/// <summary>Read a parameter for a media type/range.</summary>
/// <param name="text">Text to read from.</param>
/// <param name="textIndex">Pointer in text.</param>
/// <param name="parameters">Array with parameters to grow as necessary.</param>
private static void ReadMediaTypeParameter(string text, ref int textIndex, ref KeyValuePair <string, string>[] parameters)
{
int startIndex = textIndex;
if (ReadToken(text, ref textIndex))
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpProcessUtility_MediaTypeMissingValue);
}
string parameterName = text.Substring(startIndex, textIndex - startIndex);
if (text[textIndex] != '=')
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpProcessUtility_MediaTypeMissingValue);
}
textIndex++;
string parameterValue = ReadQuotedParameterValue(parameterName, text, ref textIndex);
// Add the parameter name/value pair to the list.
if (parameters == null)
{
parameters = new KeyValuePair <string, string> [1];
}
else
{
KeyValuePair <string, string>[] grow = new KeyValuePair <string, string> [parameters.Length + 1];
Array.Copy(parameters, grow, parameters.Length);
parameters = grow;
}
parameters[parameters.Length - 1] = new KeyValuePair <string, string>(parameterName, parameterValue);
}
/// <summary>Reads the type and subtype specifications for a MIME type.</summary>
/// <param name='text'>Text in which specification exists.</param>
/// <param name='textIndex'>Pointer into text.</param>
/// <param name='type'>Type of media found.</param>
/// <param name='subType'>Subtype of media found.</param>
private static void ReadMediaTypeAndSubtype(string text, ref int textIndex, out string type, out string subType)
{
Debug.Assert(text != null, "text != null");
int textStart = textIndex;
if (ReadToken(text, ref textIndex))
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpProcessUtility_MediaTypeUnspecified);
}
if (text[textIndex] != '/')
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpProcessUtility_MediaTypeRequiresSlash);
}
type = text.Substring(textStart, textIndex - textStart);
textIndex++;
int subTypeStart = textIndex;
ReadToken(text, ref textIndex);
if (textIndex == subTypeStart)
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpProcessUtility_MediaTypeRequiresSubType);
}
subType = text.Substring(subTypeStart, textIndex - subTypeStart);
}
/// <summary>
/// Reads the numeric part of a quality value substring, normalizing it to 0-1000
/// rather than the standard 0.000-1.000 ranges.
/// </summary>
/// <param name="text">Text to read qvalue from.</param>
/// <param name="textIndex">Index into text where the qvalue starts.</param>
/// <param name="qualityValue">After the method executes, the normalized qvalue.</param>
/// <remarks>
/// For more information, see RFC 2616.3.8.
/// </remarks>
private static void ReadQualityValue(string text, ref int textIndex, out int qualityValue)
{
char digit = text[textIndex++];
if (digit == '0')
{
qualityValue = 0;
}
else if (digit == '1')
{
qualityValue = 1;
}
else
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpContextServiceHost_MalformedHeaderValue);
}
if (textIndex < text.Length && text[textIndex] == '.')
{
textIndex++;
int adjustFactor = 1000;
while (adjustFactor > 1 && textIndex < text.Length)
{
char c = text[textIndex];
int charValue = DigitToInt32(c);
if (charValue >= 0)
{
textIndex++;
adjustFactor /= 10;
qualityValue *= 10;
qualityValue += charValue;
}
else
{
break;
}
}
qualityValue = qualityValue *= adjustFactor;
if (qualityValue > 1000)
{
// Too high of a value in qvalue.
throw HttpProcessUtils.CreateParsingException(Resource.HttpContextServiceHost_MalformedHeaderValue);
}
}
else
{
qualityValue *= 1000;
}
}
/// <summary>
/// Converts the specified character from the ASCII range to a digit.
/// </summary>
/// <param name="c">Character to convert.</param>
/// <returns>
/// The Int32 value for c, or -1 if it is an element separator.
/// </returns>
private static int DigitToInt32(char c)
{
if (c >= '0' && c <= '9')
{
return((int)(c - '0'));
}
else
{
if (IsHttpElementSeparator(c))
{
return(-1);
}
else
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpContextServiceHost_MalformedHeaderValue);
}
}
}
/// <summary>Returns all MIME types from the specified (non-blank) <paramref name='text' />.</summary>
/// <param name='text'>Non-blank text, as it appears on an HTTP Accepts header.</param>
/// <returns>An enumerable object with media type descriptions.</returns>
private static IEnumerable <MediaType> MimeTypesFromAcceptHeader(string text)
{
Debug.Assert(!String.IsNullOrEmpty(text), "!String.IsNullOrEmpty(text)");
List <MediaType> mediaTypes = new List <MediaType>();
int textIndex = 0;
while (!SkipWhitespace(text, ref textIndex))
{
string type;
string subType;
ReadMediaTypeAndSubtype(text, ref textIndex, out type, out subType);
KeyValuePair <string, string>[] parameters = null;
while (!SkipWhitespace(text, ref textIndex))
{
if (text[textIndex] == ',')
{
textIndex++;
break;
}
if (text[textIndex] != ';')
{
throw HttpProcessUtils.CreateParsingException(Resource.HttpProcessUtility_MediaTypeRequiresSemicolonBeforeParameter);
}
textIndex++;
if (SkipWhitespace(text, ref textIndex))
{
// ';' should be a leading separator, but we choose to be a
// bit permissive and allow it as a final delimiter as well.
break;
}
ReadMediaTypeParameter(text, ref textIndex, ref parameters);
}
mediaTypes.Add(new MediaType(type, subType, parameters));
}
return(mediaTypes);
}
/// <summary>
/// Reads Mime type parameter value for a particular parameter in the Content-Type/Accept headers.
/// </summary>
/// <param name="parameterName">Name of parameter.</param>
/// <param name="headerText">Header text.</param>
/// <param name="textIndex">Parsing index in <paramref name="headerText"/>.</param>
/// <returns>String representing the value of the <paramref name="parameterName"/> parameter.</returns>
private static string ReadQuotedParameterValue(string parameterName, string headerText, ref int textIndex)
{
StringBuilder parameterValue = new StringBuilder();
// Check if the value is quoted.
bool valueIsQuoted = false;
if (textIndex < headerText.Length)
{
if (headerText[textIndex] == '\"')
{
textIndex++;
valueIsQuoted = true;
}
}
while (textIndex < headerText.Length)
{
char currentChar = headerText[textIndex];
if (currentChar == '\\' || currentChar == '\"')
{
if (!valueIsQuoted)
{
throw HttpProcessUtils.CreateParsingException(string.Format(
CultureInfo.InvariantCulture,
Resource.HttpProcessUtility_EscapeCharWithoutQuotes,
parameterName));
}
textIndex++;
// End of quoted parameter value.
if (currentChar == '\"')
{
valueIsQuoted = false;
break;
}
if (textIndex >= headerText.Length)
{
throw HttpProcessUtils.CreateParsingException(string.Format(
CultureInfo.InvariantCulture,
Resource.HttpProcessUtility_EscapeCharAtEnd,
parameterName));
}
currentChar = headerText[textIndex];
}
else
if (!IsHttpToken(currentChar))
{
// If the given character is special, we stop processing.
break;
}
parameterValue.Append(currentChar);
textIndex++;
}
if (valueIsQuoted)
{
throw HttpProcessUtils.CreateParsingException(string.Format(
CultureInfo.InvariantCulture,
Resource.HttpProcessUtility_ClosingQuoteNotFound,
parameterName));
}
return(parameterValue.ToString());
}