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