mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 3.6.0

Browse Source 
Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14
This commit is contained in:
Jo Shields
2014-08-13 10:39:27 +01:00
commit a575963da9
50588 changed files with 8155799 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
external/aspnetwebstack/src/System.Net.Http.Formatting/Headers/CookieHeaderValue.cs vendored Normal file
View File

@@ -0,0 +1,302 @@
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Net.Http.Formatting;
using System.Text;
using System.Web.Http;
namespace System.Net.Http.Headers
{
public class CookieHeaderValue : ICloneable
{
private const string ExpiresToken = "expires";
private const string MaxAgeToken = "max-age";
private const string DomainToken = "domain";
private const string PathToken = "path";
private const string SecureToken = "secure";
private const string HttpOnlyToken = "httponly";
private const string DefaultPath = "/";
private static readonly char[] segmentSeparator = new char[] { ';' };
private static readonly char[] nameValueSeparator = new char[] { '=' };
// Use list instead of dictionary since we may have multiple parameters with the same name.
private Collection<CookieState> _cookies;
public CookieHeaderValue(string name, string value)
{
CookieState cookie = new CookieState(name, value);
Cookies.Add(cookie);
}
public CookieHeaderValue(string name, NameValueCollection values)
{
CookieState cookie = new CookieState(name, values);
Cookies.Add(cookie);
}
/// <summary>
/// Constructor to be used by parser to create a new instance of this type.
/// </summary>
protected CookieHeaderValue()
{
}
private CookieHeaderValue(CookieHeaderValue source)
{
if (source == null)
{
throw Error.ArgumentNull("source");
}
Expires = source.Expires;
MaxAge = source.MaxAge;
Domain = source.Domain;
Path = source.Path;
Secure = source.Secure;
HttpOnly = source.HttpOnly;
foreach (CookieState cookie in source.Cookies)
{
Cookies.Add(cookie.Clone<CookieState>());
}
}
public Collection<CookieState> Cookies
{
get
{
if (_cookies == null)
{
_cookies = new Collection<CookieState>();
}
return _cookies;
}
}
public DateTimeOffset? Expires { get; set; }
public TimeSpan? MaxAge { get; set; }
public string Domain { get; set; }
public string Path { get; set; }
public bool Secure { get; set; }
public bool HttpOnly { get; set; }
public CookieState this[string name]
{
get
{
if (String.IsNullOrEmpty(name))
{
return null;
}
CookieState cookie = Cookies.FirstOrDefault(c => String.Equals(c.Name, name, StringComparison.OrdinalIgnoreCase));
if (cookie == null)
{
cookie = new CookieState(name, String.Empty);
Cookies.Add(cookie);
}
return cookie;
}
}
public override string ToString()
{
StringBuilder header = new StringBuilder();
bool first = true;
foreach (CookieState cookie in Cookies)
{
first = AppendSegment(header, first, cookie.ToString(), null);
}
if (Expires.HasValue)
{
first = AppendSegment(header, first, ExpiresToken, FormattingUtilities.DateToString(Expires.Value));
}
if (MaxAge.HasValue)
{
first = AppendSegment(header, first, MaxAgeToken, ((int)MaxAge.Value.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo));
}
if (Domain != null)
{
first = AppendSegment(header, first, DomainToken, Domain);
}
if (Path != null)
{
first = AppendSegment(header, first, PathToken, Path);
}
if (Secure)
{
first = AppendSegment(header, first, SecureToken, null);
}
if (HttpOnly)
{
first = AppendSegment(header, first, HttpOnlyToken, null);
}
return header.ToString();
}
public object Clone()
{
return new CookieHeaderValue(this);
}
public static bool TryParse(string input, out CookieHeaderValue parsedValue)
{
parsedValue = null;
if (!String.IsNullOrEmpty(input))
{
string[] segments = input.Split(segmentSeparator);
CookieHeaderValue instance = new CookieHeaderValue();
foreach (string segment in segments)
{
if (!ParseCookieSegment(instance, segment))
{
return false;
}
}
// If we didn't find any cookie state name/value pairs then cookie is not valid
if (instance.Cookies.Count == 0)
{
return false;
}
parsedValue = instance;
return true;
}
return false;
}
private static bool AppendSegment(StringBuilder builder, bool first, string name, string value)
{
if (first)
{
first = false;
}
else
{
builder.Append("; ");
}
builder.Append(name);
if (value != null)
{
builder.Append("=");
builder.Append(value);
}
return first;
}
[SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This is a try method where we do want to ignore errors.")]
private static bool ParseCookieSegment(CookieHeaderValue instance, string segment)
{
if (String.IsNullOrWhiteSpace(segment))
{
return true;
}
string[] nameValue = segment.Split(nameValueSeparator, 2);
if (nameValue.Length < 1 || String.IsNullOrWhiteSpace(nameValue[0]))
{
return false;
}
string name = nameValue[0].Trim();
if (String.Equals(name, ExpiresToken, StringComparison.OrdinalIgnoreCase))
{
string value = GetSegmentValue(nameValue, null);
DateTimeOffset expires;
if (FormattingUtilities.TryParseDate(value, out expires))
{
instance.Expires = expires;
return true;
}
return false;
}
else if (String.Equals(name, MaxAgeToken, StringComparison.OrdinalIgnoreCase))
{
string value = GetSegmentValue(nameValue, null);
int maxAge;
if (FormattingUtilities.TryParseInt32(value, out maxAge))
{
instance.MaxAge = new TimeSpan(0, 0, maxAge);
return true;
}
return false;
}
else if (String.Equals(name, DomainToken, StringComparison.OrdinalIgnoreCase))
{
instance.Domain = GetSegmentValue(nameValue, null);
return true;
}
else if (String.Equals(name, PathToken, StringComparison.OrdinalIgnoreCase))
{
instance.Path = GetSegmentValue(nameValue, DefaultPath);
return true;
}
else if (String.Equals(name, SecureToken, StringComparison.OrdinalIgnoreCase))
{
string value = GetSegmentValue(nameValue, null);
if (!String.IsNullOrWhiteSpace(value))
{
return false;
}
instance.Secure = true;
return true;
}
else if (String.Equals(name, HttpOnlyToken, StringComparison.OrdinalIgnoreCase))
{
string value = GetSegmentValue(nameValue, null);
if (!String.IsNullOrWhiteSpace(value))
{
return false;
}
instance.HttpOnly = true;
return true;
}
else
{
string value = GetSegmentValue(nameValue, null);
// We read the cookie segment as form data
try
{
FormDataCollection formData = new FormDataCollection(value);
NameValueCollection values = formData.ReadAsNameValueCollection();
CookieState cookie = new CookieState(name, values);
instance.Cookies.Add(cookie);
return true;
}
catch
{
return false;
}
}
}
private static string GetSegmentValue(string[] nameValuePair, string defaultValue)
{
Contract.Assert(nameValuePair != null);
return nameValuePair.Length > 1 ? FormattingUtilities.UnquoteToken(nameValuePair[1]) : defaultValue;
}
}
}

129
external/aspnetwebstack/src/System.Net.Http.Formatting/Headers/CookieState.cs vendored Normal file
View File

@@ -0,0 +1,129 @@
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
using System.Collections.Specialized;
using System.Diagnostics.Contracts;
using System.Net.Http.Formatting.Internal;
using System.Web.Http;
namespace System.Net.Http.Headers
{
public class CookieState : ICloneable
{
private string _name;
private NameValueCollection _values = HttpValueCollection.Create();
public CookieState(string name)
: this(name, String.Empty)
{
}
public CookieState(string name, string value)
{
CheckNameFormat(name, "name");
_name = name;
CheckValueFormat(value, "value");
Value = value;
}
public CookieState(string name, NameValueCollection values)
{
CheckNameFormat(name, "name");
_name = name;
if (values == null)
{
throw Error.ArgumentNull("values");
}
Values.Add(values);
}
private CookieState(CookieState source)
{
Contract.Requires(source != null);
_name = source._name;
if (source._values != null)
{
Values.Add(source._values);
}
}
public string Name
{
get { return _name; }
set
{
CheckNameFormat(value, "value");
_name = value;
}
}
/// <summary>
/// If the cookie data is a simple string value then set or retrieve it using the <see cref="Value"/> property.
/// If the cookie data is structured then use the <see cref="Values"/> property.
/// </summary>
public string Value
{
get
{
return Values.Count > 0 ? Values.AllKeys[0] : String.Empty;
}
set
{
CheckValueFormat(value, "value");
if (Values.Count > 0)
{
Values.AllKeys[0] = value;
}
else
{
Values.Add(value, String.Empty);
}
}
}
/// <summary>
/// If the cookie data is structured then use the <see cref="Values"/> property for setting and getting individual values.
/// If the cookie data is a simple string value then set or retrieve it using the <see cref="Value"/> property.
/// </summary>
public NameValueCollection Values
{
get { return _values; }
}
public string this[string name]
{
get { return Values[name]; }
set { Values[name] = value; }
}
public override string ToString()
{
return _name + "=" + (_values != null ? _values.ToString() : String.Empty);
}
public object Clone()
{
return new CookieState(this);
}
private static void CheckNameFormat(string name, string parameterName)
{
if (!FormattingUtilities.ValidateHeaderToken(name))
{
throw Error.Argument(parameterName, Properties.Resources.CookieInvalidName);
}
}
private static void CheckValueFormat(string value, string parameterName)
{
// Empty string is a valid cookie value
if (value == null)
{
throw Error.ArgumentNull(parameterName);
}
}
}
}