mirror of
https://github.com/jellyfin/jellyfin.git
synced 2025-10-31 00:01:12 +01:00
244 lines
9.7 KiB
C#
244 lines
9.7 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Text;
|
|
|
|
namespace Rssdp.Infrastructure
|
|
{
|
|
/// <summary>
|
|
/// A base class for the <see cref="HttpResponseParser"/> and <see cref="HttpRequestParser"/> classes. Not intended for direct use.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public abstract class HttpParserBase<T> where T : new()
|
|
{
|
|
|
|
#region Fields
|
|
|
|
private static readonly string[] LineTerminators = new string[] { "\r\n", "\n" };
|
|
private static readonly char[] SeparatorCharacters = new char[] { ',', ';' };
|
|
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Parses the <paramref name="data"/> provided into either a <see cref="System.Net.Http.HttpRequestMessage"/> or <see cref="System.Net.Http.HttpResponseMessage"/> object.
|
|
/// </summary>
|
|
/// <param name="data">A string containing the HTTP message to parse.</param>
|
|
/// <returns>Either a <see cref="System.Net.Http.HttpRequestMessage"/> or <see cref="System.Net.Http.HttpResponseMessage"/> object containing the parsed data.</returns>
|
|
public abstract T Parse(string data);
|
|
|
|
/// <summary>
|
|
/// Parses a string containing either an HTTP request or response into a <see cref="System.Net.Http.HttpRequestMessage"/> or <see cref="System.Net.Http.HttpResponseMessage"/> object.
|
|
/// </summary>
|
|
/// <param name="message">A <see cref="System.Net.Http.HttpRequestMessage"/> or <see cref="System.Net.Http.HttpResponseMessage"/> object representing the parsed message.</param>
|
|
/// <param name="headers">A reference to the <see cref="System.Net.Http.Headers.HttpHeaders"/> collection for the <paramref name="message"/> object.</param>
|
|
/// <param name="data">A string containing the data to be parsed.</param>
|
|
/// <returns>An <see cref="System.Net.Http.HttpContent"/> object containing the content of the parsed message.</returns>
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification="Honestly, it's fine. MemoryStream doesn't mind.")]
|
|
protected virtual HttpContent Parse(T message, System.Net.Http.Headers.HttpHeaders headers, string data)
|
|
{
|
|
if (data == null) throw new ArgumentNullException("data");
|
|
if (data.Length == 0) throw new ArgumentException("data cannot be an empty string.", "data");
|
|
if (!LineTerminators.Any(data.Contains)) throw new ArgumentException("data is not a valid request, it does not contain any CRLF/LF terminators.", "data");
|
|
|
|
HttpContent retVal = null;
|
|
try
|
|
{
|
|
var contentStream = new System.IO.MemoryStream();
|
|
try
|
|
{
|
|
retVal = new StreamContent(contentStream);
|
|
|
|
var lines = data.Split(LineTerminators, StringSplitOptions.None);
|
|
|
|
//First line is the 'request' line containing http protocol details like method, uri, http version etc.
|
|
ParseStatusLine(lines[0], message);
|
|
|
|
int lineIndex = ParseHeaders(headers, retVal.Headers, lines);
|
|
|
|
if (lineIndex < lines.Length - 1)
|
|
{
|
|
//Read rest of any remaining data as content.
|
|
if (lineIndex < lines.Length - 1)
|
|
{
|
|
//This is inefficient in multiple ways, but not sure of a good way of correcting. Revisit.
|
|
var body = System.Text.UTF8Encoding.UTF8.GetBytes(String.Join(null, lines, lineIndex, lines.Length - lineIndex));
|
|
contentStream.Write(body, 0, body.Length);
|
|
contentStream.Seek(0, System.IO.SeekOrigin.Begin);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
if (contentStream != null)
|
|
contentStream.Dispose();
|
|
|
|
throw;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
if (retVal != null)
|
|
retVal.Dispose();
|
|
|
|
throw;
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used to parse the first line of an HTTP request or response and assign the values to the appropriate properties on the <paramref name="message"/>.
|
|
/// </summary>
|
|
/// <param name="data">The first line of the HTTP message to be parsed.</param>
|
|
/// <param name="message">Either a <see cref="System.Net.Http.HttpResponseMessage"/> or <see cref="System.Net.Http.HttpRequestMessage"/> to assign the parsed values to.</param>
|
|
protected abstract void ParseStatusLine(string data, T message);
|
|
|
|
/// <summary>
|
|
/// Returns a boolean indicating whether the specified HTTP header name represents a content header (true), or a message header (false).
|
|
/// </summary>
|
|
/// <param name="headerName">A string containing the name of the header to return the type of.</param>
|
|
protected abstract bool IsContentHeader(string headerName);
|
|
|
|
/// <summary>
|
|
/// Parses the HTTP version text from an HTTP request or response status line and returns a <see cref="Version"/> object representing the parsed values.
|
|
/// </summary>
|
|
/// <param name="versionData">A string containing the HTTP version, from the message status line.</param>
|
|
/// <returns>A <see cref="Version"/> object containing the parsed version data.</returns>
|
|
protected static Version ParseHttpVersion(string versionData)
|
|
{
|
|
if (versionData == null) throw new ArgumentNullException("versionData");
|
|
|
|
var versionSeparatorIndex = versionData.IndexOf('/');
|
|
if (versionSeparatorIndex <= 0 || versionSeparatorIndex == versionData.Length) throw new ArgumentException("request header line is invalid. Http Version not supplied or incorrect format.", "versionData");
|
|
|
|
return Version.Parse(versionData.Substring(versionSeparatorIndex + 1));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Parses a line from an HTTP request or response message containing a header name and value pair.
|
|
/// </summary>
|
|
/// <param name="line">A string containing the data to be parsed.</param>
|
|
/// <param name="headers">A reference to a <see cref="System.Net.Http.Headers.HttpHeaders"/> collection to which the parsed header will be added.</param>
|
|
/// <param name="contentHeaders">A reference to a <see cref="System.Net.Http.Headers.HttpHeaders"/> collection for the message content, to which the parsed header will be added.</param>
|
|
private void ParseHeader(string line, System.Net.Http.Headers.HttpHeaders headers, System.Net.Http.Headers.HttpHeaders contentHeaders)
|
|
{
|
|
//Header format is
|
|
//name: value
|
|
var headerKeySeparatorIndex = line.IndexOf(":", StringComparison.OrdinalIgnoreCase);
|
|
var headerName = line.Substring(0, headerKeySeparatorIndex).Trim();
|
|
var headerValue = line.Substring(headerKeySeparatorIndex + 1).Trim();
|
|
|
|
//Not sure how to determine where request headers and and content headers begin,
|
|
//at least not without a known set of headers (general headers first the content headers)
|
|
//which seems like a bad way of doing it. So we'll assume if it's a known content header put it there
|
|
//else use request headers.
|
|
|
|
var values = ParseValues(headerValue);
|
|
var headersToAddTo = IsContentHeader(headerName) ? contentHeaders : headers;
|
|
|
|
if (values.Count > 1)
|
|
headersToAddTo.TryAddWithoutValidation(headerName, values);
|
|
else
|
|
headersToAddTo.TryAddWithoutValidation(headerName, values.First());
|
|
}
|
|
|
|
private int ParseHeaders(System.Net.Http.Headers.HttpHeaders headers, System.Net.Http.Headers.HttpHeaders contentHeaders, string[] lines)
|
|
{
|
|
//Blank line separates headers from content, so read headers until we find blank line.
|
|
int lineIndex = 1;
|
|
string line = null, nextLine = null;
|
|
while (lineIndex + 1 < lines.Length && !String.IsNullOrEmpty((line = lines[lineIndex++])))
|
|
{
|
|
//If the following line starts with space or tab (or any whitespace), it is really part of this header but split for human readability.
|
|
//Combine these lines into a single comma separated style header for easier parsing.
|
|
while (lineIndex < lines.Length && !String.IsNullOrEmpty((nextLine = lines[lineIndex])))
|
|
{
|
|
if (nextLine.Length > 0 && Char.IsWhiteSpace(nextLine[0]))
|
|
{
|
|
line += "," + nextLine.TrimStart();
|
|
lineIndex++;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
ParseHeader(line, headers, contentHeaders);
|
|
}
|
|
return lineIndex;
|
|
}
|
|
|
|
private static IList<string> ParseValues(string headerValue)
|
|
{
|
|
// This really should be better and match the HTTP 1.1 spec,
|
|
// but this should actually be good enough for SSDP implementations
|
|
// I think.
|
|
var values = new List<string>();
|
|
|
|
if (headerValue == "\"\"")
|
|
{
|
|
values.Add(String.Empty);
|
|
return values;
|
|
}
|
|
|
|
var indexOfSeparator = headerValue.IndexOfAny(SeparatorCharacters);
|
|
if (indexOfSeparator <= 0)
|
|
values.Add(headerValue);
|
|
else
|
|
{
|
|
var segments = headerValue.Split(SeparatorCharacters);
|
|
if (headerValue.Contains("\""))
|
|
{
|
|
for (int segmentIndex = 0; segmentIndex < segments.Length; segmentIndex++)
|
|
{
|
|
var segment = segments[segmentIndex];
|
|
if (segment.Trim().StartsWith("\"", StringComparison.OrdinalIgnoreCase))
|
|
segment = CombineQuotedSegments(segments, ref segmentIndex, segment);
|
|
|
|
values.Add(segment);
|
|
}
|
|
}
|
|
else
|
|
values.AddRange(segments);
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
private static string CombineQuotedSegments(string[] segments, ref int segmentIndex, string segment)
|
|
{
|
|
var trimmedSegment = segment.Trim();
|
|
for (int index = segmentIndex; index < segments.Length; index++)
|
|
{
|
|
if (trimmedSegment == "\"\"" ||
|
|
(
|
|
trimmedSegment.EndsWith("\"", StringComparison.OrdinalIgnoreCase)
|
|
&& !trimmedSegment.EndsWith("\"\"", StringComparison.OrdinalIgnoreCase)
|
|
&& !trimmedSegment.EndsWith("\\\"", StringComparison.OrdinalIgnoreCase))
|
|
)
|
|
{
|
|
segmentIndex = index;
|
|
return trimmedSegment.Substring(1, trimmedSegment.Length - 2);
|
|
}
|
|
|
|
if (index + 1 < segments.Length)
|
|
trimmedSegment += "," + segments[index + 1].TrimEnd();
|
|
}
|
|
|
|
segmentIndex = segments.Length;
|
|
if (trimmedSegment.StartsWith("\"", StringComparison.OrdinalIgnoreCase) && trimmedSegment.EndsWith("\"", StringComparison.OrdinalIgnoreCase))
|
|
return trimmedSegment.Substring(1, trimmedSegment.Length - 2);
|
|
else
|
|
return trimmedSegment;
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
} |