REGRESSION (XHR Caching): Uncacheable responses sent by Rails through Apache...
[WebKit-https.git] / Source / WebCore / platform / network / ResourceResponseBase.cpp
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
36 using namespace std;
37
38 namespace WebCore {
39
40 static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result);
41
42 inline const ResourceResponse& ResourceResponseBase::asResourceResponse() const
43 {
44     return *static_cast<const ResourceResponse*>(this);
45 }
46
47 ResourceResponseBase::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
71 ResourceResponseBase::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
99 PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)
100 {
101     OwnPtr<ResourceResponse> response = adoptPtr(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(CommonAndUncommonFields);
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
119 PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
120 {
121     OwnPtr<CrossThreadResourceResponseData> data = adoptPtr(new CrossThreadResourceResponseData);
122     data->m_url = url().copy();
123     data->m_mimeType = mimeType().isolatedCopy();
124     data->m_expectedContentLength = expectedContentLength();
125     data->m_textEncodingName = textEncodingName().isolatedCopy();
126     data->m_suggestedFilename = suggestedFilename().isolatedCopy();
127     data->m_httpStatusCode = httpStatusCode();
128     data->m_httpStatusText = httpStatusText().isolatedCopy();
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
136 bool 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
145 const KURL& ResourceResponseBase::url() const
146 {
147     lazyInit(CommonFieldsOnly);
148
149     return m_url; 
150 }
151
152 void ResourceResponseBase::setURL(const KURL& url)
153 {
154     lazyInit(CommonFieldsOnly);
155     m_isNull = false;
156
157     m_url = url; 
158 }
159
160 const String& ResourceResponseBase::mimeType() const
161 {
162     lazyInit(CommonFieldsOnly);
163
164     return m_mimeType; 
165 }
166
167 void ResourceResponseBase::setMimeType(const String& mimeType)
168 {
169     lazyInit(CommonFieldsOnly);
170     m_isNull = false;
171
172     m_mimeType = mimeType; 
173 }
174
175 long long ResourceResponseBase::expectedContentLength() const 
176 {
177     lazyInit(CommonFieldsOnly);
178
179     return m_expectedContentLength;
180 }
181
182 void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
183 {
184     lazyInit(CommonFieldsOnly);
185     m_isNull = false;
186
187     m_expectedContentLength = expectedContentLength; 
188 }
189
190 const String& ResourceResponseBase::textEncodingName() const
191 {
192     lazyInit(CommonFieldsOnly);
193
194     return m_textEncodingName;
195 }
196
197 void 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
206 const String& ResourceResponseBase::suggestedFilename() const
207 {
208     lazyInit(AllFields);
209
210     return m_suggestedFilename;
211 }
212
213 void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
214 {
215     lazyInit(AllFields);
216     m_isNull = false;
217
218     m_suggestedFilename = suggestedName; 
219 }
220
221 int ResourceResponseBase::httpStatusCode() const
222 {
223     lazyInit(CommonFieldsOnly);
224
225     return m_httpStatusCode;
226 }
227
228 void ResourceResponseBase::setHTTPStatusCode(int statusCode)
229 {
230     lazyInit(CommonFieldsOnly);
231
232     m_httpStatusCode = statusCode;
233 }
234
235 const String& ResourceResponseBase::httpStatusText() const 
236 {
237     lazyInit(CommonAndUncommonFields);
238
239     return m_httpStatusText; 
240 }
241
242 void ResourceResponseBase::setHTTPStatusText(const String& statusText) 
243 {
244     lazyInit(CommonAndUncommonFields);
245
246     m_httpStatusText = statusText; 
247 }
248
249 String 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(CommonAndUncommonFields);
259
260     return m_httpHeaderFields.get(name); 
261 }
262
263 String 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(CommonAndUncommonFields);
273
274     return m_httpHeaderFields.get(name); 
275 }
276
277 void ResourceResponseBase::setHTTPHeaderField(const AtomicString& name, const String& value)
278 {
279     lazyInit(CommonAndUncommonFields);
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
301 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
302 {
303     lazyInit(CommonAndUncommonFields);
304
305     return m_httpHeaderFields;
306 }
307
308 void 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                 if (!isnan(m_cacheControlMaxAge)) {
343                     // First max-age directive wins if there are multiple ones.
344                     continue;
345                 }
346                 bool ok;
347                 double maxAge = directives[i].second.toDouble(&ok);
348                 if (ok)
349                     m_cacheControlMaxAge = maxAge;
350             }
351         }
352     }
353
354     if (!m_cacheControlContainsNoCache) {
355         // Handle Pragma: no-cache
356         // This is deprecated and equivalent to Cache-control: no-cache
357         // Don't bother tokenizing the value, it is not important
358         DEFINE_STATIC_LOCAL(const AtomicString, pragmaHeader, ("pragma"));
359         String pragmaValue = m_httpHeaderFields.get(pragmaHeader);
360
361         m_cacheControlContainsNoCache = pragmaValue.lower().contains(noCacheDirective);
362     }
363 }
364     
365 bool ResourceResponseBase::cacheControlContainsNoCache() const
366 {
367     if (!m_haveParsedCacheControlHeader)
368         parseCacheControlDirectives();
369     return m_cacheControlContainsNoCache;
370 }
371
372 bool ResourceResponseBase::cacheControlContainsNoStore() const
373 {
374     if (!m_haveParsedCacheControlHeader)
375         parseCacheControlDirectives();
376     return m_cacheControlContainsNoStore;
377 }
378
379 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
380 {
381     if (!m_haveParsedCacheControlHeader)
382         parseCacheControlDirectives();
383     return m_cacheControlContainsMustRevalidate;
384 }
385
386 bool ResourceResponseBase::hasCacheValidatorFields() const
387 {
388     lazyInit(CommonFieldsOnly);
389
390     DEFINE_STATIC_LOCAL(const AtomicString, lastModifiedHeader, ("last-modified"));
391     DEFINE_STATIC_LOCAL(const AtomicString, eTagHeader, ("etag"));
392     return !m_httpHeaderFields.get(lastModifiedHeader).isEmpty() || !m_httpHeaderFields.get(eTagHeader).isEmpty();
393 }
394
395 double ResourceResponseBase::cacheControlMaxAge() const
396 {
397     if (!m_haveParsedCacheControlHeader)
398         parseCacheControlDirectives();
399     return m_cacheControlMaxAge;
400 }
401
402 static double parseDateValueInHeader(const HTTPHeaderMap& headers, const AtomicString& headerName)
403 {
404     String headerValue = headers.get(headerName);
405     if (headerValue.isEmpty())
406         return std::numeric_limits<double>::quiet_NaN(); 
407     // This handles all date formats required by RFC2616:
408     // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
409     // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
410     // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
411     double dateInMilliseconds = parseDate(headerValue);
412     if (!isfinite(dateInMilliseconds))
413         return std::numeric_limits<double>::quiet_NaN();
414     return dateInMilliseconds / 1000;
415 }
416
417 double ResourceResponseBase::date() const
418 {
419     lazyInit(CommonFieldsOnly);
420
421     if (!m_haveParsedDateHeader) {
422         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("date"));
423         m_date = parseDateValueInHeader(m_httpHeaderFields, headerName);
424         m_haveParsedDateHeader = true;
425     }
426     return m_date;
427 }
428
429 double ResourceResponseBase::age() const
430 {
431     lazyInit(CommonFieldsOnly);
432
433     if (!m_haveParsedAgeHeader) {
434         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("age"));
435         String headerValue = m_httpHeaderFields.get(headerName);
436         bool ok;
437         m_age = headerValue.toDouble(&ok);
438         if (!ok)
439             m_age = std::numeric_limits<double>::quiet_NaN();
440         m_haveParsedAgeHeader = true;
441     }
442     return m_age;
443 }
444
445 double ResourceResponseBase::expires() const
446 {
447     lazyInit(CommonFieldsOnly);
448
449     if (!m_haveParsedExpiresHeader) {
450         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("expires"));
451         m_expires = parseDateValueInHeader(m_httpHeaderFields, headerName);
452         m_haveParsedExpiresHeader = true;
453     }
454     return m_expires;
455 }
456
457 double ResourceResponseBase::lastModified() const
458 {
459     lazyInit(CommonFieldsOnly);
460
461     if (!m_haveParsedLastModifiedHeader) {
462         DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("last-modified"));
463         m_lastModified = parseDateValueInHeader(m_httpHeaderFields, headerName);
464         m_haveParsedLastModifiedHeader = true;
465     }
466     return m_lastModified;
467 }
468
469 bool ResourceResponseBase::isAttachment() const
470 {
471     lazyInit(CommonAndUncommonFields);
472
473     DEFINE_STATIC_LOCAL(const AtomicString, headerName, ("content-disposition"));
474     String value = m_httpHeaderFields.get(headerName);
475     size_t loc = value.find(';');
476     if (loc != notFound)
477         value = value.left(loc);
478     value = value.stripWhiteSpace();
479     DEFINE_STATIC_LOCAL(const AtomicString, attachmentString, ("attachment"));
480     return equalIgnoringCase(value, attachmentString);
481 }
482   
483 void ResourceResponseBase::setLastModifiedDate(time_t lastModifiedDate)
484 {
485     lazyInit(CommonAndUncommonFields);
486
487     m_lastModifiedDate = lastModifiedDate;
488 }
489
490 time_t ResourceResponseBase::lastModifiedDate() const
491 {
492     lazyInit(CommonAndUncommonFields);
493
494     return m_lastModifiedDate;
495 }
496
497 bool ResourceResponseBase::wasCached() const
498 {
499     lazyInit(CommonAndUncommonFields);
500
501     return m_wasCached;
502 }
503
504 void ResourceResponseBase::setWasCached(bool value)
505 {
506     m_wasCached = value;
507 }
508
509 bool ResourceResponseBase::connectionReused() const
510 {
511     lazyInit(CommonAndUncommonFields);
512
513     return m_connectionReused;
514 }
515
516 void ResourceResponseBase::setConnectionReused(bool connectionReused)
517 {
518     lazyInit(CommonAndUncommonFields);
519
520     m_connectionReused = connectionReused;
521 }
522
523 unsigned ResourceResponseBase::connectionID() const
524 {
525     lazyInit(CommonAndUncommonFields);
526
527     return m_connectionID;
528 }
529
530 void ResourceResponseBase::setConnectionID(unsigned connectionID)
531 {
532     lazyInit(CommonAndUncommonFields);
533
534     m_connectionID = connectionID;
535 }
536
537 ResourceLoadTiming* ResourceResponseBase::resourceLoadTiming() const
538 {
539     lazyInit(CommonAndUncommonFields);
540
541     return m_resourceLoadTiming.get();
542 }
543
544 void ResourceResponseBase::setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming)
545 {
546     lazyInit(CommonAndUncommonFields);
547
548     m_resourceLoadTiming = resourceLoadTiming;
549 }
550
551 PassRefPtr<ResourceLoadInfo> ResourceResponseBase::resourceLoadInfo() const
552 {
553     lazyInit(CommonAndUncommonFields);
554
555     return m_resourceLoadInfo.get();
556 }
557
558 void ResourceResponseBase::setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo)
559 {
560     lazyInit(CommonAndUncommonFields);
561
562     m_resourceLoadInfo = loadInfo;
563 }
564
565 void ResourceResponseBase::lazyInit(InitLevel initLevel) const
566 {
567     const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel);
568 }
569     
570 bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b)
571 {
572     if (a.isNull() != b.isNull())
573         return false;  
574     if (a.url() != b.url())
575         return false;
576     if (a.mimeType() != b.mimeType())
577         return false;
578     if (a.expectedContentLength() != b.expectedContentLength())
579         return false;
580     if (a.textEncodingName() != b.textEncodingName())
581         return false;
582     if (a.suggestedFilename() != b.suggestedFilename())
583         return false;
584     if (a.httpStatusCode() != b.httpStatusCode())
585         return false;
586     if (a.httpStatusText() != b.httpStatusText())
587         return false;
588     if (a.httpHeaderFields() != b.httpHeaderFields())
589         return false;
590     if (a.resourceLoadTiming() && b.resourceLoadTiming() && *a.resourceLoadTiming() == *b.resourceLoadTiming())
591         return ResourceResponse::platformCompare(a, b);
592     if (a.resourceLoadTiming() != b.resourceLoadTiming())
593         return false;
594     return ResourceResponse::platformCompare(a, b);
595 }
596
597 static bool isCacheHeaderSeparator(UChar c)
598 {
599     // See RFC 2616, Section 2.2
600     switch (c) {
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 '=':
616         case '{':
617         case '}':
618         case ' ':
619         case '\t':
620             return true;
621         default:
622             return false;
623     }
624 }
625
626 static bool isControlCharacter(UChar c)
627 {
628     return c < ' ' || c == 127;
629 }
630
631 static inline String trimToNextSeparator(const String& str)
632 {
633     return str.substring(0, str.find(isCacheHeaderSeparator, 0));
634 }
635
636 static void parseCacheHeader(const String& header, Vector<pair<String, String> >& result)
637 {
638     const String safeHeader = header.removeCharacters(isControlCharacter);
639     unsigned max = safeHeader.length();
640     for (unsigned pos = 0; pos < max; /* pos incremented in loop */) {
641         size_t nextCommaPosition = safeHeader.find(',', pos);
642         size_t nextEqualSignPosition = safeHeader.find('=', pos);
643         if (nextEqualSignPosition != notFound && (nextEqualSignPosition < nextCommaPosition || nextCommaPosition == notFound)) {
644             // Get directive name, parse right hand side of equal sign, then add to map
645             String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos).stripWhiteSpace());
646             pos += nextEqualSignPosition - pos + 1;
647
648             String value = safeHeader.substring(pos, max - pos).stripWhiteSpace();
649             if (value[0] == '"') {
650                 // The value is a quoted string
651                 size_t nextDoubleQuotePosition = value.find('"', 1);
652                 if (nextDoubleQuotePosition != notFound) {
653                     // Store the value as a quoted string without quotes
654                     result.append(pair<String, String>(directive, value.substring(1, nextDoubleQuotePosition - 1).stripWhiteSpace()));
655                     pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
656                     // Move past next comma, if there is one
657                     size_t nextCommaPosition2 = safeHeader.find(',', pos);
658                     if (nextCommaPosition2 != notFound)
659                         pos += nextCommaPosition2 - pos + 1;
660                     else
661                         return; // Parse error if there is anything left with no comma
662                 } else {
663                     // Parse error; just use the rest as the value
664                     result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(1, value.length() - 1).stripWhiteSpace())));
665                     return;
666                 }
667             } else {
668                 // The value is a token until the next comma
669                 size_t nextCommaPosition2 = value.find(',', 0);
670                 if (nextCommaPosition2 != notFound) {
671                     // The value is delimited by the next comma
672                     result.append(pair<String, String>(directive, trimToNextSeparator(value.substring(0, nextCommaPosition2).stripWhiteSpace())));
673                     pos += (safeHeader.find(',', pos) - pos) + 1;
674                 } else {
675                     // The rest is the value; no change to value needed
676                     result.append(pair<String, String>(directive, trimToNextSeparator(value)));
677                     return;
678                 }
679             }
680         } else if (nextCommaPosition != notFound && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition == notFound)) {
681             // Add directive to map with empty string as value
682             result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos).stripWhiteSpace()), ""));
683             pos += nextCommaPosition - pos + 1;
684         } else {
685             // Add last directive to map with empty string as value
686             result.append(pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), ""));
687             return;
688         }
689     }
690 }
691
692 }