2011-04-01 Michael Saboff <msaboff@apple.com>
[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(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
119 PassOwnPtr<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
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(CommonFieldsOnly);
209
210     return m_suggestedFilename;
211 }
212
213 void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
214 {
215     lazyInit(CommonFieldsOnly);
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(AllFields);
238
239     return m_httpStatusText; 
240 }
241
242 void ResourceResponseBase::setHTTPStatusText(const String& statusText) 
243 {
244     lazyInit(AllFields);
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(AllFields);
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(AllFields);
273
274     return m_httpHeaderFields.get(name); 
275 }
276
277 void 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
301 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
302 {
303     lazyInit(AllFields);
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                 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     
361 bool ResourceResponseBase::cacheControlContainsNoCache() const
362 {
363     if (!m_haveParsedCacheControlHeader)
364         parseCacheControlDirectives();
365     return m_cacheControlContainsNoCache;
366 }
367
368 bool ResourceResponseBase::cacheControlContainsNoStore() const
369 {
370     if (!m_haveParsedCacheControlHeader)
371         parseCacheControlDirectives();
372     return m_cacheControlContainsNoStore;
373 }
374
375 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
376 {
377     if (!m_haveParsedCacheControlHeader)
378         parseCacheControlDirectives();
379     return m_cacheControlContainsMustRevalidate;
380 }
381
382 bool 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
391 double ResourceResponseBase::cacheControlMaxAge() const
392 {
393     if (!m_haveParsedCacheControlHeader)
394         parseCacheControlDirectives();
395     return m_cacheControlMaxAge;
396 }
397
398 static 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
413 double 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
425 double 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
441 double 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
453 double 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
465 bool 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   
479 void ResourceResponseBase::setLastModifiedDate(time_t lastModifiedDate)
480 {
481     lazyInit(AllFields);
482
483     m_lastModifiedDate = lastModifiedDate;
484 }
485
486 time_t ResourceResponseBase::lastModifiedDate() const
487 {
488     lazyInit(AllFields);
489
490     return m_lastModifiedDate;
491 }
492
493 bool ResourceResponseBase::wasCached() const
494 {
495     lazyInit(AllFields);
496
497     return m_wasCached;
498 }
499
500 void ResourceResponseBase::setWasCached(bool value)
501 {
502     m_wasCached = value;
503 }
504
505 bool ResourceResponseBase::connectionReused() const
506 {
507     lazyInit(AllFields);
508
509     return m_connectionReused;
510 }
511
512 void ResourceResponseBase::setConnectionReused(bool connectionReused)
513 {
514     lazyInit(AllFields);
515
516     m_connectionReused = connectionReused;
517 }
518
519 unsigned ResourceResponseBase::connectionID() const
520 {
521     lazyInit(AllFields);
522
523     return m_connectionID;
524 }
525
526 void ResourceResponseBase::setConnectionID(unsigned connectionID)
527 {
528     lazyInit(AllFields);
529
530     m_connectionID = connectionID;
531 }
532
533 ResourceLoadTiming* ResourceResponseBase::resourceLoadTiming() const
534 {
535     lazyInit(AllFields);
536
537     return m_resourceLoadTiming.get();
538 }
539
540 void ResourceResponseBase::setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming)
541 {
542     lazyInit(AllFields);
543
544     m_resourceLoadTiming = resourceLoadTiming;
545 }
546
547 PassRefPtr<ResourceLoadInfo> ResourceResponseBase::resourceLoadInfo() const
548 {
549     lazyInit(AllFields);
550
551     return m_resourceLoadInfo.get();
552 }
553
554 void ResourceResponseBase::setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo)
555 {
556     lazyInit(AllFields);
557
558     m_resourceLoadInfo = loadInfo;
559 }
560
561 void ResourceResponseBase::lazyInit(InitLevel initLevel) const
562 {
563     const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel);
564 }
565     
566 bool 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
593 static 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
622 static bool isControlCharacter(UChar c)
623 {
624     return c < ' ' || c == 127;
625 }
626
627 static inline String trimToNextSeparator(const String& str)
628 {
629     return str.substring(0, str.find(isCacheHeaderSeparator, 0));
630 }
631
632 static 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 }