Source/WebCore/platform/network/HTTPParsers.cpp

   1 /*
   2  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
   3  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   4  * Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
   5  * Copyright (C) 2009 Google Inc. All rights reserved.
   6  * Copyright (C) 2011 Apple Inc. All Rights Reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1.  Redistributions of source code must retain the above copyright
  13  *     notice, this list of conditions and the following disclaimer.
  14  * 2.  Redistributions in binary form must reproduce the above copyright
  15  *     notice, this list of conditions and the following disclaimer in the
  16  *     documentation and/or other materials provided with the distribution.
  17  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
  18  *     its contributors may be used to endorse or promote products derived
  19  *     from this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  25  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  28  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include "config.h"
  34 #include "HTTPParsers.h"
  35
  36 #include "ContentSecurityPolicy.h"
  37 #include <wtf/DateMath.h>
  38 #include <wtf/text/CString.h>
  39 #include <wtf/text/StringBuilder.h>
  40 #include <wtf/text/WTFString.h>
  41 #include <wtf/unicode/CharacterNames.h>
  42
  43 using namespace WTF;
  44
  45 namespace WebCore {
  46
  47 // true if there is more to parse, after incrementing pos past whitespace.
  48 // Note: Might return pos == str.length()
  49 static inline bool skipWhiteSpace(const String& str, unsigned& pos, bool fromHttpEquivMeta)
  50 {
  51     unsigned len = str.length();
  52
  53     if (fromHttpEquivMeta) {
  54         while (pos < len && str[pos] <= ' ')
  55             ++pos;
  56     } else {
  57         while (pos < len && (str[pos] == '\t' || str[pos] == ' '))
  58             ++pos;
  59     }
  60
  61     return pos < len;
  62 }
  63
  64 // Returns true if the function can match the whole token (case insensitive)
  65 // incrementing pos on match, otherwise leaving pos unchanged.
  66 // Note: Might return pos == str.length()
  67 static inline bool skipToken(const String& str, unsigned& pos, const char* token)
  68 {
  69     unsigned len = str.length();
  70     unsigned current = pos;
  71
  72     while (current < len && *token) {
  73         if (toASCIILower(str[current]) != *token++)
  74             return false;
  75         ++current;
  76     }
  77
  78     if (*token)
  79         return false;
  80
  81     pos = current;
  82     return true;
  83 }
  84
  85 // True if the expected equals sign is seen and there is more to follow.
  86 static inline bool skipEquals(const String& str, unsigned &pos)
  87 {
  88     return skipWhiteSpace(str, pos, false) && str[pos++] == '=' && skipWhiteSpace(str, pos, false);
  89 }
  90
  91 // True if a value present, incrementing pos to next space or semicolon, if any.
  92 // Note: might return pos == str.length().
  93 static inline bool skipValue(const String& str, unsigned& pos)
  94 {
  95     unsigned start = pos;
  96     unsigned len = str.length();
  97     while (pos < len) {
  98         if (str[pos] == ' ' || str[pos] == '\t' || str[pos] == ';')
  99             break;
 100         ++pos;
 101     }
 102     return pos != start;
 103 }
 104
 105 // See RFC 7230, Section 3.2.3.
 106 bool isValidHTTPHeaderValue(const String& value)
 107 {
 108     UChar c = value[0];
 109     if (c == ' ' || c == '\t')
 110         return false;
 111     c = value[value.length() - 1];
 112     if (c == ' ' || c == '\t')
 113         return false;
 114     for (unsigned i = 0; i < value.length(); ++i) {
 115         c = value[i];
 116         if (c == 0x7F || c > 0xFF || (c < 0x20 && c != '\t'))
 117             return false;
 118     }
 119     return true;
 120 }
 121
 122 // See RFC 7230, Section 3.2.6.
 123 bool isValidHTTPToken(const String& value)
 124 {
 125     if (value.isEmpty())
 126         return false;
 127     for (unsigned i = 0; i < value.length(); ++i) {
 128         UChar c = value[i];
 129         if (c <= 0x20 || c >= 0x7F
 130             || c == '(' || c == ')' || c == '<' || c == '>' || c == '@'
 131             || c == ',' || c == ';' || c == ':' || c == '\\' || c == '"'
 132             || c == '/' || c == '[' || c == ']' || c == '?' || c == '='
 133             || c == '{' || c == '}')
 134         return false;
 135     }
 136     return true;
 137 }
 138
 139 static const size_t maxInputSampleSize = 128;
 140 static String trimInputSample(const char* p, size_t length)
 141 {
 142     String s = String(p, std::min<size_t>(length, maxInputSampleSize));
 143     if (length > maxInputSampleSize)
 144         s.append(horizontalEllipsis);
 145     return s;
 146 }
 147
 148 ContentDispositionType contentDispositionType(const String& contentDisposition)
 149 {
 150     if (contentDisposition.isEmpty())
 151         return ContentDispositionNone;
 152
 153     Vector<String> parameters;
 154     contentDisposition.split(';', parameters);
 155
 156     String dispositionType = parameters[0];
 157     dispositionType.stripWhiteSpace();
 158
 159     if (equalIgnoringCase(dispositionType, "inline"))
 160         return ContentDispositionInline;
 161
 162     // Some broken sites just send bogus headers like
 163     //
 164     //   Content-Disposition: ; filename="file"
 165     //   Content-Disposition: filename="file"
 166     //   Content-Disposition: name="file"
 167     //
 168     // without a disposition token... screen those out.
 169     if (!isValidHTTPToken(dispositionType))
 170         return ContentDispositionNone;
 171
 172     // We have a content-disposition of "attachment" or unknown.
 173     // RFC 2183, section 2.8 says that an unknown disposition
 174     // value should be treated as "attachment"
 175     return ContentDispositionAttachment;
 176 }
 177
 178 bool parseHTTPRefresh(const String& refresh, bool fromHttpEquivMeta, double& delay, String& url)
 179 {
 180     unsigned len = refresh.length();
 181     unsigned pos = 0;
 182
 183     if (!skipWhiteSpace(refresh, pos, fromHttpEquivMeta))
 184         return false;
 185
 186     while (pos != len && refresh[pos] != ',' && refresh[pos] != ';')
 187         ++pos;
 188
 189     if (pos == len) { // no URL
 190         url = String();
 191         bool ok;
 192         delay = refresh.stripWhiteSpace().toDouble(&ok);
 193         return ok;
 194     } else {
 195         bool ok;
 196         delay = refresh.left(pos).stripWhiteSpace().toDouble(&ok);
 197         if (!ok)
 198             return false;
 199
 200         ++pos;
 201         skipWhiteSpace(refresh, pos, fromHttpEquivMeta);
 202         unsigned urlStartPos = pos;
 203         if (refresh.find("url", urlStartPos, false) == urlStartPos) {
 204             urlStartPos += 3;
 205             skipWhiteSpace(refresh, urlStartPos, fromHttpEquivMeta);
 206             if (refresh[urlStartPos] == '=') {
 207                 ++urlStartPos;
 208                 skipWhiteSpace(refresh, urlStartPos, fromHttpEquivMeta);
 209             } else
 210                 urlStartPos = pos;  // e.g. "Refresh: 0; url.html"
 211         }
 212
 213         unsigned urlEndPos = len;
 214
 215         if (refresh[urlStartPos] == '"' || refresh[urlStartPos] == '\'') {
 216             UChar quotationMark = refresh[urlStartPos];
 217             urlStartPos++;
 218             while (urlEndPos > urlStartPos) {
 219                 urlEndPos--;
 220                 if (refresh[urlEndPos] == quotationMark)
 221                     break;
 222             }
 223
 224             // https://bugs.webkit.org/show_bug.cgi?id=27868
 225             // Sometimes there is no closing quote for the end of the URL even though there was an opening quote.
 226             // If we looped over the entire alleged URL string back to the opening quote, just go ahead and use everything
 227             // after the opening quote instead.
 228             if (urlEndPos == urlStartPos)
 229                 urlEndPos = len;
 230         }
 231
 232         url = refresh.substring(urlStartPos, urlEndPos - urlStartPos).stripWhiteSpace();
 233         return true;
 234     }
 235 }
 236
 237 double parseDate(const String& value)
 238 {
 239     return parseDateFromNullTerminatedCharacters(value.utf8().data());
 240 }
 241
 242 // FIXME: This function doesn't comply with RFC 6266.
 243 // For example, this function doesn't handle the interaction between " and ;
 244 // that arises from quoted-string, nor does this function properly unquote
 245 // attribute values. Further this function appears to process parameter names
 246 // in a case-sensitive manner. (There are likely other bugs as well.)
 247 String filenameFromHTTPContentDisposition(const String& value)
 248 {
 249     Vector<String> keyValuePairs;
 250     value.split(';', keyValuePairs);
 251
 252     unsigned length = keyValuePairs.size();
 253     for (unsigned i = 0; i < length; i++) {
 254         size_t valueStartPos = keyValuePairs[i].find('=');
 255         if (valueStartPos == notFound)
 256             continue;
 257
 258         String key = keyValuePairs[i].left(valueStartPos).stripWhiteSpace();
 259
 260         if (key.isEmpty() || key != "filename")
 261             continue;
 262
 263         String value = keyValuePairs[i].substring(valueStartPos + 1).stripWhiteSpace();
 264
 265         // Remove quotes if there are any
 266         if (value[0] == '\"')
 267             value = value.substring(1, value.length() - 2);
 268
 269         return value;
 270     }
 271
 272     return String();
 273 }
 274
 275 String extractMIMETypeFromMediaType(const String& mediaType)
 276 {
 277     StringBuilder mimeType;
 278     unsigned length = mediaType.length();
 279     mimeType.reserveCapacity(length);
 280     for (unsigned i = 0; i < length; i++) {
 281         UChar c = mediaType[i];
 282
 283         if (c == ';')
 284             break;
 285
 286         // While RFC 2616 does not allow it, other browsers allow multiple values in the HTTP media
 287         // type header field, Content-Type. In such cases, the media type string passed here may contain
 288         // the multiple values separated by commas. For now, this code ignores text after the first comma,
 289         // which prevents it from simply failing to parse such types altogether. Later for better
 290         // compatibility we could consider using the first or last valid MIME type instead.
 291         // See https://bugs.webkit.org/show_bug.cgi?id=25352 for more discussion.
 292         if (c == ',')
 293             break;
 294
 295         // FIXME: The following is not correct. RFC 2616 allows linear white space before and
 296         // after the MIME type, but not within the MIME type itself. And linear white space
 297         // includes only a few specific ASCII characters; a small subset of isSpaceOrNewline.
 298         // See https://bugs.webkit.org/show_bug.cgi?id=8644 for a bug tracking part of this.
 299         if (isSpaceOrNewline(c))
 300             continue;
 301
 302         mimeType.append(c);
 303     }
 304
 305     if (mimeType.length() == length)
 306         return mediaType;
 307     return mimeType.toString();
 308 }
 309
 310 String extractCharsetFromMediaType(const String& mediaType)
 311 {
 312     unsigned int pos, len;
 313     findCharsetInMediaType(mediaType, pos, len);
 314     return mediaType.substring(pos, len);
 315 }
 316
 317 void findCharsetInMediaType(const String& mediaType, unsigned int& charsetPos, unsigned int& charsetLen, unsigned int start)
 318 {
 319     charsetPos = start;
 320     charsetLen = 0;
 321
 322     size_t pos = start;
 323     unsigned length = mediaType.length();
 324
 325     while (pos < length) {
 326         pos = mediaType.find("charset", pos, false);
 327         if (pos == notFound || pos == 0) {
 328             charsetLen = 0;
 329             return;
 330         }
 331
 332         // is what we found a beginning of a word?
 333         if (mediaType[pos-1] > ' ' && mediaType[pos-1] != ';') {
 334             pos += 7;
 335             continue;
 336         }
 337
 338         pos += 7;
 339
 340         // skip whitespace
 341         while (pos != length && mediaType[pos] <= ' ')
 342             ++pos;
 343
 344         if (mediaType[pos++] != '=') // this "charset" substring wasn't a parameter name, but there may be others
 345             continue;
 346
 347         while (pos != length && (mediaType[pos] <= ' ' || mediaType[pos] == '"' || mediaType[pos] == '\''))
 348             ++pos;
 349
 350         // we don't handle spaces within quoted parameter values, because charset names cannot have any
 351         unsigned endpos = pos;
 352         while (pos != length && mediaType[endpos] > ' ' && mediaType[endpos] != '"' && mediaType[endpos] != '\'' && mediaType[endpos] != ';')
 353             ++endpos;
 354
 355         charsetPos = pos;
 356         charsetLen = endpos - pos;
 357         return;
 358     }
 359 }
 360
 361 ContentSecurityPolicy::ReflectedXSSDisposition parseXSSProtectionHeader(const String& header, String& failureReason, unsigned& failurePosition, String& reportURL)
 362 {
 363     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonInvalidToggle, (ASCIILiteral("expected 0 or 1")));
 364     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonInvalidSeparator, (ASCIILiteral("expected semicolon")));
 365     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonInvalidEquals, (ASCIILiteral("expected equals sign")));
 366     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonInvalidMode, (ASCIILiteral("invalid mode directive")));
 367     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonInvalidReport, (ASCIILiteral("invalid report directive")));
 368     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonDuplicateMode, (ASCIILiteral("duplicate mode directive")));
 369     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonDuplicateReport, (ASCIILiteral("duplicate report directive")));
 370     DEPRECATED_DEFINE_STATIC_LOCAL(String, failureReasonInvalidDirective, (ASCIILiteral("unrecognized directive")));
 371
 372     unsigned pos = 0;
 373
 374     if (!skipWhiteSpace(header, pos, false))
 375         return ContentSecurityPolicy::ReflectedXSSUnset;
 376
 377     if (header[pos] == '0')
 378         return ContentSecurityPolicy::AllowReflectedXSS;
 379
 380     if (header[pos++] != '1') {
 381         failureReason = failureReasonInvalidToggle;
 382         return ContentSecurityPolicy::ReflectedXSSInvalid;
 383     }
 384
 385     ContentSecurityPolicy::ReflectedXSSDisposition result = ContentSecurityPolicy::FilterReflectedXSS;
 386     bool modeDirectiveSeen = false;
 387     bool reportDirectiveSeen = false;
 388
 389     while (1) {
 390         // At end of previous directive: consume whitespace, semicolon, and whitespace.
 391         if (!skipWhiteSpace(header, pos, false))
 392             return result;
 393
 394         if (header[pos++] != ';') {
 395             failureReason = failureReasonInvalidSeparator;
 396             failurePosition = pos;
 397             return ContentSecurityPolicy::ReflectedXSSInvalid;
 398         }
 399
 400         if (!skipWhiteSpace(header, pos, false))
 401             return result;
 402
 403         // At start of next directive.
 404         if (skipToken(header, pos, "mode")) {
 405             if (modeDirectiveSeen) {
 406                 failureReason = failureReasonDuplicateMode;
 407                 failurePosition = pos;
 408                 return ContentSecurityPolicy::ReflectedXSSInvalid;
 409             }
 410             modeDirectiveSeen = true;
 411             if (!skipEquals(header, pos)) {
 412                 failureReason = failureReasonInvalidEquals;
 413                 failurePosition = pos;
 414                 return ContentSecurityPolicy::ReflectedXSSInvalid;
 415             }
 416             if (!skipToken(header, pos, "block")) {
 417                 failureReason = failureReasonInvalidMode;
 418                 failurePosition = pos;
 419                 return ContentSecurityPolicy::ReflectedXSSInvalid;
 420             }
 421             result = ContentSecurityPolicy::BlockReflectedXSS;
 422         } else if (skipToken(header, pos, "report")) {
 423             if (reportDirectiveSeen) {
 424                 failureReason = failureReasonDuplicateReport;
 425                 failurePosition = pos;
 426                 return ContentSecurityPolicy::ReflectedXSSInvalid;
 427             }
 428             reportDirectiveSeen = true;
 429             if (!skipEquals(header, pos)) {
 430                 failureReason = failureReasonInvalidEquals;
 431                 failurePosition = pos;
 432                 return ContentSecurityPolicy::ReflectedXSSInvalid;
 433             }
 434             size_t startPos = pos;
 435             if (!skipValue(header, pos)) {
 436                 failureReason = failureReasonInvalidReport;
 437                 failurePosition = pos;
 438                 return ContentSecurityPolicy::ReflectedXSSInvalid;
 439             }
 440             reportURL = header.substring(startPos, pos - startPos);
 441             failurePosition = startPos; // If later semantic check deems unacceptable.
 442         } else {
 443             failureReason = failureReasonInvalidDirective;
 444             failurePosition = pos;
 445             return ContentSecurityPolicy::ReflectedXSSInvalid;
 446         }
 447     }
 448 }
 449
 450 #if ENABLE(NOSNIFF)
 451 ContentTypeOptionsDisposition parseContentTypeOptionsHeader(const String& header)
 452 {
 453     if (header.stripWhiteSpace().lower() == "nosniff")
 454         return ContentTypeOptionsNosniff;
 455     return ContentTypeOptionsNone;
 456 }
 457 #endif
 458
 459 String extractReasonPhraseFromHTTPStatusLine(const String& statusLine)
 460 {
 461     size_t spacePos = statusLine.find(' ');
 462     // Remove status code from the status line.
 463     spacePos = statusLine.find(' ', spacePos + 1);
 464     return statusLine.substring(spacePos + 1);
 465 }
 466
 467 XFrameOptionsDisposition parseXFrameOptionsHeader(const String& header)
 468 {
 469     XFrameOptionsDisposition result = XFrameOptionsNone;
 470
 471     if (header.isEmpty())
 472         return result;
 473
 474     Vector<String> headers;
 475     header.split(',', headers);
 476
 477     for (size_t i = 0; i < headers.size(); i++) {
 478         String currentHeader = headers[i].stripWhiteSpace();
 479         XFrameOptionsDisposition currentValue = XFrameOptionsNone;
 480         if (equalIgnoringCase(currentHeader, "deny"))
 481             currentValue = XFrameOptionsDeny;
 482         else if (equalIgnoringCase(currentHeader, "sameorigin"))
 483             currentValue = XFrameOptionsSameOrigin;
 484         else if (equalIgnoringCase(currentHeader, "allowall"))
 485             currentValue = XFrameOptionsAllowAll;
 486         else
 487             currentValue = XFrameOptionsInvalid;
 488
 489         if (result == XFrameOptionsNone)
 490             result = currentValue;
 491         else if (result != currentValue)
 492             return XFrameOptionsConflict;
 493     }
 494     return result;
 495 }
 496
 497 bool parseRange(const String& range, long long& rangeOffset, long long& rangeEnd, long long& rangeSuffixLength)
 498 {
 499     // The format of "Range" header is defined in RFC 2616 Section 14.35.1.
 500     // http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.1
 501     // We don't support multiple range requests.
 502
 503     rangeOffset = rangeEnd = rangeSuffixLength = -1;
 504
 505     // The "bytes" unit identifier should be present.
 506     static const char bytesStart[] = "bytes=";
 507     if (!range.startsWith(bytesStart, false))
 508         return false;
 509     String byteRange = range.substring(sizeof(bytesStart) - 1);
 510
 511     // The '-' character needs to be present.
 512     int index = byteRange.find('-');
 513     if (index == -1)
 514         return false;
 515
 516     // If the '-' character is at the beginning, the suffix length, which specifies the last N bytes, is provided.
 517     // Example:
 518     //     -500
 519     if (!index) {
 520         String suffixLengthString = byteRange.substring(index + 1).stripWhiteSpace();
 521         bool ok;
 522         long long value = suffixLengthString.toInt64Strict(&ok);
 523         if (ok)
 524             rangeSuffixLength = value;
 525         return true;
 526     }
 527
 528     // Otherwise, the first-byte-position and the last-byte-position are provied.
 529     // Examples:
 530     //     0-499
 531     //     500-
 532     String firstBytePosStr = byteRange.left(index).stripWhiteSpace();
 533     bool ok;
 534     long long firstBytePos = firstBytePosStr.toInt64Strict(&ok);
 535     if (!ok)
 536         return false;
 537
 538     String lastBytePosStr = byteRange.substring(index + 1).stripWhiteSpace();
 539     long long lastBytePos = -1;
 540     if (!lastBytePosStr.isEmpty()) {
 541         lastBytePos = lastBytePosStr.toInt64Strict(&ok);
 542         if (!ok)
 543             return false;
 544     }
 545
 546     if (firstBytePos < 0 || !(lastBytePos == -1 || lastBytePos >= firstBytePos))
 547         return false;
 548
 549     rangeOffset = firstBytePos;
 550     rangeEnd = lastBytePos;
 551     return true;
 552 }
 553
 554 // HTTP/1.1 - RFC 2616
 555 // http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1
 556 // Request-Line = Method SP Request-URI SP HTTP-Version CRLF
 557 size_t parseHTTPRequestLine(const char* data, size_t length, String& failureReason, String& method, String& url, HTTPVersion& httpVersion)
 558 {
 559     method = String();
 560     url = String();
 561     httpVersion = Unknown;
 562
 563     const char* space1 = 0;
 564     const char* space2 = 0;
 565     const char* p;
 566     size_t consumedLength;
 567
 568     for (p = data, consumedLength = 0; consumedLength < length; p++, consumedLength++) {
 569         if (*p == ' ') {
 570             if (!space1)
 571                 space1 = p;
 572             else if (!space2)
 573                 space2 = p;
 574         } else if (*p == '\n')
 575             break;
 576     }
 577
 578     // Haven't finished header line.
 579     if (consumedLength == length) {
 580         failureReason = "Incomplete Request Line";
 581         return 0;
 582     }
 583
 584     // RequestLine does not contain 3 parts.
 585     if (!space1 || !space2) {
 586         failureReason = "Request Line does not appear to contain: <Method> <Url> <HTTPVersion>.";
 587         return 0;
 588     }
 589
 590     // The line must end with "\r\n".
 591     const char* end = p + 1;
 592     if (*(end - 2) != '\r') {
 593         failureReason = "Request line does not end with CRLF";
 594         return 0;
 595     }
 596
 597     // Request Method.
 598     method = String(data, space1 - data); // For length subtract 1 for space, but add 1 for data being the first character.
 599
 600     // Request URI.
 601     url = String(space1 + 1, space2 - space1 - 1); // For length subtract 1 for space.
 602
 603     // HTTP Version.
 604     String httpVersionString(space2 + 1, end - space2 - 3); // For length subtract 1 for space, and 2 for "\r\n".
 605     if (httpVersionString.length() != 8 || !httpVersionString.startsWith("HTTP/1."))
 606         httpVersion = Unknown;
 607     else if (httpVersionString[7] == '0')
 608         httpVersion = HTTP_1_0;
 609     else if (httpVersionString[7] == '1')
 610         httpVersion = HTTP_1_1;
 611     else
 612         httpVersion = Unknown;
 613
 614     return end - data;
 615 }
 616
 617 size_t parseHTTPHeader(const char* start, size_t length, String& failureReason, String& nameStr, String& valueStr, bool strict)
 618 {
 619     const char* p = start;
 620     const char* end = start + length;
 621
 622     Vector<char> name;
 623     Vector<char> value;
 624     nameStr = String();
 625     valueStr = String();
 626
 627     for (; p < end; p++) {
 628         switch (*p) {
 629         case '\r':
 630             if (name.isEmpty()) {
 631                 if (p + 1 < end && *(p + 1) == '\n')
 632                     return (p + 2) - start;
 633                 failureReason = "CR doesn't follow LF at " + trimInputSample(p, end - p);
 634                 return 0;
 635             }
 636             failureReason = "Unexpected CR in name at " + trimInputSample(name.data(), name.size());
 637             return 0;
 638         case '\n':
 639             failureReason = "Unexpected LF in name at " + trimInputSample(name.data(), name.size());
 640             return 0;
 641         case ':':
 642             break;
 643         default:
 644             name.append(*p);
 645             continue;
 646         }
 647         if (*p == ':') {
 648             ++p;
 649             break;
 650         }
 651     }
 652
 653     for (; p < end && *p == 0x20; p++) { }
 654
 655     for (; p < end; p++) {
 656         switch (*p) {
 657         case '\r':
 658             break;
 659         case '\n':
 660             if (strict) {
 661                 failureReason = "Unexpected LF in value at " + trimInputSample(value.data(), value.size());
 662                 return 0;
 663             }
 664             break;
 665         default:
 666             value.append(*p);
 667         }
 668         if (*p == '\r' || (!strict && *p == '\n')) {
 669             ++p;
 670             break;
 671         }
 672     }
 673     if (p >= end || (strict && *p != '\n')) {
 674         failureReason = "CR doesn't follow LF after value at " + trimInputSample(p, end - p);
 675         return 0;
 676     }
 677     nameStr = String::fromUTF8(name.data(), name.size());
 678     valueStr = String::fromUTF8(value.data(), value.size());
 679     if (nameStr.isNull()) {
 680         failureReason = "Invalid UTF-8 sequence in header name";
 681         return 0;
 682     }
 683     if (valueStr.isNull()) {
 684         failureReason = "Invalid UTF-8 sequence in header value";
 685         return 0;
 686     }
 687     return p - start;
 688 }
 689
 690 size_t parseHTTPRequestBody(const char* data, size_t length, Vector<unsigned char>& body)
 691 {
 692     body.clear();
 693     body.append(data, length);
 694
 695     return length;
 696 }
 697
 698 }