The Tor Browser: comparison netwerk/cache2/CacheFileUtils.cpp

--1:000000000000
+:586d9f21b2e1
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "CacheLog.h"
+#include "CacheFileUtils.h"
+#include "LoadContextInfo.h"
+#include "nsCOMPtr.h"
+#include "nsAutoPtr.h"
+#include "nsString.h"
+namespace mozilla {
+namespace net {
+namespace CacheFileUtils {
+namespace { // anon
+/**
+* A simple recursive descent parser for the mapping key.
+*/
+class KeyParser
+{
+public:
+KeyParser(nsACString::const_iterator aCaret, nsACString::const_iterator aEnd)
+: caret(aCaret)
+, end(aEnd)
+// Initialize attributes to their default values
+, appId(nsILoadContextInfo::NO_APP_ID)
+, isPrivate(false)
+, isInBrowser(false)
+, isAnonymous(false)
+// Initialize the cache key to a zero length by default
+, cacheKey(aEnd)
+, lastTag(0)
+{
+}
+private:
+// Current character being parsed
+nsACString::const_iterator caret;
+// The end of the buffer
+nsACString::const_iterator const end;
+// Results
+uint32_t appId;
+bool isPrivate;
+bool isInBrowser;
+bool isAnonymous;
+nsCString idEnhance;
+// Position of the cache key, if present
+nsACString::const_iterator cacheKey;
+// Keeps the last tag name, used for alphabetical sort checking
+char lastTag;
+bool ParseTags()
+{
+// Expects to be at the tag name or at the end
+if (caret == end)
+return true;
+// 'Read' the tag name and move to the next char
+char const tag = *caret++;
+// Check the alphabetical order, hard-fail on disobedience
+if (!(lastTag < tag || tag == ':'))
+return false;
+lastTag = tag;
+switch (tag) {
+case ':':
+// last possible tag, when present there is the cacheKey following,
+// not terminated with ',' and no need to unescape.
+cacheKey = caret;
+caret = end;
+return true;
+case 'p':
+isPrivate = true;
+break;
+case 'b':
+isInBrowser = true;
+break;
+case 'a':
+isAnonymous = true;
+break;
+case 'i': {
+nsAutoCString appIdString;
+if (!ParseValue(&appIdString))
+return false;
+nsresult rv;
+int64_t appId64 = appIdString.ToInteger64(&rv);
+if (NS_FAILED(rv))
+return false; // appid value is mandatory
+if (appId64 < 0 || appId64 > PR_UINT32_MAX)
+return false; // not in the range
+appId = static_cast<uint32_t>(appId64);
+break;
+}
+case '~':
+if (!ParseValue(&idEnhance))
+return false;
+break;
+default:
+if (!ParseValue()) // skip any tag values, optional
+return false;
+break;
+}
+// Recurse to the next tag
+return ParseNextTagOrEnd();
+}
+bool ParseNextTagOrEnd()
+{
+// We expect a comma after every tag
+if (caret == end || *caret++ != ',')
+return false;
+// Go to another tag
+return ParseTags();
+}
+bool ParseValue(nsACString * result = nullptr)
+{
+// If at the end, fail since we expect a comma ; value may be empty tho
+if (caret == end)
+return false;
+// Remeber where the value starts
+nsACString::const_iterator val = caret;
+nsACString::const_iterator comma = end;
+bool escape = false;
+while (caret != end) {
+nsACString::const_iterator at = caret;
+++caret; // we can safely break/continue the loop now
+if (*at == ',') {
+if (comma != end) {
+// another comma (we have found ",," -> escape)
+comma = end;
+escape = true;
+} else {
+comma = at;
+}
+continue;
+}
+if (comma != end) {
+// after a single comma
+break;
+}
+}
+// At this point |comma| points to the last and lone ',' we've hit.
+// If a lone comma was not found, |comma| is at the end of the buffer,
+// that is not expected and we return failure.
+caret = comma;
+if (result) {
+if (escape) {
+// No ReplaceSubstring on nsACString..
+nsAutoCString _result(Substring(val, caret));
+_result.ReplaceSubstring(NS_LITERAL_CSTRING(",,"), NS_LITERAL_CSTRING(","));
+result->Assign(_result);
+} else {
+result->Assign(Substring(val, caret));
+}
+}
+return caret != end;
+}
+public:
+already_AddRefed<LoadContextInfo> Parse()
+{
+nsRefPtr<LoadContextInfo> info;
+if (ParseTags())
+info = GetLoadContextInfo(isPrivate, appId, isInBrowser, isAnonymous);
+return info.forget();
+}
+void URISpec(nsACString &result)
+{
+// cacheKey is either pointing to end or the position where the cache key is.
+result.Assign(Substring(cacheKey, end));
+}
+void IdEnhance(nsACString &result)
+{
+result.Assign(idEnhance);
+}
+};
+} // anon
+already_AddRefed<nsILoadContextInfo>
+ParseKey(const nsCSubstring &aKey,
+nsCSubstring *aIdEnhance,
+nsCSubstring *aURISpec)
+{
+nsACString::const_iterator caret, end;
+aKey.BeginReading(caret);
+aKey.EndReading(end);
+KeyParser parser(caret, end);
+nsRefPtr<LoadContextInfo> info = parser.Parse();
+if (info) {
+if (aIdEnhance)
+parser.IdEnhance(*aIdEnhance);
+if (aURISpec)
+parser.URISpec(*aURISpec);
+}
+return info.forget();
+}
+void
+AppendKeyPrefix(nsILoadContextInfo* aInfo, nsACString &_retval)
+{
+/**
+* This key is used to salt file hashes.  When form of the key is changed
+* cache entries will fail to find on disk.
+*
+* IMPORTANT NOTE:
+* Keep the attributes list sorted according their ASCII code.
+*/
+if (aInfo->IsAnonymous()) {
+_retval.Append(NS_LITERAL_CSTRING("a,"));
+}
+if (aInfo->IsInBrowserElement()) {
+_retval.Append(NS_LITERAL_CSTRING("b,"));
+}
+if (aInfo->AppId() != nsILoadContextInfo::NO_APP_ID) {
+_retval.Append('i');
+_retval.AppendInt(aInfo->AppId());
+_retval.Append(',');
+}
+if (aInfo->IsPrivate()) {
+_retval.Append(NS_LITERAL_CSTRING("p,"));
+}
+}
+void
+AppendTagWithValue(nsACString & aTarget, char const aTag, nsCSubstring const & aValue)
+{
+aTarget.Append(aTag);
+// First check the value string to save some memory copying
+// for cases we don't need to escape at all (most likely).
+if (!aValue.IsEmpty()) {
+if (aValue.FindChar(',') == kNotFound) {
+// No need to escape
+aTarget.Append(aValue);
+} else {
+nsAutoCString escapedValue(aValue);
+escapedValue.ReplaceSubstring(
+NS_LITERAL_CSTRING(","), NS_LITERAL_CSTRING(",,"));
+aTarget.Append(escapedValue);
+}
+}
+aTarget.Append(',');
+}
+nsresult
+KeyMatchesLoadContextInfo(const nsACString &aKey, nsILoadContextInfo *aInfo,
+bool *_retval)
+{
+nsCOMPtr<nsILoadContextInfo> info = ParseKey(aKey);
+if (!info) {
+return NS_ERROR_FAILURE;
+}
+*_retval = info->Equals(aInfo);
+return NS_OK;
+}
+} // CacheFileUtils
+} // net
+} // mozilla

The Tor Browser / file comparison

comparison: netwerk/cache2/CacheFileUtils.cpp

netwerk/cache2/CacheFileUtils.cpp