1/* 2 * Copyright (C) 2006, 2008 Apple Inc. All rights reserved. 3 * Copyright (C) 2009 Google Inc. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY 15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR 18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 21 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27#include "config.h" 28#include "ResourceResponseBase.h" 29 30#include "HTTPParsers.h" 31#include "ResourceResponse.h" 32#include <wtf/CurrentTime.h> 33#include <wtf/MathExtras.h> 34#include <wtf/StdLibExtras.h> 35 36using namespace std; 37 38namespace WebCore { 39 40static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result); 41 42inline const ResourceResponse& ResourceResponseBase::asResourceResponse() const 43{ 44 return *static_cast<const ResourceResponse*>(this); 45} 46 47ResourceResponseBase::ResourceResponseBase() 48 : m_expectedContentLength(0) 49 , m_httpStatusCode(0) 50 , m_lastModifiedDate(0) 51 , m_wasCached(false) 52 , m_connectionID(0) 53 , m_connectionReused(false) 54 , m_isNull(true) 55 , m_haveParsedCacheControlHeader(false) 56 , m_haveParsedAgeHeader(false) 57 , m_haveParsedDateHeader(false) 58 , m_haveParsedExpiresHeader(false) 59 , m_haveParsedLastModifiedHeader(false) 60 , m_cacheControlContainsNoCache(false) 61 , m_cacheControlContainsNoStore(false) 62 , m_cacheControlContainsMustRevalidate(false) 63 , m_cacheControlMaxAge(0.0) 64 , m_age(0.0) 65 , m_date(0.0) 66 , m_expires(0.0) 67 , m_lastModified(0.0) 68{ 69} 70 71ResourceResponseBase::ResourceResponseBase(const KURL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename) 72 : m_url(url) 73 , m_mimeType(mimeType) 74 , m_expectedContentLength(expectedLength) 75 , m_textEncodingName(textEncodingName) 76 , m_suggestedFilename(filename) 77 , m_httpStatusCode(0) 78 , m_lastModifiedDate(0) 79 , m_wasCached(false) 80 , m_connectionID(0) 81 , m_connectionReused(false) 82 , m_isNull(false) 83 , m_haveParsedCacheControlHeader(false) 84 , m_haveParsedAgeHeader(false) 85 , m_haveParsedDateHeader(false) 86 , m_haveParsedExpiresHeader(false) 87 , m_haveParsedLastModifiedHeader(false) 88 , m_cacheControlContainsNoCache(false) 89 , m_cacheControlContainsNoStore(false) 90 , m_cacheControlContainsMustRevalidate(false) 91 , m_cacheControlMaxAge(0.0) 92 , m_age(0.0) 93 , m_date(0.0) 94 , m_expires(0.0) 95 , m_lastModified(0.0) 96{ 97} 98 99PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadResourceResponseData> data) 100{ 101 OwnPtr<ResourceResponse> response(new ResourceResponse()); 102 response->setURL(data->m_url); 103 response->setMimeType(data->m_mimeType); 104 response->setExpectedContentLength(data->m_expectedContentLength); 105 response->setTextEncodingName(data->m_textEncodingName); 106 response->setSuggestedFilename(data->m_suggestedFilename); 107 108 response->setHTTPStatusCode(data->m_httpStatusCode); 109 response->setHTTPStatusText(data->m_httpStatusText); 110 111 response->lazyInit(AllFields); 112 response->m_httpHeaderFields.adopt(data->m_httpHeaders.release()); 113 response->setLastModifiedDate(data->m_lastModifiedDate); 114 response->setResourceLoadTiming(data->m_resourceLoadTiming.release()); 115 response->doPlatformAdopt(data); 116 return response.release(); 117} 118 119PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const 120{ 121 OwnPtr<CrossThreadResourceResponseData> data(new CrossThreadResourceResponseData()); 122 data->m_url = url().copy(); 123 data->m_mimeType = mimeType().crossThreadString(); 124 data->m_expectedContentLength = expectedContentLength(); 125 data->m_textEncodingName = textEncodingName().crossThreadString(); 126 data->m_suggestedFilename = suggestedFilename().crossThreadString(); 127 data->m_httpStatusCode = httpStatusCode(); 128 data->m_httpStatusText = httpStatusText().crossThreadString(); 129 data->m_httpHeaders = httpHeaderFields().copyData(); 130 data->m_lastModifiedDate = lastModifiedDate(); 131 if (m_resourceLoadTiming) 132 data->m_resourceLoadTiming = m_resourceLoadTiming->deepCopy(); 133 return asResourceResponse().doPlatformCopyData(data.release()); 134} 135 136bool ResourceResponseBase::isHTTP() const 137{ 138 lazyInit(CommonFieldsOnly); 139 140 String protocol = m_url.protocol(); 141 142 return equalIgnoringCase(protocol, "http") || equalIgnoringCase(protocol, "https"); 143} 144 145const KURL& ResourceResponseBase::url() const 146{ 147 lazyInit(CommonFieldsOnly); 148 149 return m_url; 150} 151 152void ResourceResponseBase::setURL(const KURL& url) 153{ 154 lazyInit(CommonFieldsOnly); 155 m_isNull = false; 156 157 m_url = url; 158} 159 160const String& ResourceResponseBase::mimeType() const 161{ 162 lazyInit(CommonFieldsOnly); 163 164 return m_mimeType; 165} 166 167void ResourceResponseBase::setMimeType(const String& mimeType) 168{ 169 lazyInit(CommonFieldsOnly); 170 m_isNull = false; 171 172 m_mimeType = mimeType; 173} 174 175long long ResourceResponseBase::expectedContentLength() const 176{ 177 lazyInit(CommonFieldsOnly); 178 179 return m_expectedContentLength; 180} 181 182void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength) 183{ 184 lazyInit(CommonFieldsOnly); 185 m_isNull = false; 186 187 m_expectedContentLength = expectedContentLength; 188} 189 190const String& ResourceResponseBase::textEncodingName() const 191{ 192 lazyInit(CommonFieldsOnly); 193 194 return m_textEncodingName; 195} 196 197void ResourceResponseBase::setTextEncodingName(const String& encodingName) 198{ 199 lazyInit(CommonFieldsOnly); 200 m_isNull = false; 201 202 m_textEncodingName = encodingName; 203} 204 205// FIXME should compute this on the fly 206const String& ResourceResponseBase::suggestedFilename() const 207{ 208 lazyInit(CommonFieldsOnly); 209 210 return m_suggestedFilename; 211} 212 213void ResourceResponseBase::setSuggestedFilename(const String& suggestedName) 214{ 215 lazyInit(CommonFieldsOnly); 216 m_isNull = false; 217 218 m_suggestedFilename = suggestedName; 219} 220 221int ResourceResponseBase::httpStatusCode() const 222{ 223 lazyInit(CommonFieldsOnly); 224 225 return m_httpStatusCode; 226} 227 228void ResourceResponseBase::setHTTPStatusCode(int statusCode) 229{ 230 lazyInit(CommonFieldsOnly); 231 232 m_httpStatusCode = statusCode; 233} 234 235const String& ResourceResponseBase::httpStatusText() const 236{ 237 lazyInit(AllFields); 238 239 return m_httpStatusText; 240} 241 242void ResourceResponseBase::setHTTPStatusText(const String& statusText) 243{ 244 lazyInit(AllFields); 245 246 m_httpStatusText = statusText; 247} 248 249String ResourceResponseBase::httpHeaderField(const AtomicString& name) const 250{ 251 lazyInit(CommonFieldsOnly); 252 253 // If we already have the header, just return it instead of consuming memory by grabing all headers. 254 String value = m_httpHeaderFields.get(name); 255 if (!value.isEmpty()) 256 return value; 257 258 lazyInit(AllFields); 259 260 return m_httpHeaderFields.get(name); 261} 262 263String ResourceResponseBase::httpHeaderField(const char* name) const 264{ 265 lazyInit(CommonFieldsOnly); 266 267 // If we already have the header, just return it instead of consuming memory by grabing all headers. 268 String value = m_httpHeaderFields.get(name); 269 if (!value.isEmpty()) 270 return value; 271 272 lazyInit(AllFields); 273 274 return m_httpHeaderFields.get(name); 275} 276 277void ResourceResponseBase::setHTTPHeaderField(const AtomicString& name, const String& value) 278{ 279 lazyInit(AllFields); 280 281 DEFINE_STATIC_LOCAL(const AtomicString, ageHeader, ("age")); 282 DEFINE_STATIC_LOCAL(const AtomicString, cacheControlHeader, ("cache-control")); 283 DEFINE_STATIC_LOCAL(const AtomicString, dateHeader, ("date")); 284 DEFINE_STATIC_LOCAL(const AtomicString, expiresHeader, ("expires")); 285 DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified")); 286 DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma")); 287 if (equalIgnoringCase(name, ageHeader)) 288 m_haveParsedAgeHeader = false; 289 else if (equalIgnoringCase(name, cacheControlHeader) || equalIgnoringCase(name, pragmaHeader)) 290 m_haveParsedCacheControlHeader = false; 291 else if (equalIgnoringCase(name, dateHeader)) 292 m_haveParsedDateHeader = false; 293 else if (equalIgnoringCase(name, expiresHeader)) 294 m_haveParsedExpiresHeader = false; 295 else if (equalIgnoringCase(name, lastModifiedHeader)) 296 m_haveParsedLastModifiedHeader = false; 297 298 m_httpHeaderFields.set(name, value); 299} 300 301const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const 302{ 303 lazyInit(AllFields); 304 305 return m_httpHeaderFields; 306} 307 308void ResourceResponseBase::parseCacheControlDirectives() const 309{ 310 ASSERT(!m_haveParsedCacheControlHeader); 311 312 lazyInit(CommonFieldsOnly); 313 314 m_haveParsedCacheControlHeader = true; 315 316 m_cacheControlContainsMustRevalidate = false; 317 m_cacheControlContainsNoCache = false; 318 m_cacheControlMaxAge = numeric_limits<double>::quiet_NaN(); 319 320 DEFINE_STATIC_LOCAL(const AtomicString, cacheControlString, ("cache-control")); 321 DEFINE_STATIC_LOCAL(const AtomicString, noCacheDirective, ("no-cache")); 322 DEFINE_STATIC_LOCAL(const AtomicString, noStoreDirective, ("no-store")); 323 DEFINE_STATIC_LOCAL(const AtomicString, mustRevalidateDirective, ("must-revalidate")); 324 DEFINE_STATIC_LOCAL(const AtomicString, maxAgeDirective, ("max-age")); 325 326 String cacheControlValue = m_httpHeaderFields.get(cacheControlString); 327 if (!cacheControlValue.isEmpty()) { 328 Vector<pair<String, String> > directives; 329 parseCacheHeader(cacheControlValue, directives); 330 331 size_t directivesSize = directives.size(); 332 for (size_t i = 0; i < directivesSize; ++i) { 333 // RFC2616 14.9.1: A no-cache directive with a value is only meaningful for proxy caches. 334 // It should be ignored by a browser level cache. 335 if (equalIgnoringCase(directives[i].first, noCacheDirective) && directives[i].second.isEmpty()) 336 m_cacheControlContainsNoCache = true; 337 else if (equalIgnoringCase(directives[i].first, noStoreDirective)) 338 m_cacheControlContainsNoStore = true; 339 else if (equalIgnoringCase(directives[i].first, mustRevalidateDirective)) 340 m_cacheControlContainsMustRevalidate = true; 341 else if (equalIgnoringCase(directives[i].first, maxAgeDirective)) { 342 bool ok; 343 double maxAge = directives[i].second.toDouble(&ok); 344 if (ok) 345 m_cacheControlMaxAge = maxAge; 346 } 347 } 348 } 349 350 if (!m_cacheControlContainsNoCache) { 351 // Handle Pragma: no-cache 352 // This is deprecated and equivalent to Cache-control: no-cache 353 // Don't bother tokenizing the value, it is not important 354 DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma")); 355 String pragmaValue = m_httpHeaderFields.get(pragmaHeader); 356 357 m_cacheControlContainsNoCache = pragmaValue.lower().contains(noCacheDirective); 358 } 359} 360 361bool ResourceResponseBase::cacheControlContainsNoCache() const 362{ 363 if (!m_haveParsedCacheControlHeader) 364 parseCacheControlDirectives(); 365 return m_cacheControlContainsNoCache; 366} 367 368bool ResourceResponseBase::cacheControlContainsNoStore() const 369{ 370 if (!m_haveParsedCacheControlHeader) 371 parseCacheControlDirectives(); 372 return m_cacheControlContainsNoStore; 373} 374 375bool ResourceResponseBase::cacheControlContainsMustRevalidate() const 376{ 377 if (!m_haveParsedCacheControlHeader) 378 parseCacheControlDirectives(); 379 return m_cacheControlContainsMustRevalidate; 380} 381 382bool ResourceResponseBase::hasCacheValidatorFields() const 383{ 384 lazyInit(CommonFieldsOnly); 385 386 DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified")); 387 DEFINE_STATIC_LOCAL(const AtomicString, eTagHeader, ("etag")); 388 return !m_httpHeaderFields.get(lastModifiedHeader).isEmpty() || !m_httpHeaderFields.get(eTagHeader).isEmpty(); 389} 390 391double ResourceResponseBase::cacheControlMaxAge() const 392{ 393 if (!m_haveParsedCacheControlHeader) 394 parseCacheControlDirectives(); 395 return m_cacheControlMaxAge; 396} 397 398static double parseDateValueInHeader(const HTTPHeaderMap& headers, const AtomicString& headerName) 399{ 400 String headerValue = headers.get(headerName); 401 if (headerValue.isEmpty()) 402 return std::numeric_limits<double>::quiet_NaN(); 403 // This handles all date formats required by RFC2616: 404 // Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123 405 // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036 406 // Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format 407 double dateInMilliseconds = parseDate(headerValue); 408 if (!isfinite(dateInMilliseconds)) 409 return std::numeric_limits<double>::quiet_NaN(); 410 return dateInMilliseconds / 1000; 411} 412 413double ResourceResponseBase::date() const 414{ 415 lazyInit(CommonFieldsOnly); 416 417 if (!m_haveParsedDateHeader) { 418 DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date")); 419 m_date = parseDateValueInHeader(m_httpHeaderFields, headerName); 420 m_haveParsedDateHeader = true; 421 } 422 return m_date; 423} 424 425double ResourceResponseBase::age() const 426{ 427 lazyInit(CommonFieldsOnly); 428 429 if (!m_haveParsedAgeHeader) { 430 DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age")); 431 String headerValue = m_httpHeaderFields.get(headerName); 432 bool ok; 433 m_age = headerValue.toDouble(&ok); 434 if (!ok) 435 m_age = std::numeric_limits<double>::quiet_NaN(); 436 m_haveParsedAgeHeader = true; 437 } 438 return m_age; 439} 440 441double ResourceResponseBase::expires() const 442{ 443 lazyInit(CommonFieldsOnly); 444 445 if (!m_haveParsedExpiresHeader) { 446 DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires")); 447 m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName); 448 m_haveParsedExpiresHeader = true; 449 } 450 return m_expires; 451} 452 453double ResourceResponseBase::lastModified() const 454{ 455 lazyInit(CommonFieldsOnly); 456 457 if (!m_haveParsedLastModifiedHeader) { 458 DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified")); 459 m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName); 460 m_haveParsedLastModifiedHeader = true; 461 } 462 return m_lastModified; 463} 464 465bool ResourceResponseBase::isAttachment() const 466{ 467 lazyInit(AllFields); 468 469 DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition")); 470 String value = m_httpHeaderFields.get(headerName); 471 size_t loc = value.find(';'); 472 if (loc != notFound) 473 value = value.left(loc); 474 value = value.stripWhiteSpace(); 475 DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment")); 476 return equalIgnoringCase(value, attachmentString); 477} 478 479void ResourceResponseBase::setLastModifiedDate(time_t lastModifiedDate) 480{ 481 lazyInit(AllFields); 482 483 m_lastModifiedDate = lastModifiedDate; 484} 485 486time_t ResourceResponseBase::lastModifiedDate() const 487{ 488 lazyInit(AllFields); 489 490 return m_lastModifiedDate; 491} 492 493bool ResourceResponseBase::wasCached() const 494{ 495 lazyInit(AllFields); 496 497 return m_wasCached; 498} 499 500void ResourceResponseBase::setWasCached(bool value) 501{ 502 m_wasCached = value; 503} 504 505bool ResourceResponseBase::connectionReused() const 506{ 507 lazyInit(AllFields); 508 509 return m_connectionReused; 510} 511 512void ResourceResponseBase::setConnectionReused(bool connectionReused) 513{ 514 lazyInit(AllFields); 515 516 m_connectionReused = connectionReused; 517} 518 519unsigned ResourceResponseBase::connectionID() const 520{ 521 lazyInit(AllFields); 522 523 return m_connectionID; 524} 525 526void ResourceResponseBase::setConnectionID(unsigned connectionID) 527{ 528 lazyInit(AllFields); 529 530 m_connectionID = connectionID; 531} 532 533ResourceLoadTiming* ResourceResponseBase::resourceLoadTiming() const 534{ 535 lazyInit(AllFields); 536 537 return m_resourceLoadTiming.get(); 538} 539 540void ResourceResponseBase::setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming) 541{ 542 lazyInit(AllFields); 543 544 m_resourceLoadTiming = resourceLoadTiming; 545} 546 547PassRefPtr<ResourceLoadInfo> ResourceResponseBase::resourceLoadInfo() const 548{ 549 lazyInit(AllFields); 550 551 return m_resourceLoadInfo.get(); 552} 553 554void ResourceResponseBase::setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo) 555{ 556 lazyInit(AllFields); 557 558 m_resourceLoadInfo = loadInfo; 559} 560 561void ResourceResponseBase::lazyInit(InitLevel initLevel) const 562{ 563 const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel); 564} 565 566bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b) 567{ 568 if (a.isNull() != b.isNull()) 569 return false; 570 if (a.url() != b.url()) 571 return false; 572 if (a.mimeType() != b.mimeType()) 573 return false; 574 if (a.expectedContentLength() != b.expectedContentLength()) 575 return false; 576 if (a.textEncodingName() != b.textEncodingName()) 577 return false; 578 if (a.suggestedFilename() != b.suggestedFilename()) 579 return false; 580 if (a.httpStatusCode() != b.httpStatusCode()) 581 return false; 582 if (a.httpStatusText() != b.httpStatusText()) 583 return false; 584 if (a.httpHeaderFields() != b.httpHeaderFields()) 585 return false; 586 if (a.resourceLoadTiming() && b.resourceLoadTiming() && *a.resourceLoadTiming() == *b.resourceLoadTiming()) 587 return ResourceResponse::platformCompare(a, b); 588 if (a.resourceLoadTiming() != b.resourceLoadTiming()) 589 return false; 590 return ResourceResponse::platformCompare(a, b); 591} 592 593static bool isCacheHeaderSeparator(UChar c) 594{ 595 // See RFC 2616, Section 2.2 596 switch (c) { 597 case '(': 598 case ')': 599 case '<': 600 case '>': 601 case '@': 602 case ',': 603 case ';': 604 case ':': 605 case '\\': 606 case '"': 607 case '/': 608 case '[': 609 case ']': 610 case '?': 611 case '=': 612 case '{': 613 case '}': 614 case ' ': 615 case '\t': 616 return true; 617 default: 618 return false; 619 } 620} 621 622static bool isControlCharacter(UChar c) 623{ 624 return c < ' ' || c == 127; 625} 626 627static inline String trimToNextSeparator(const String& str) 628{ 629 return str.substring(0, str.find(isCacheHeaderSeparator, 0)); 630} 631 632static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result) 633{ 634 const String safeHeader = header.removeCharacters(isControlCharacter); 635 unsigned max = safeHeader.length(); 636 for (unsigned pos = 0; pos < max; /* pos incremented in loop */) { 637 size_t nextCommaPosition = safeHeader.find(',', pos); 638 size_t nextEqualSignPosition = safeHeader.find('=', pos); 639 if (nextEqualSignPosition != notFound && (nextEqualSignPosition < nextCommaPosition || nextCommaPosition == notFound)) { 640 // Get directive name, parse right hand side of equal sign, then add to map 641 String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos).stripWhiteSpace()); 642 pos += nextEqualSignPosition - pos + 1; 643 644 String value = safeHeader.substring(pos, max - pos).stripWhiteSpace(); 645 if (value[0] == '"') { 646 // The value is a quoted string 647 size_t nextDoubleQuotePosition = value.find('"', 1); 648 if (nextDoubleQuotePosition != notFound) { 649 // Store the value as a quoted string without quotes 650 result.append(pair<String, String>(directive, value.substring(1, nextDoubleQuotePosition - 1).stripWhiteSpace())); 651 pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1; 652 // Move past next comma, if there is one 653 size_t nextCommaPosition2 = safeHeader.find(',', pos); 654 if (nextCommaPosition2 != notFound) 655 pos += nextCommaPosition2 - pos + 1; 656 else 657 return; // Parse error if there is anything left with no comma 658 } else { 659 // Parse error; just use the rest as the value 660 result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(1, value.length() - 1).stripWhiteSpace()))); 661 return; 662 } 663 } else { 664 // The value is a token until the next comma 665 size_t nextCommaPosition2 = value.find(',', 0); 666 if (nextCommaPosition2 != notFound) { 667 // The value is delimited by the next comma 668 result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(0, nextCommaPosition2).stripWhiteSpace()))); 669 pos += (safeHeader.find(',', pos) - pos) + 1; 670 } else { 671 // The rest is the value; no change to value needed 672 result.append(pair<String, String>(directive, trimToNextSeparator(value))); 673 return; 674 } 675 } 676 } else if (nextCommaPosition != notFound && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition == notFound)) { 677 // Add directive to map with empty string as value 678 result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos).stripWhiteSpace()), "")); 679 pos += nextCommaPosition - pos + 1; 680 } else { 681 // Add last directive to map with empty string as value 682 result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), "")); 683 return; 684 } 685 } 686} 687 688} 689