private static string[] GetValuesAsStrings(
HeaderDescriptor descriptor,
HttpHeaders.HeaderStoreItemInfo info,
object exclude = null)
{
int valueCount = HttpHeaders.GetValueCount(info);
string[] values;
if (valueCount > 0)
{
values = new string[valueCount];
int currentIndex = 0;
HttpHeaders.ReadStoreValues <string>(values, info.RawValue, (HttpHeaderParser)null, (string)null, ref currentIndex);
HttpHeaders.ReadStoreValues <object>(values, info.ParsedValue, descriptor.Parser, exclude, ref currentIndex);
HttpHeaders.ReadStoreValues <string>(values, info.InvalidValue, (HttpHeaderParser)null, (string)null, ref currentIndex);
if (currentIndex < valueCount)
{
string[] strArray = new string[currentIndex];
Array.Copy((Array)values, 0, (Array)strArray, 0, currentIndex);
values = strArray;
}
}
else
{
values = Array.Empty <string>();
}
return(values);
}
private bool ParseRawHeaderValues(
HeaderDescriptor descriptor,
HttpHeaders.HeaderStoreItemInfo info,
bool removeEmptyHeader)
{
lock (info)
{
if (info.RawValue != null)
{
if (!(info.RawValue is List <string> rawValue))
{
HttpHeaders.ParseSingleRawHeaderValue(descriptor, info);
}
else
{
HttpHeaders.ParseMultipleRawHeaderValues(descriptor, info, rawValue);
}
info.RawValue = (object)null;
if (info.InvalidValue == null)
{
if (info.ParsedValue == null)
{
if (removeEmptyHeader)
{
this._headerStore.Remove(descriptor);
}
return(false);
}
}
}
}
return(true);
}
private HttpHeaders.HeaderStoreItemInfo CreateAndAddHeaderToStore(
HeaderDescriptor descriptor)
{
HttpHeaders.HeaderStoreItemInfo info = new HttpHeaders.HeaderStoreItemInfo();
this.AddHeaderToStore(descriptor, info);
return(info);
}
private void AddHeaderInfo(
HeaderDescriptor descriptor,
HttpHeaders.HeaderStoreItemInfo sourceInfo)
{
HttpHeaders.HeaderStoreItemInfo addHeaderToStore = this.CreateAndAddHeaderToStore(descriptor);
if (descriptor.Parser == null)
{
addHeaderToStore.ParsedValue = HttpHeaders.CloneStringHeaderInfoValues(sourceInfo.ParsedValue);
}
else
{
addHeaderToStore.InvalidValue = HttpHeaders.CloneStringHeaderInfoValues(sourceInfo.InvalidValue);
if (sourceInfo.ParsedValue == null)
{
return;
}
if (!(sourceInfo.ParsedValue is List <object> parsedValue))
{
HttpHeaders.CloneAndAddValue(addHeaderToStore, sourceInfo.ParsedValue);
}
else
{
foreach (object source in parsedValue)
{
HttpHeaders.CloneAndAddValue(addHeaderToStore, source);
}
}
}
}
internal void Add(HeaderDescriptor descriptor, IEnumerable <string> values)
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
HttpHeaders.HeaderStoreItemInfo info;
bool addToStore;
this.PrepareHeaderInfoForAdd(descriptor, out info, out addToStore);
try
{
foreach (string str in values)
{
this.ParseAndAddValue(descriptor, info, str);
}
}
finally
{
if (addToStore && info.ParsedValue != null)
{
this.AddHeaderToStore(descriptor, info);
}
}
}
internal bool ContainsParsedValue(HeaderDescriptor descriptor, object value)
{
if (this._headerStore == null)
{
return(false);
}
HttpHeaders.HeaderStoreItemInfo info = (HttpHeaders.HeaderStoreItemInfo)null;
if (!this.TryGetAndParseHeaderInfo(descriptor, out info) || info.ParsedValue == null)
{
return(false);
}
List <object> parsedValue = info.ParsedValue as List <object>;
IEqualityComparer comparer = descriptor.Parser.Comparer;
if (parsedValue == null)
{
return(this.AreEqual(value, info.ParsedValue, comparer));
}
foreach (object storeValue in parsedValue)
{
if (this.AreEqual(value, storeValue, comparer))
{
return(true);
}
}
return(false);
}
private static void ParseMultipleRawHeaderValues(
HeaderDescriptor descriptor,
HttpHeaders.HeaderStoreItemInfo info,
List <string> rawValues)
{
if (descriptor.Parser == null)
{
foreach (string rawValue in rawValues)
{
if (!HttpHeaders.ContainsInvalidNewLine(rawValue, descriptor.Name))
{
HttpHeaders.AddValue(info, (object)rawValue, HttpHeaders.StoreLocation.Parsed);
}
}
}
else
{
foreach (string rawValue in rawValues)
{
if (!HttpHeaders.TryParseAndAddRawHeaderValue(descriptor, info, rawValue, true) && NetEventSource.IsEnabled)
{
NetEventSource.Log.HeadersInvalidValue(descriptor.Name, rawValue);
}
}
}
}
internal static TimeSpan?GetTimeSpanValue(
HeaderDescriptor descriptor,
HttpHeaders store)
{
object parsedValues = store.GetParsedValues(descriptor);
return(parsedValues != null ? new TimeSpan?((TimeSpan)parsedValues) : new TimeSpan?());
}
private void AddHeaderToStore(HeaderDescriptor descriptor, HttpHeaders.HeaderStoreItemInfo info)
{
if (this._headerStore == null)
{
this._headerStore = new Dictionary <HeaderDescriptor, HttpHeaders.HeaderStoreItemInfo>();
}
this._headerStore.Add(descriptor, info);
}
internal void SetParsedValue(HeaderDescriptor descriptor, object value)
{
HttpHeaders.HeaderStoreItemInfo headerInfo = this.GetOrCreateHeaderInfo(descriptor, true);
headerInfo.InvalidValue = (object)null;
headerInfo.ParsedValue = (object)null;
headerInfo.RawValue = (object)null;
HttpHeaders.AddValue(headerInfo, value, HttpHeaders.StoreLocation.Parsed);
}
internal bool Contains(HeaderDescriptor descriptor)
{
if (this._headerStore == null)
{
return(false);
}
HttpHeaders.HeaderStoreItemInfo info = (HttpHeaders.HeaderStoreItemInfo)null;
return(this.TryGetAndParseHeaderInfo(descriptor, out info));
}
internal bool TryAddWithoutValidation(HeaderDescriptor descriptor, string value)
{
if (value == null)
{
value = string.Empty;
}
HttpHeaders.AddValue(this.GetOrCreateHeaderInfo(descriptor, false), (object)value, HttpHeaders.StoreLocation.Raw);
return(true);
}
internal IEnumerable <string> GetValues(HeaderDescriptor descriptor)
{
IEnumerable <string> values;
if (!this.TryGetValues(descriptor, out values))
{
throw new InvalidOperationException(SR.net_http_headers_not_found);
}
return(values);
}
private bool TryGetHeaderInfo(
HeaderDescriptor descriptor,
out HttpHeaders.HeaderStoreItemInfo info)
{
if (this._headerStore != null)
{
return(this._headerStore.TryGetValue(descriptor, out info));
}
info = (HttpHeaders.HeaderStoreItemInfo)null;
return(false);
}
private HttpHeaders.HeaderStoreItemInfo GetOrCreateHeaderInfo(
HeaderDescriptor descriptor,
bool parseRawValues)
{
HttpHeaders.HeaderStoreItemInfo info = (HttpHeaders.HeaderStoreItemInfo)null;
if (!(!parseRawValues ? this.TryGetHeaderInfo(descriptor, out info) : this.TryGetAndParseHeaderInfo(descriptor, out info)))
{
info = this.CreateAndAddHeaderToStore(descriptor);
}
return(info);
}
internal void SetOrRemoveParsedValue(HeaderDescriptor descriptor, object value)
{
if (value == null)
{
this.Remove(descriptor);
}
else
{
this.SetParsedValue(descriptor, value);
}
}
internal HttpHeaderValueCollection(HeaderDescriptor descriptor, HttpHeaders store, T specialValue,
Action <HttpHeaderValueCollection <T>, T> validator)
{
Debug.Assert(descriptor.Name != null);
Debug.Assert(store != null);
_store = store;
_descriptor = descriptor;
_specialValue = specialValue;
_validator = validator;
}
internal static TimeSpan?GetTimeSpanValue(HeaderDescriptor descriptor, HttpHeaders store)
{
Debug.Assert(store != null);
object?storedValue = store.GetSingleParsedValue(descriptor);
if (storedValue != null)
{
return((TimeSpan)storedValue);
}
return(null);
}
internal static DateTimeOffset?GetDateTimeOffsetValue(HeaderDescriptor descriptor, HttpHeaders store)
{
Debug.Assert(store != null);
object storedValue = store.GetParsedValues(descriptor);
if (storedValue != null)
{
return((DateTimeOffset)storedValue);
}
return(null);
}
internal static DateTimeOffset?GetDateTimeOffsetValue(
HeaderDescriptor descriptor,
HttpHeaders store,
DateTimeOffset?defaultValue = null)
{
object parsedValues = store.GetParsedValues(descriptor);
if (parsedValues != null)
{
return(new DateTimeOffset?((DateTimeOffset)parsedValues));
}
return(defaultValue.HasValue && store.Contains(descriptor) ? defaultValue : new DateTimeOffset?());
}
internal bool TryAddWithoutValidation(HeaderDescriptor descriptor, IEnumerable <string> values)
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
HttpHeaders.HeaderStoreItemInfo headerInfo = this.GetOrCreateHeaderInfo(descriptor, false);
foreach (string str in values)
{
HttpHeaders.AddValue(headerInfo, (object)(str ?? string.Empty), HttpHeaders.StoreLocation.Raw);
}
return(true);
}
internal void Add(HeaderDescriptor descriptor, string value)
{
HttpHeaders.HeaderStoreItemInfo info;
bool addToStore;
this.PrepareHeaderInfoForAdd(descriptor, out info, out addToStore);
this.ParseAndAddValue(descriptor, info, value);
if (!addToStore || info.ParsedValue == null)
{
return;
}
this.AddHeaderToStore(descriptor, info);
}
private void PrepareHeaderInfoForAdd(
HeaderDescriptor descriptor,
out HttpHeaders.HeaderStoreItemInfo info,
out bool addToStore)
{
info = (HttpHeaders.HeaderStoreItemInfo)null;
addToStore = false;
if (this.TryGetAndParseHeaderInfo(descriptor, out info))
{
return;
}
info = new HttpHeaders.HeaderStoreItemInfo();
addToStore = true;
}
internal bool TryParseAndAddValue(HeaderDescriptor descriptor, string value)
{
HttpHeaders.HeaderStoreItemInfo info;
bool addToStore;
this.PrepareHeaderInfoForAdd(descriptor, out info, out addToStore);
bool addRawHeaderValue = HttpHeaders.TryParseAndAddRawHeaderValue(descriptor, info, value, false);
if (addRawHeaderValue & addToStore && info.ParsedValue != null)
{
this.AddHeaderToStore(descriptor, info);
}
return(addRawHeaderValue);
}
internal bool RemoveParsedValue(HeaderDescriptor descriptor, object value)
{
if (this._headerStore == null)
{
return(false);
}
HttpHeaders.HeaderStoreItemInfo info = (HttpHeaders.HeaderStoreItemInfo)null;
if (!this.TryGetAndParseHeaderInfo(descriptor, out info))
{
return(false);
}
bool flag = false;
if (info.ParsedValue == null)
{
return(false);
}
IEqualityComparer comparer = descriptor.Parser.Comparer;
if (!(info.ParsedValue is List <object> parsedValue))
{
if (this.AreEqual(value, info.ParsedValue, comparer))
{
info.ParsedValue = (object)null;
flag = true;
}
}
else
{
foreach (object storeValue in parsedValue)
{
if (this.AreEqual(value, storeValue, comparer))
{
flag = parsedValue.Remove(storeValue);
break;
}
}
if (parsedValue.Count == 0)
{
info.ParsedValue = (object)null;
}
}
if (info.IsEmpty)
{
this.Remove(descriptor);
}
return(flag);
}
private void ParseAndAddValue(
HeaderDescriptor descriptor,
HttpHeaders.HeaderStoreItemInfo info,
string value)
{
if (descriptor.Parser == null)
{
HttpHeaders.CheckInvalidNewLine(value);
HttpHeaders.AddValue(info, (object)(value ?? string.Empty), HttpHeaders.StoreLocation.Parsed);
}
else
{
if (!info.CanAddValue(descriptor.Parser))
{
throw new FormatException(SR.Format((IFormatProvider)CultureInfo.InvariantCulture, SR.net_http_headers_single_value_header, (object)descriptor.Name));
}
int index = 0;
object obj1 = descriptor.Parser.ParseValue(value, info.ParsedValue, ref index);
if (value == null || index == value.Length)
{
if (obj1 == null)
{
return;
}
HttpHeaders.AddValue(info, obj1, HttpHeaders.StoreLocation.Parsed);
}
else
{
List <object> objectList = new List <object>();
if (obj1 != null)
{
objectList.Add(obj1);
}
while (index < value.Length)
{
object obj2 = descriptor.Parser.ParseValue(value, info.ParsedValue, ref index);
if (obj2 != null)
{
objectList.Add(obj2);
}
}
foreach (object obj2 in objectList)
{
HttpHeaders.AddValue(info, obj2, HttpHeaders.StoreLocation.Parsed);
}
}
}
}
internal override bool IsAllowedHeaderName(HeaderDescriptor descriptor)
{
if (!_containsTrailingHeaders)
{
return(true);
}
KnownHeader knownHeader = KnownHeaders.TryGetKnownHeader(descriptor.Name);
if (knownHeader == null)
{
return(true);
}
return((knownHeader.HeaderType & HttpHeaderType.NonTrailing) == 0);
}
internal bool TryGetValues(HeaderDescriptor descriptor, out IEnumerable <string> values)
{
if (this._headerStore == null)
{
values = (IEnumerable <string>)null;
return(false);
}
HttpHeaders.HeaderStoreItemInfo info = (HttpHeaders.HeaderStoreItemInfo)null;
if (this.TryGetAndParseHeaderInfo(descriptor, out info))
{
values = (IEnumerable <string>)HttpHeaders.GetValuesAsStrings(descriptor, info, (object)null);
return(true);
}
values = (IEnumerable <string>)null;
return(false);
}
internal static DateTimeOffset?GetDateTimeOffsetValue(HeaderDescriptor descriptor, HttpHeaders store, DateTimeOffset?defaultValue = null)
{
Debug.Assert(store != null);
object?storedValue = store.GetSingleParsedValue(descriptor);
if (storedValue != null)
{
return((DateTimeOffset)storedValue);
}
else if (defaultValue != null && store.Contains(descriptor))
{
return(defaultValue);
}
return(null);
}
internal static IEnumerable <KeyValuePair <HeaderDescriptor, string[]> > GetHeaderDescriptorsAndValues(this HttpHeaders headers)
{
List <KeyValuePair <HeaderDescriptor, string[]> > result = new List <KeyValuePair <HeaderDescriptor, string[]> >();
foreach (KeyValuePair <string, IEnumerable <string> > header in headers)
{
KnownHeader knownHeader = KnownHeaders.TryGetKnownHeader(header.Key);
if (knownHeader == null)
{
knownHeader = new KnownHeader(header.Key);
}
HeaderDescriptor descriptor = new HeaderDescriptor(knownHeader);
result.Add(new KeyValuePair <HeaderDescriptor, string[]>(descriptor, header.Value.ToArray()));
}
return(result);
}
