mirror of
https://github.com/jellyfin/jellyfin.git
synced 2026-04-29 21:36:31 +01:00
Pushing missing changes
This commit is contained in:
LukePulverenti
@@ -1,249 +1,264 @@
|
||||
using MediaBrowser.Common.Logging;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Net;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace MediaBrowser.Common.Net.Handlers
|
||||
{
|
||||
public class StaticFileHandler : BaseHandler
|
||||
{
|
||||
public override bool HandlesRequest(HttpListenerRequest request)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private string _path;
|
||||
public virtual string Path
|
||||
{
|
||||
get
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(_path))
|
||||
{
|
||||
return _path;
|
||||
}
|
||||
|
||||
return QueryString["path"];
|
||||
}
|
||||
set
|
||||
{
|
||||
_path = value;
|
||||
}
|
||||
}
|
||||
|
||||
private Stream SourceStream { get; set; }
|
||||
|
||||
protected override bool SupportsByteRangeRequests
|
||||
{
|
||||
get
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private bool ShouldCompressResponse(string contentType)
|
||||
{
|
||||
// Can't compress these
|
||||
if (IsRangeRequest)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Don't compress media
|
||||
if (contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) || contentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// It will take some work to support compression within this handler
|
||||
return false;
|
||||
}
|
||||
|
||||
protected override long? GetTotalContentLength()
|
||||
{
|
||||
return SourceStream.Length;
|
||||
}
|
||||
|
||||
protected override Task<ResponseInfo> GetResponseInfo()
|
||||
{
|
||||
ResponseInfo info = new ResponseInfo
|
||||
{
|
||||
ContentType = MimeTypes.GetMimeType(Path),
|
||||
};
|
||||
|
||||
try
|
||||
{
|
||||
SourceStream = File.OpenRead(Path);
|
||||
}
|
||||
catch (FileNotFoundException ex)
|
||||
{
|
||||
info.StatusCode = 404;
|
||||
Logger.LogException(ex);
|
||||
}
|
||||
catch (DirectoryNotFoundException ex)
|
||||
{
|
||||
info.StatusCode = 404;
|
||||
Logger.LogException(ex);
|
||||
}
|
||||
catch (UnauthorizedAccessException ex)
|
||||
{
|
||||
info.StatusCode = 403;
|
||||
Logger.LogException(ex);
|
||||
}
|
||||
|
||||
info.CompressResponse = ShouldCompressResponse(info.ContentType);
|
||||
|
||||
if (SourceStream != null)
|
||||
{
|
||||
info.DateLastModified = File.GetLastWriteTimeUtc(Path);
|
||||
}
|
||||
|
||||
return Task.FromResult<ResponseInfo>(info);
|
||||
}
|
||||
|
||||
protected override Task WriteResponseToOutputStream(Stream stream)
|
||||
{
|
||||
if (IsRangeRequest)
|
||||
{
|
||||
KeyValuePair<long, long?> requestedRange = RequestedRanges.First();
|
||||
|
||||
// If the requested range is "0-" and we know the total length, we can optimize by avoiding having to buffer the content into memory
|
||||
if (requestedRange.Value == null && TotalContentLength != null)
|
||||
{
|
||||
return ServeCompleteRangeRequest(requestedRange, stream);
|
||||
}
|
||||
if (TotalContentLength.HasValue)
|
||||
{
|
||||
// This will have to buffer a portion of the content into memory
|
||||
return ServePartialRangeRequestWithKnownTotalContentLength(requestedRange, stream);
|
||||
}
|
||||
|
||||
// This will have to buffer the entire content into memory
|
||||
return ServePartialRangeRequestWithUnknownTotalContentLength(requestedRange, stream);
|
||||
}
|
||||
|
||||
return SourceStream.CopyToAsync(stream);
|
||||
}
|
||||
|
||||
protected override void DisposeResponseStream()
|
||||
{
|
||||
base.DisposeResponseStream();
|
||||
|
||||
if (SourceStream != null)
|
||||
{
|
||||
SourceStream.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handles a range request of "bytes=0-"
|
||||
/// This will serve the complete content and add the content-range header
|
||||
/// </summary>
|
||||
private Task ServeCompleteRangeRequest(KeyValuePair<long, long?> requestedRange, Stream responseStream)
|
||||
{
|
||||
long totalContentLength = TotalContentLength.Value;
|
||||
|
||||
long rangeStart = requestedRange.Key;
|
||||
long rangeEnd = totalContentLength - 1;
|
||||
long rangeLength = 1 + rangeEnd - rangeStart;
|
||||
|
||||
// Content-Length is the length of what we're serving, not the original content
|
||||
HttpListenerContext.Response.ContentLength64 = rangeLength;
|
||||
HttpListenerContext.Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
|
||||
|
||||
if (rangeStart > 0)
|
||||
{
|
||||
SourceStream.Position = rangeStart;
|
||||
}
|
||||
|
||||
return SourceStream.CopyToAsync(responseStream);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Serves a partial range request where the total content length is not known
|
||||
/// </summary>
|
||||
private async Task ServePartialRangeRequestWithUnknownTotalContentLength(KeyValuePair<long, long?> requestedRange, Stream responseStream)
|
||||
{
|
||||
// Read the entire stream so that we can determine the length
|
||||
byte[] bytes = await ReadBytes(SourceStream, 0, null).ConfigureAwait(false);
|
||||
|
||||
long totalContentLength = bytes.LongLength;
|
||||
|
||||
long rangeStart = requestedRange.Key;
|
||||
long rangeEnd = requestedRange.Value ?? (totalContentLength - 1);
|
||||
long rangeLength = 1 + rangeEnd - rangeStart;
|
||||
|
||||
// Content-Length is the length of what we're serving, not the original content
|
||||
HttpListenerContext.Response.ContentLength64 = rangeLength;
|
||||
HttpListenerContext.Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
|
||||
|
||||
await responseStream.WriteAsync(bytes, Convert.ToInt32(rangeStart), Convert.ToInt32(rangeLength)).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Serves a partial range request where the total content length is already known
|
||||
/// </summary>
|
||||
private async Task ServePartialRangeRequestWithKnownTotalContentLength(KeyValuePair<long, long?> requestedRange, Stream responseStream)
|
||||
{
|
||||
long totalContentLength = TotalContentLength.Value;
|
||||
long rangeStart = requestedRange.Key;
|
||||
long rangeEnd = requestedRange.Value ?? (totalContentLength - 1);
|
||||
long rangeLength = 1 + rangeEnd - rangeStart;
|
||||
|
||||
// Only read the bytes we need
|
||||
byte[] bytes = await ReadBytes(SourceStream, Convert.ToInt32(rangeStart), Convert.ToInt32(rangeLength)).ConfigureAwait(false);
|
||||
|
||||
// Content-Length is the length of what we're serving, not the original content
|
||||
HttpListenerContext.Response.ContentLength64 = rangeLength;
|
||||
|
||||
HttpListenerContext.Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
|
||||
|
||||
await responseStream.WriteAsync(bytes, 0, Convert.ToInt32(rangeLength)).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reads bytes from a stream
|
||||
/// </summary>
|
||||
/// <param name="input">The input stream</param>
|
||||
/// <param name="start">The starting position</param>
|
||||
/// <param name="count">The number of bytes to read, or null to read to the end.</param>
|
||||
private async Task<byte[]> ReadBytes(Stream input, int start, int? count)
|
||||
{
|
||||
if (start > 0)
|
||||
{
|
||||
input.Position = start;
|
||||
}
|
||||
|
||||
if (count == null)
|
||||
{
|
||||
var buffer = new byte[16 * 1024];
|
||||
|
||||
using (var ms = new MemoryStream())
|
||||
{
|
||||
int read;
|
||||
while ((read = await input.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) > 0)
|
||||
{
|
||||
await ms.WriteAsync(buffer, 0, read).ConfigureAwait(false);
|
||||
}
|
||||
return ms.ToArray();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
var buffer = new byte[count.Value];
|
||||
|
||||
using (var ms = new MemoryStream())
|
||||
{
|
||||
int read = await input.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
|
||||
|
||||
await ms.WriteAsync(buffer, 0, read).ConfigureAwait(false);
|
||||
|
||||
return ms.ToArray();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
using MediaBrowser.Common.Extensions;
|
||||
using MediaBrowser.Common.IO;
|
||||
using MediaBrowser.Common.Kernel;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace MediaBrowser.Common.Net.Handlers
|
||||
{
|
||||
/// <summary>
|
||||
/// Represents an http handler that serves static content
|
||||
/// </summary>
|
||||
public class StaticFileHandler : BaseHandler<IKernel>
|
||||
{
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="StaticFileHandler" /> class.
|
||||
/// </summary>
|
||||
/// <param name="kernel">The kernel.</param>
|
||||
public StaticFileHandler(IKernel kernel)
|
||||
{
|
||||
Initialize(kernel);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The _path
|
||||
/// </summary>
|
||||
private string _path;
|
||||
/// <summary>
|
||||
/// Gets or sets the path to the static resource
|
||||
/// </summary>
|
||||
/// <value>The path.</value>
|
||||
public string Path
|
||||
{
|
||||
get
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(_path))
|
||||
{
|
||||
return _path;
|
||||
}
|
||||
|
||||
return QueryString["path"];
|
||||
}
|
||||
set
|
||||
{
|
||||
_path = value;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets or sets the last date modified of the resource
|
||||
/// </summary>
|
||||
/// <value>The last date modified.</value>
|
||||
public DateTime? LastDateModified { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets or sets the content type of the resource
|
||||
/// </summary>
|
||||
/// <value>The type of the content.</value>
|
||||
public string ContentType { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets or sets the content type of the resource
|
||||
/// </summary>
|
||||
/// <value>The etag.</value>
|
||||
public Guid Etag { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets or sets the source stream of the resource
|
||||
/// </summary>
|
||||
/// <value>The source stream.</value>
|
||||
public Stream SourceStream { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Shoulds the compress response.
|
||||
/// </summary>
|
||||
/// <param name="contentType">Type of the content.</param>
|
||||
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
|
||||
private bool ShouldCompressResponse(string contentType)
|
||||
{
|
||||
// It will take some work to support compression with byte range requests
|
||||
if (IsRangeRequest)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Don't compress media
|
||||
if (contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) || contentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Don't compress images
|
||||
if (contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets or sets the duration of the cache.
|
||||
/// </summary>
|
||||
/// <value>The duration of the cache.</value>
|
||||
public TimeSpan? CacheDuration { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the total length of the content.
|
||||
/// </summary>
|
||||
/// <param name="responseInfo">The response info.</param>
|
||||
/// <returns>System.Nullable{System.Int64}.</returns>
|
||||
protected override long? GetTotalContentLength(ResponseInfo responseInfo)
|
||||
{
|
||||
// If we're compressing the response, content length must be the compressed length, which we don't know
|
||||
if (responseInfo.CompressResponse && ClientSupportsCompression)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
return SourceStream.Length;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the response info.
|
||||
/// </summary>
|
||||
/// <returns>Task{ResponseInfo}.</returns>
|
||||
protected override Task<ResponseInfo> GetResponseInfo()
|
||||
{
|
||||
var info = new ResponseInfo
|
||||
{
|
||||
ContentType = ContentType ?? MimeTypes.GetMimeType(Path),
|
||||
Etag = Etag,
|
||||
DateLastModified = LastDateModified
|
||||
};
|
||||
|
||||
if (SourceStream == null && !string.IsNullOrEmpty(Path))
|
||||
{
|
||||
// FileShare must be ReadWrite in case someone else is currently writing to it.
|
||||
SourceStream = new FileStream(Path, FileMode.Open, FileAccess.Read, FileShare.Read, StreamDefaults.DefaultFileStreamBufferSize, FileOptions.Asynchronous);
|
||||
}
|
||||
|
||||
info.CompressResponse = ShouldCompressResponse(info.ContentType);
|
||||
|
||||
info.SupportsByteRangeRequests = !info.CompressResponse || !ClientSupportsCompression;
|
||||
|
||||
if (!info.DateLastModified.HasValue && !string.IsNullOrWhiteSpace(Path))
|
||||
{
|
||||
info.DateLastModified = File.GetLastWriteTimeUtc(Path);
|
||||
}
|
||||
|
||||
if (CacheDuration.HasValue)
|
||||
{
|
||||
info.CacheDuration = CacheDuration.Value;
|
||||
}
|
||||
|
||||
if (SourceStream == null && string.IsNullOrEmpty(Path))
|
||||
{
|
||||
throw new ResourceNotFoundException();
|
||||
}
|
||||
|
||||
return Task.FromResult(info);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the response to output stream.
|
||||
/// </summary>
|
||||
/// <param name="stream">The stream.</param>
|
||||
/// <param name="responseInfo">The response info.</param>
|
||||
/// <param name="totalContentLength">Total length of the content.</param>
|
||||
/// <returns>Task.</returns>
|
||||
protected override Task WriteResponseToOutputStream(Stream stream, ResponseInfo responseInfo, long? totalContentLength)
|
||||
{
|
||||
if (IsRangeRequest && totalContentLength.HasValue)
|
||||
{
|
||||
var requestedRange = RequestedRanges.First();
|
||||
|
||||
// If the requested range is "0-", we can optimize by just doing a stream copy
|
||||
if (!requestedRange.Value.HasValue)
|
||||
{
|
||||
return ServeCompleteRangeRequest(requestedRange, stream, totalContentLength.Value);
|
||||
}
|
||||
|
||||
// This will have to buffer a portion of the content into memory
|
||||
return ServePartialRangeRequest(requestedRange.Key, requestedRange.Value.Value, stream, totalContentLength.Value);
|
||||
}
|
||||
|
||||
return SourceStream.CopyToAsync(stream);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Disposes the response stream.
|
||||
/// </summary>
|
||||
protected override void DisposeResponseStream()
|
||||
{
|
||||
if (SourceStream != null)
|
||||
{
|
||||
SourceStream.Dispose();
|
||||
}
|
||||
|
||||
base.DisposeResponseStream();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handles a range request of "bytes=0-"
|
||||
/// This will serve the complete content and add the content-range header
|
||||
/// </summary>
|
||||
/// <param name="requestedRange">The requested range.</param>
|
||||
/// <param name="responseStream">The response stream.</param>
|
||||
/// <param name="totalContentLength">Total length of the content.</param>
|
||||
/// <returns>Task.</returns>
|
||||
private Task ServeCompleteRangeRequest(KeyValuePair<long, long?> requestedRange, Stream responseStream, long totalContentLength)
|
||||
{
|
||||
var rangeStart = requestedRange.Key;
|
||||
var rangeEnd = totalContentLength - 1;
|
||||
var rangeLength = 1 + rangeEnd - rangeStart;
|
||||
|
||||
// Content-Length is the length of what we're serving, not the original content
|
||||
HttpListenerContext.Response.ContentLength64 = rangeLength;
|
||||
HttpListenerContext.Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
|
||||
|
||||
if (rangeStart > 0)
|
||||
{
|
||||
SourceStream.Position = rangeStart;
|
||||
}
|
||||
|
||||
return SourceStream.CopyToAsync(responseStream);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Serves a partial range request
|
||||
/// </summary>
|
||||
/// <param name="rangeStart">The range start.</param>
|
||||
/// <param name="rangeEnd">The range end.</param>
|
||||
/// <param name="responseStream">The response stream.</param>
|
||||
/// <param name="totalContentLength">Total length of the content.</param>
|
||||
/// <returns>Task.</returns>
|
||||
private async Task ServePartialRangeRequest(long rangeStart, long rangeEnd, Stream responseStream, long totalContentLength)
|
||||
{
|
||||
var rangeLength = 1 + rangeEnd - rangeStart;
|
||||
|
||||
// Content-Length is the length of what we're serving, not the original content
|
||||
HttpListenerContext.Response.ContentLength64 = rangeLength;
|
||||
HttpListenerContext.Response.Headers["Content-Range"] = string.Format("bytes {0}-{1}/{2}", rangeStart, rangeEnd, totalContentLength);
|
||||
|
||||
SourceStream.Position = rangeStart;
|
||||
|
||||
// Fast track to just copy the stream to the end
|
||||
if (rangeEnd == totalContentLength - 1)
|
||||
{
|
||||
await SourceStream.CopyToAsync(responseStream).ConfigureAwait(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Read the bytes we need
|
||||
var buffer = new byte[Convert.ToInt32(rangeLength)];
|
||||
await SourceStream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
|
||||
|
||||
await responseStream.WriteAsync(buffer, 0, Convert.ToInt32(rangeLength)).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user