PageRenderTime 48ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/WCFWebApi/src/Microsoft.Net.Http.Formatting/System/Net/Http/InternetMessageFormatHeaderParser.cs

#
C# | 334 lines | 237 code | 45 blank | 52 comment | 44 complexity | 3d2749bbf88b9359ddb7c187e02be529 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, Apache-2.0
  1. // <copyright>
  2. // Copyright (c) Microsoft Corporation. All rights reserved.
  3. // </copyright>
  4. namespace System.Net.Http
  5. {
  6. using System;
  7. using System.Diagnostics.CodeAnalysis;
  8. using System.Diagnostics.Contracts;
  9. using System.Net.Http.Headers;
  10. using System.Text;
  11. /// <summary>
  12. /// Buffer-oriented RFC 5322 style Internet Message Format parser which can be used to pass header
  13. /// fields used in HTTP and MIME message entities.
  14. /// </summary>
  15. internal class InternetMessageFormatHeaderParser
  16. {
  17. internal const int MinHeaderSize = 2;
  18. private int totalBytesConsumed;
  19. private int maxHeaderSize;
  20. private HeaderFieldState headerState;
  21. private HttpHeaders headers;
  22. private CurrentHeaderFieldStore currentHeader;
  23. /// <summary>
  24. /// Initializes a new instance of the <see cref="InternetMessageFormatHeaderParser"/> class.
  25. /// </summary>
  26. /// <param name="headers">Concrete <see cref="HttpHeaders"/> instance where header fields are added as they are parsed.</param>
  27. /// <param name="maxHeaderSize">Maximum length of complete header containing all the individual header fields.</param>
  28. public InternetMessageFormatHeaderParser(HttpHeaders headers, int maxHeaderSize)
  29. {
  30. // The minimum length which would be an empty header terminated by CRLF
  31. if (maxHeaderSize < InternetMessageFormatHeaderParser.MinHeaderSize)
  32. {
  33. throw new ArgumentException(SR.MinParameterSize(InternetMessageFormatHeaderParser.MinHeaderSize), "maxHeaderSize");
  34. }
  35. if (headers == null)
  36. {
  37. throw new ArgumentNullException("headers");
  38. }
  39. this.headers = headers;
  40. this.maxHeaderSize = maxHeaderSize;
  41. this.currentHeader = new CurrentHeaderFieldStore();
  42. }
  43. private enum HeaderFieldState
  44. {
  45. Name = 0,
  46. Value,
  47. AfterCarriageReturn,
  48. FoldingLine
  49. }
  50. /// <summary>
  51. /// Parse a buffer of RFC 5322 style header fields and add them to the <see cref="HttpHeaders"/> collection.
  52. /// Bytes are parsed in a consuming manner from the beginning of the buffer meaning that the same bytes can not be
  53. /// present in the buffer.
  54. /// </summary>
  55. /// <param name="buffer">Request buffer from where request is read</param>
  56. /// <param name="bytesReady">Size of request buffer</param>
  57. /// <param name="bytesConsumed">Offset into request buffer</param>
  58. /// <returns>State of the parser. Call this method with new data until it reaches a final state.</returns>
  59. [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is translated to parse state.")]
  60. public ParserState ParseBuffer(
  61. byte[] buffer,
  62. int bytesReady,
  63. ref int bytesConsumed)
  64. {
  65. if (buffer == null)
  66. {
  67. throw new ArgumentNullException("buffer");
  68. }
  69. ParserState parseStatus = ParserState.NeedMoreData;
  70. if (bytesConsumed >= bytesReady)
  71. {
  72. // We already can tell we need more data
  73. return parseStatus;
  74. }
  75. try
  76. {
  77. parseStatus = InternetMessageFormatHeaderParser.ParseHeaderFields(
  78. buffer,
  79. bytesReady,
  80. ref bytesConsumed,
  81. ref this.headerState,
  82. this.maxHeaderSize,
  83. ref this.totalBytesConsumed,
  84. this.currentHeader,
  85. this.headers);
  86. }
  87. catch (Exception)
  88. {
  89. parseStatus = ParserState.Invalid;
  90. }
  91. return parseStatus;
  92. }
  93. [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "This is a parser which cannot be split up for performance reasons.")]
  94. private static unsafe ParserState ParseHeaderFields(
  95. byte[] buffer,
  96. int bytesReady,
  97. ref int bytesConsumed,
  98. ref HeaderFieldState requestHeaderState,
  99. int maximumHeaderLength,
  100. ref int totalBytesConsumed,
  101. CurrentHeaderFieldStore currentField,
  102. HttpHeaders headers)
  103. {
  104. Contract.Assert((bytesReady - bytesConsumed) >= 0, "ParseHeaderFields()|(inputBufferLength - bytesParsed) < 0");
  105. Contract.Assert(maximumHeaderLength <= 0 || totalBytesConsumed <= maximumHeaderLength, "ParseHeaderFields()|Headers already read exceeds limit.");
  106. // Remember where we started.
  107. int initialBytesParsed = bytesConsumed;
  108. int segmentStart;
  109. // Set up parsing status with what will happen if we exceed the buffer.
  110. ParserState parseStatus = ParserState.DataTooBig;
  111. int effectiveMax = maximumHeaderLength <= 0 ? Int32.MaxValue : maximumHeaderLength - totalBytesConsumed + initialBytesParsed;
  112. if (bytesReady < effectiveMax)
  113. {
  114. parseStatus = ParserState.NeedMoreData;
  115. effectiveMax = bytesReady;
  116. }
  117. Contract.Assert(bytesConsumed < effectiveMax, "We have already consumed more than the max header length.");
  118. fixed (byte* inputPtr = buffer)
  119. {
  120. switch (requestHeaderState)
  121. {
  122. case HeaderFieldState.Name:
  123. segmentStart = bytesConsumed;
  124. while (inputPtr[bytesConsumed] != ':')
  125. {
  126. if (inputPtr[bytesConsumed] == '\r')
  127. {
  128. if (!currentField.IsEmpty())
  129. {
  130. parseStatus = ParserState.Invalid;
  131. goto quit;
  132. }
  133. else
  134. {
  135. // Move past the '\r'
  136. requestHeaderState = HeaderFieldState.AfterCarriageReturn;
  137. if (++bytesConsumed == effectiveMax)
  138. {
  139. goto quit;
  140. }
  141. goto case HeaderFieldState.AfterCarriageReturn;
  142. }
  143. }
  144. if (++bytesConsumed == effectiveMax)
  145. {
  146. string headerFieldName = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
  147. currentField.Name.Append(headerFieldName);
  148. goto quit;
  149. }
  150. }
  151. if (bytesConsumed > segmentStart)
  152. {
  153. string headerFieldName = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
  154. currentField.Name.Append(headerFieldName);
  155. }
  156. // Move past the ':'
  157. requestHeaderState = HeaderFieldState.Value;
  158. if (++bytesConsumed == effectiveMax)
  159. {
  160. goto quit;
  161. }
  162. goto case HeaderFieldState.Value;
  163. case HeaderFieldState.Value:
  164. segmentStart = bytesConsumed;
  165. while (inputPtr[bytesConsumed] != '\r')
  166. {
  167. if (++bytesConsumed == effectiveMax)
  168. {
  169. string headerFieldValue = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
  170. currentField.Value.Append(headerFieldValue);
  171. goto quit;
  172. }
  173. }
  174. if (bytesConsumed > segmentStart)
  175. {
  176. string headerFieldValue = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
  177. currentField.Value.Append(headerFieldValue);
  178. }
  179. // Move past the CR
  180. requestHeaderState = HeaderFieldState.AfterCarriageReturn;
  181. if (++bytesConsumed == effectiveMax)
  182. {
  183. goto quit;
  184. }
  185. goto case HeaderFieldState.AfterCarriageReturn;
  186. case HeaderFieldState.AfterCarriageReturn:
  187. if (inputPtr[bytesConsumed] != '\n')
  188. {
  189. parseStatus = ParserState.Invalid;
  190. goto quit;
  191. }
  192. if (currentField.IsEmpty())
  193. {
  194. parseStatus = ParserState.Done;
  195. bytesConsumed++;
  196. goto quit;
  197. }
  198. requestHeaderState = HeaderFieldState.FoldingLine;
  199. if (++bytesConsumed == effectiveMax)
  200. {
  201. goto quit;
  202. }
  203. goto case HeaderFieldState.FoldingLine;
  204. case HeaderFieldState.FoldingLine:
  205. if (inputPtr[bytesConsumed] != ' ' && inputPtr[bytesConsumed] != '\t')
  206. {
  207. currentField.CopyTo(headers);
  208. requestHeaderState = HeaderFieldState.Name;
  209. if (bytesConsumed == effectiveMax)
  210. {
  211. goto quit;
  212. }
  213. goto case HeaderFieldState.Name;
  214. }
  215. // Unfold line by inserting SP instead
  216. currentField.Value.Append(' ');
  217. // Continue parsing header field value
  218. requestHeaderState = HeaderFieldState.Value;
  219. if (++bytesConsumed == effectiveMax)
  220. {
  221. goto quit;
  222. }
  223. goto case HeaderFieldState.Value;
  224. }
  225. }
  226. quit:
  227. totalBytesConsumed += bytesConsumed - initialBytesParsed;
  228. return parseStatus;
  229. }
  230. /// <summary>
  231. /// Maintains information about the current header field being parsed.
  232. /// </summary>
  233. private class CurrentHeaderFieldStore
  234. {
  235. private const int DefaultFieldNameAllocation = 128;
  236. private const int DefaultFieldValueAllocation = 2 * 1024;
  237. private static readonly char[] LinearWhiteSpace = new char[] { ' ', '\t' };
  238. private StringBuilder name = new StringBuilder(CurrentHeaderFieldStore.DefaultFieldNameAllocation);
  239. private StringBuilder value = new StringBuilder(CurrentHeaderFieldStore.DefaultFieldValueAllocation);
  240. /// <summary>
  241. /// Gets the header field name.
  242. /// </summary>
  243. public StringBuilder Name
  244. {
  245. get
  246. {
  247. return this.name;
  248. }
  249. }
  250. /// <summary>
  251. /// Gets the header field value.
  252. /// </summary>
  253. public StringBuilder Value
  254. {
  255. get
  256. {
  257. return this.value;
  258. }
  259. }
  260. /// <summary>
  261. /// Copies current header field to the provided <see cref="HttpHeaders"/> instance.
  262. /// </summary>
  263. /// <param name="headers">The headers.</param>
  264. public void CopyTo(HttpHeaders headers)
  265. {
  266. headers.Add(this.name.ToString(), this.value.ToString().Trim(CurrentHeaderFieldStore.LinearWhiteSpace));
  267. this.Clear();
  268. }
  269. /// <summary>
  270. /// Determines whether this instance is empty.
  271. /// </summary>
  272. /// <returns>
  273. /// <c>true</c> if this instance is empty; otherwise, <c>false</c>.
  274. /// </returns>
  275. public bool IsEmpty()
  276. {
  277. return this.name.Length == 0 && this.value.Length == 0;
  278. }
  279. /// <summary>
  280. /// Clears this instance.
  281. /// </summary>
  282. private void Clear()
  283. {
  284. this.name.Clear();
  285. this.value.Clear();
  286. }
  287. }
  288. }
  289. }