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
asResourceResponse() const42 inline const ResourceResponse& ResourceResponseBase::asResourceResponse() const
43 {
44 return *static_cast<const ResourceResponse*>(this);
45 }
46
ResourceResponseBase()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
ResourceResponseBase(const KURL & url,const String & mimeType,long long expectedLength,const String & textEncodingName,const String & filename)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
adopt(PassOwnPtr<CrossThreadResourceResponseData> data)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
copyData() const119 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
isHTTP() const136 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
url() const145 const KURL& ResourceResponseBase::url() const
146 {
147 lazyInit(CommonFieldsOnly);
148
149 return m_url;
150 }
151
setURL(const KURL & url)152 void ResourceResponseBase::setURL(const KURL& url)
153 {
154 lazyInit(CommonFieldsOnly);
155 m_isNull = false;
156
157 m_url = url;
158 }
159
mimeType() const160 const String& ResourceResponseBase::mimeType() const
161 {
162 lazyInit(CommonFieldsOnly);
163
164 return m_mimeType;
165 }
166
setMimeType(const String & mimeType)167 void ResourceResponseBase::setMimeType(const String& mimeType)
168 {
169 lazyInit(CommonFieldsOnly);
170 m_isNull = false;
171
172 m_mimeType = mimeType;
173 }
174
expectedContentLength() const175 long long ResourceResponseBase::expectedContentLength() const
176 {
177 lazyInit(CommonFieldsOnly);
178
179 return m_expectedContentLength;
180 }
181
setExpectedContentLength(long long expectedContentLength)182 void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
183 {
184 lazyInit(CommonFieldsOnly);
185 m_isNull = false;
186
187 m_expectedContentLength = expectedContentLength;
188 }
189
textEncodingName() const190 const String& ResourceResponseBase::textEncodingName() const
191 {
192 lazyInit(CommonFieldsOnly);
193
194 return m_textEncodingName;
195 }
196
setTextEncodingName(const String & encodingName)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
suggestedFilename() const206 const String& ResourceResponseBase::suggestedFilename() const
207 {
208 lazyInit(CommonFieldsOnly);
209
210 return m_suggestedFilename;
211 }
212
setSuggestedFilename(const String & suggestedName)213 void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
214 {
215 lazyInit(CommonFieldsOnly);
216 m_isNull = false;
217
218 m_suggestedFilename = suggestedName;
219 }
220
httpStatusCode() const221 int ResourceResponseBase::httpStatusCode() const
222 {
223 lazyInit(CommonFieldsOnly);
224
225 return m_httpStatusCode;
226 }
227
setHTTPStatusCode(int statusCode)228 void ResourceResponseBase::setHTTPStatusCode(int statusCode)
229 {
230 lazyInit(CommonFieldsOnly);
231
232 m_httpStatusCode = statusCode;
233 }
234
httpStatusText() const235 const String& ResourceResponseBase::httpStatusText() const
236 {
237 lazyInit(AllFields);
238
239 return m_httpStatusText;
240 }
241
setHTTPStatusText(const String & statusText)242 void ResourceResponseBase::setHTTPStatusText(const String& statusText)
243 {
244 lazyInit(AllFields);
245
246 m_httpStatusText = statusText;
247 }
248
httpHeaderField(const AtomicString & name) const249 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
httpHeaderField(const char * name) const263 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
setHTTPHeaderField(const AtomicString & name,const String & value)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
httpHeaderFields() const301 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
302 {
303 lazyInit(AllFields);
304
305 return m_httpHeaderFields;
306 }
307
parseCacheControlDirectives() const308 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
cacheControlContainsNoCache() const361 bool ResourceResponseBase::cacheControlContainsNoCache() const
362 {
363 if (!m_haveParsedCacheControlHeader)
364 parseCacheControlDirectives();
365 return m_cacheControlContainsNoCache;
366 }
367
cacheControlContainsNoStore() const368 bool ResourceResponseBase::cacheControlContainsNoStore() const
369 {
370 if (!m_haveParsedCacheControlHeader)
371 parseCacheControlDirectives();
372 return m_cacheControlContainsNoStore;
373 }
374
cacheControlContainsMustRevalidate() const375 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
376 {
377 if (!m_haveParsedCacheControlHeader)
378 parseCacheControlDirectives();
379 return m_cacheControlContainsMustRevalidate;
380 }
381
hasCacheValidatorFields() const382 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
cacheControlMaxAge() const391 double ResourceResponseBase::cacheControlMaxAge() const
392 {
393 if (!m_haveParsedCacheControlHeader)
394 parseCacheControlDirectives();
395 return m_cacheControlMaxAge;
396 }
397
parseDateValueInHeader(const HTTPHeaderMap & headers,const AtomicString & headerName)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
date() const413 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
age() const425 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
expires() const441 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
lastModified() const453 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
isAttachment() const465 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
setLastModifiedDate(time_t lastModifiedDate)479 void ResourceResponseBase::setLastModifiedDate(time_t lastModifiedDate)
480 {
481 lazyInit(AllFields);
482
483 m_lastModifiedDate = lastModifiedDate;
484 }
485
lastModifiedDate() const486 time_t ResourceResponseBase::lastModifiedDate() const
487 {
488 lazyInit(AllFields);
489
490 return m_lastModifiedDate;
491 }
492
wasCached() const493 bool ResourceResponseBase::wasCached() const
494 {
495 lazyInit(AllFields);
496
497 return m_wasCached;
498 }
499
setWasCached(bool value)500 void ResourceResponseBase::setWasCached(bool value)
501 {
502 m_wasCached = value;
503 }
504
connectionReused() const505 bool ResourceResponseBase::connectionReused() const
506 {
507 lazyInit(AllFields);
508
509 return m_connectionReused;
510 }
511
setConnectionReused(bool connectionReused)512 void ResourceResponseBase::setConnectionReused(bool connectionReused)
513 {
514 lazyInit(AllFields);
515
516 m_connectionReused = connectionReused;
517 }
518
connectionID() const519 unsigned ResourceResponseBase::connectionID() const
520 {
521 lazyInit(AllFields);
522
523 return m_connectionID;
524 }
525
setConnectionID(unsigned connectionID)526 void ResourceResponseBase::setConnectionID(unsigned connectionID)
527 {
528 lazyInit(AllFields);
529
530 m_connectionID = connectionID;
531 }
532
resourceLoadTiming() const533 ResourceLoadTiming* ResourceResponseBase::resourceLoadTiming() const
534 {
535 lazyInit(AllFields);
536
537 return m_resourceLoadTiming.get();
538 }
539
setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming)540 void ResourceResponseBase::setResourceLoadTiming(PassRefPtr<ResourceLoadTiming> resourceLoadTiming)
541 {
542 lazyInit(AllFields);
543
544 m_resourceLoadTiming = resourceLoadTiming;
545 }
546
resourceLoadInfo() const547 PassRefPtr<ResourceLoadInfo> ResourceResponseBase::resourceLoadInfo() const
548 {
549 lazyInit(AllFields);
550
551 return m_resourceLoadInfo.get();
552 }
553
setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo)554 void ResourceResponseBase::setResourceLoadInfo(PassRefPtr<ResourceLoadInfo> loadInfo)
555 {
556 lazyInit(AllFields);
557
558 m_resourceLoadInfo = loadInfo;
559 }
560
lazyInit(InitLevel initLevel) const561 void ResourceResponseBase::lazyInit(InitLevel initLevel) const
562 {
563 const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel);
564 }
565
compare(const ResourceResponse & a,const ResourceResponse & b)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
isCacheHeaderSeparator(UChar c)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
isControlCharacter(UChar c)622 static bool isControlCharacter(UChar c)
623 {
624 return c < ' ' || c == 127;
625 }
626
trimToNextSeparator(const String & str)627 static inline String trimToNextSeparator(const String& str)
628 {
629 return str.substring(0, str.find(isCacheHeaderSeparator, 0));
630 }
631
parseCacheHeader(const String & header,Vector<pair<String,String>> & result)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 }
689