private void ParseHeaders(string[] requestContent)
{
foreach (var line in requestContent)
{
if (line == "")
{
break;
}
string[] headerContent = line.Split(new char[] { ':' });
string key = string.Empty;
string value = string.Empty;
key = headerContent[0].Trim();
if (key == "Host")
{
value = (headerContent[1] + ':' + headerContent[2]).Trim();
}
else
{
value = headerContent[1].Trim();
}
var header = new HttpHeader(key, value);
this.Headers.Add(header);
}
if (!Headers.ContainsHeader("Host"))
{
throw new BadRequestException();
}
}
private void ParseHeaders(string[] requestContent)
{
foreach (var contentLine in requestContent)
{
if (contentLine.Equals(string.Empty))
{
break;
}
var headerTokens = contentLine
.Split(": ")
.ToArray();
if (headerTokens.Length != 2)
{
throw new BadRequestException();
}
var key = headerTokens[0].Trim();
var value = headerTokens[1].Trim();
var header = new HttpHeader(key, value);
Headers.Add(header);
}
if (!Headers.ContainsHeader(GlobalConstants.HostHeaderKey))
{
throw new BadRequestException();
}
}
private void ParseCookies()
{
if (Headers.ContainsHeader(GlobalConstants.HeaderCookieKey))
{
var requestCookies = Headers.GetHeader(GlobalConstants.HeaderCookieKey).Value;
if (!requestCookies.Contains(GlobalConstants.ParameterKvpSeparator))
{
throw new BadRequestException();
}
var cookies = requestCookies
.Split("; ")
.ToArray();
foreach (var cookie in cookies)
{
var cookieParts = cookie
.Split('=', 2)
.ToArray();
if (cookieParts.Length != 2)
{
continue;
}
var key = cookieParts[0];
var value = cookieParts[1];
var httpCookie = new HttpCookie(key, value, false);
Cookies.Add(httpCookie);
}
}
}
private void ParseCookies()
{
if (Headers.ContainsHeader("Cookie"))
{
var cookieValue = Headers.GetHeader("Cookie").Value;
if (string.IsNullOrEmpty(cookieValue))
{
return;
}
string[] cookies = cookieValue.Split("; ");
foreach (var splitCookie in cookies)
{
string[] cookieParts = splitCookie.Split('=', 2, StringSplitOptions.RemoveEmptyEntries);
if (cookieParts.Length != 2)
{
continue;
}
string key = cookieParts[0];
string value = cookieParts[1];
Cookies.Add(new HttpCookie(key, value, false));
}
}
}
private void ParseCookies()
{
if (!Headers.ContainsHeader(HttpHeader.Cookie))
{
return;
}
string cookiesString = Headers.GetHeader(HttpHeader.Cookie).Value;
if (string.IsNullOrEmpty(cookiesString))
{
return;
}
string[] splitCookies = cookiesString.Split(HttpRequestCookiesSeparator);
foreach (string splitCookie in splitCookies)
{
string[] cookieParts = splitCookie.Split(HttpRequestCookieNameValueSeparator, 2, StringSplitOptions.RemoveEmptyEntries);
if (cookieParts.Length != 2)
{
continue;
}
string key = cookieParts[0];
string value = cookieParts[1];
Cookies.Add(new HttpCookie(key, value, false));
}
}
private void ParseHeaders(string[] rawHeaders)
{
foreach (var rawHeader in rawHeaders)
{
string[] parts = rawHeader.Split(HttpHeaderNameValueSeparator, 2);
if (parts[0] == HttpHeader.Cookie)
{
ParseCookies(parts[1]);
continue;
}
if (parts.Length == 1 && parts[0] == string.Empty)
{
break;
}
Headers.AddHeader(new HttpHeader(parts[0], parts[1]));
}
if (!Headers.ContainsHeader(HttpHeader.Host))
{
throw new BadRequestException();
}
}
/// <summary>
/// Adds the range.
/// </summary>
/// <param name="rangeSpecifier">The range specifier.</param>
/// <param name="range">The range.</param>
public void AddRange(string rangeSpecifier, int range)
{
if (rangeSpecifier == null)
{
throw new ArgumentNullException(nameof(rangeSpecifier));
}
string header, value = null;
var rangeKeyExists = Headers.ContainsHeader(HttpRequestHeader.Range, out header);
if (rangeKeyExists)
{
value = Headers[HttpRequestHeader.Range];
}
if (string.IsNullOrEmpty(value))
{
value = rangeSpecifier + "=";
}
else if (value.StartsWith(rangeSpecifier + "=", StringComparison.OrdinalIgnoreCase))
{
value += ",";
}
else
{
throw new InvalidOperationException("rangeSpecifier");
}
if (rangeKeyExists)
{
Headers.Remove(HttpRequestHeader.Range);
}
Headers.Add(HttpRequestHeader.Range, value + range + "-");
}
private void ParseHeaders(string[] requestContent)
{
int currentIndex = 0;
while (!string.IsNullOrEmpty(requestContent[currentIndex]))
{
string[] headerArguments = requestContent[currentIndex++].Split(HttpRequestHeaderNameValueSeparator);
Headers.Add(new HttpHeader(headerArguments[0], headerArguments[1]));
}
if (!Headers.ContainsHeader(GlobalConstants.HostHeaderKey))
{
throw new BadRequestException();
}
}
private void ParseHeaders(string[] toArray)
{
int endIndex = Array.IndexOf(toArray, string.Empty);
for (int i = 0; i < endIndex; i++)
{
string[] line = toArray[i].Split(new[] { ": " }, StringSplitOptions.None).ToArray();
HttpHeader temp = new HttpHeader(line[0], line[1]);
Headers.Add(temp);
}
if (!Headers.ContainsHeader("Host"))
{
throw new BadRequestException();
}
}
/// <summary>
/// Adds the range.
/// </summary>
/// <param name="rangeSpecifier">The range specifier.</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
public void AddRange(string rangeSpecifier, int from, int to)
{
if (rangeSpecifier == null)
{
throw new ArgumentNullException(nameof(rangeSpecifier));
}
if (from < 0 || to < 0 || from > to)
{
throw new ArgumentOutOfRangeException();
}
string header, value = null;
var rangeKeyExists = Headers.ContainsHeader(HttpRequestHeader.Range, out header);
if (rangeKeyExists)
{
value = Headers[HttpRequestHeader.Range];
}
if (string.IsNullOrEmpty(value))
{
value = rangeSpecifier + "=";
}
else if (value.ToLower().StartsWith(rangeSpecifier.ToLower() + "="))
{
value += ",";
}
else
{
throw new InvalidOperationException("rangeSpecifier");
}
if (rangeKeyExists)
{
Headers.Remove(Headers[HttpRequestHeader.Range]);
}
Headers.Add(HttpRequestHeader.Range, value + from + "-" + to);
}
private void ParseCookies()
{
if (!Headers.ContainsHeader(GlobalConstants.HttpRequestCookieHeaderName))
{
return;
}
string rawCookies = Headers.GetHeader(GlobalConstants.HttpRequestCookieHeaderName).Value;
string[] cookiesSplit = rawCookies.Split(new[] { "; " }, StringSplitOptions.RemoveEmptyEntries);
foreach (string cookie in cookiesSplit)
{
string[] cookieKeyValue = cookie.Split(new [] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (cookieKeyValue.Length != 2)
{
throw new BadRequestException();
}
Cookies.Add(new HttpCookie(cookieKeyValue[0], cookieKeyValue[1]));
}
}
private void ParseHeaders(string[] requestContent)
{
if (!requestContent.Any())
{
throw new BadRequestException();
}
foreach (string line in requestContent)
{
if (string.IsNullOrWhiteSpace(line))
{
return;
}
string[] parts = line.Split(new[] { ": " }, StringSplitOptions.RemoveEmptyEntries);
HttpHeader header = new HttpHeader(parts[0], parts[1]);
Headers.Add(header);
}
if (!Headers.ContainsHeader(GlobalConstants.HostHeaderKey))
{
throw new BadRequestException();
}
}
public void ContainsHeaderTakesInAStringAndReturnsFalseWhenNoMatchingHeaderExists()
{
var testHeaders = new Headers("hello", "world");
Assert.False(testHeaders.ContainsHeader("test"));
}
public void ContainsHeaderTakesInAStringAndReturnsTrueWhenAMatchingHeaderExists(string dynamicName)
{
var testHeaders = new Headers(dynamicName, "header");
Assert.True(testHeaders.ContainsHeader("test"));
}
