tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

PHttpChannelParams.h (10094B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set sw=2 ts=8 et tw=80 : */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #ifndef mozilla_net_PHttpChannelParams_h
      8 #define mozilla_net_PHttpChannelParams_h
      9 
     10 #define ALLOW_LATE_NSHTTP_H_INCLUDE 1
     11 #include "base/basictypes.h"
     12 
     13 #include "ipc/IPCMessageUtils.h"
     14 #include "ipc/IPCMessageUtilsSpecializations.h"
     15 #include "nsHttp.h"
     16 #include "nsHttpHeaderArray.h"
     17 #include "nsHttpRequestHead.h"
     18 #include "nsHttpResponseHead.h"
     19 
     20 namespace mozilla {
     21 namespace net {
     22 
     23 struct RequestHeaderTuple {
     24  nsCString mHeader;
     25  nsCString mValue;
     26  bool mMerge;
     27  bool mEmpty;
     28 
     29  bool operator==(const RequestHeaderTuple& other) const {
     30    return mHeader.Equals(other.mHeader) && mValue.Equals(other.mValue) &&
     31           mMerge == other.mMerge && mEmpty == other.mEmpty;
     32  }
     33 };
     34 
     35 typedef CopyableTArray<RequestHeaderTuple> RequestHeaderTuples;
     36 
     37 }  // namespace net
     38 }  // namespace mozilla
     39 
     40 namespace IPC {
     41 
     42 template <>
     43 struct ParamTraits<mozilla::net::RequestHeaderTuple> {
     44  typedef mozilla::net::RequestHeaderTuple paramType;
     45 
     46  static void Write(MessageWriter* aWriter, const paramType& aParam) {
     47    WriteParam(aWriter, aParam.mHeader);
     48    WriteParam(aWriter, aParam.mValue);
     49    WriteParam(aWriter, aParam.mMerge);
     50    WriteParam(aWriter, aParam.mEmpty);
     51  }
     52 
     53  static bool Read(MessageReader* aReader, paramType* aResult) {
     54    if (!ReadParam(aReader, &aResult->mHeader) ||
     55        !ReadParam(aReader, &aResult->mValue) ||
     56        !ReadParam(aReader, &aResult->mMerge) ||
     57        !ReadParam(aReader, &aResult->mEmpty))
     58      return false;
     59 
     60    return true;
     61  }
     62 };
     63 
     64 template <>
     65 struct ParamTraits<mozilla::net::nsHttpAtom> {
     66  typedef mozilla::net::nsHttpAtom paramType;
     67 
     68  static void Write(MessageWriter* aWriter, const paramType& aParam) {
     69    // aParam.get() cannot be null.
     70    MOZ_ASSERT(aParam.get(), "null nsHTTPAtom value");
     71    nsAutoCString value(aParam.get());
     72    WriteParam(aWriter, value);
     73  }
     74 
     75  static bool Read(MessageReader* aReader, paramType* aResult) {
     76    nsAutoCString value;
     77    if (!ReadParam(aReader, &value)) return false;
     78 
     79    *aResult = mozilla::net::nsHttp::ResolveAtom(value);
     80    MOZ_ASSERT(aResult->get(), "atom table not initialized");
     81    return true;
     82  }
     83 };
     84 
     85 template <>
     86 struct ParamTraits<mozilla::net::nsHttpHeaderArray::nsEntry> {
     87  typedef mozilla::net::nsHttpHeaderArray::nsEntry paramType;
     88 
     89  static void Write(MessageWriter* aWriter, const paramType& aParam) {
     90    if (aParam.headerNameOriginal.IsEmpty()) {
     91      WriteParam(aWriter, aParam.header);
     92    } else {
     93      WriteParam(aWriter, aParam.headerNameOriginal);
     94    }
     95    WriteParam(aWriter, aParam.value);
     96    switch (aParam.variety) {
     97      case mozilla::net::nsHttpHeaderArray::eVarietyUnknown:
     98        WriteParam(aWriter, (uint8_t)0);
     99        break;
    100      case mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride:
    101        WriteParam(aWriter, (uint8_t)1);
    102        break;
    103      case mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault:
    104        WriteParam(aWriter, (uint8_t)2);
    105        break;
    106      case mozilla::net::nsHttpHeaderArray::eVarietyRequestEnforceDefault:
    107        WriteParam(aWriter, (uint8_t)3);
    108        break;
    109      case mozilla::net::nsHttpHeaderArray::
    110          eVarietyResponseNetOriginalAndResponse:
    111        WriteParam(aWriter, (uint8_t)4);
    112        break;
    113      case mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal:
    114        WriteParam(aWriter, (uint8_t)5);
    115        break;
    116      case mozilla::net::nsHttpHeaderArray::eVarietyResponse:
    117        WriteParam(aWriter, (uint8_t)6);
    118        break;
    119      case mozilla::net::nsHttpHeaderArray::eVarietyResponseOverride:
    120        WriteParam(aWriter, (uint8_t)7);
    121        break;
    122    }
    123  }
    124 
    125  static bool Read(MessageReader* aReader, paramType* aResult) {
    126    uint8_t variety;
    127    nsAutoCString header;
    128    if (!ReadParam(aReader, &header) || !ReadParam(aReader, &aResult->value) ||
    129        !ReadParam(aReader, &variety))
    130      return false;
    131 
    132    mozilla::net::nsHttpAtom atom = mozilla::net::nsHttp::ResolveAtom(header);
    133    aResult->header = atom;
    134    if (!header.Equals(atom.get())) {
    135      aResult->headerNameOriginal = header;
    136    }
    137 
    138    switch (variety) {
    139      case 0:
    140        aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyUnknown;
    141        break;
    142      case 1:
    143        aResult->variety =
    144            mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride;
    145        break;
    146      case 2:
    147        aResult->variety =
    148            mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault;
    149        break;
    150      case 3:
    151        aResult->variety =
    152            mozilla::net::nsHttpHeaderArray::eVarietyRequestEnforceDefault;
    153        break;
    154      case 4:
    155        aResult->variety = mozilla::net::nsHttpHeaderArray::
    156            eVarietyResponseNetOriginalAndResponse;
    157        break;
    158      case 5:
    159        aResult->variety =
    160            mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal;
    161        break;
    162      case 6:
    163        aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyResponse;
    164        break;
    165      case 7:
    166        aResult->variety =
    167            mozilla::net::nsHttpHeaderArray::eVarietyResponseOverride;
    168        break;
    169      default:
    170        return false;
    171    }
    172 
    173    return true;
    174  }
    175 };
    176 
    177 template <>
    178 struct ParamTraits<mozilla::net::nsHttpHeaderArray> {
    179  typedef mozilla::net::nsHttpHeaderArray paramType;
    180 
    181  static void Write(MessageWriter* aWriter, const paramType& aParam) {
    182    paramType& p = const_cast<paramType&>(aParam);
    183 
    184    WriteParam(aWriter, p.mHeaders);
    185  }
    186 
    187  static bool Read(MessageReader* aReader, paramType* aResult) {
    188    if (!ReadParam(aReader, &aResult->mHeaders)) return false;
    189 
    190    return true;
    191  }
    192 };
    193 
    194 template <>
    195 struct ParamTraits<mozilla::net::nsHttpRequestHead> {
    196  typedef mozilla::net::nsHttpRequestHead paramType;
    197 
    198  static void Write(MessageWriter* aWriter,
    199                    const paramType& aParam) MOZ_NO_THREAD_SAFETY_ANALYSIS {
    200    aParam.Enter();
    201    WriteParam(aWriter, aParam.mHeaders);
    202    WriteParam(aWriter, aParam.mMethod);
    203    WriteParam(aWriter, static_cast<uint32_t>(aParam.mVersion));
    204    WriteParam(aWriter, aParam.mRequestURI);
    205    WriteParam(aWriter, aParam.mPath);
    206    WriteParam(aWriter, aParam.mOrigin);
    207    WriteParam(aWriter, static_cast<uint8_t>(aParam.mParsedMethod));
    208    WriteParam(aWriter, aParam.mHTTPS);
    209    aParam.Exit();
    210  }
    211 
    212  static bool Read(MessageReader* aReader, paramType* aResult) {
    213    uint32_t version;
    214    uint8_t method;
    215    aResult->Enter();
    216    if (!ReadParam(aReader, &aResult->mHeaders) ||
    217        !ReadParam(aReader, &aResult->mMethod) ||
    218        !ReadParam(aReader, &version) ||
    219        !ReadParam(aReader, &aResult->mRequestURI) ||
    220        !ReadParam(aReader, &aResult->mPath) ||
    221        !ReadParam(aReader, &aResult->mOrigin) ||
    222        !ReadParam(aReader, &method) || !ReadParam(aReader, &aResult->mHTTPS)) {
    223      aResult->Exit();
    224      return false;
    225    }
    226 
    227    aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
    228    aResult->mParsedMethod =
    229        static_cast<mozilla::net::nsHttpRequestHead::ParsedMethodType>(method);
    230    aResult->Exit();
    231    return true;
    232  }
    233 };
    234 
    235 // Note that the code below MUST be synchronized with the code in
    236 // nsHttpRequestHead's copy constructor.
    237 template <>
    238 struct ParamTraits<mozilla::net::nsHttpResponseHead> {
    239  typedef mozilla::net::nsHttpResponseHead paramType;
    240 
    241  static void Write(MessageWriter* aWriter,
    242                    const paramType& aParam) MOZ_NO_THREAD_SAFETY_ANALYSIS {
    243    aParam.Enter();
    244    WriteParam(aWriter, aParam.mHeaders);
    245    WriteParam(aWriter, static_cast<uint32_t>(aParam.mVersion));
    246    WriteParam(aWriter, aParam.mStatus);
    247    WriteParam(aWriter, aParam.mStatusText);
    248    WriteParam(aWriter, aParam.mContentLength);
    249    WriteParam(aWriter, aParam.mContentType);
    250    WriteParam(aWriter, aParam.mContentCharset);
    251    WriteParam(aWriter, aParam.mHasCacheControl);
    252    WriteParam(aWriter, aParam.mCacheControlPublic);
    253    WriteParam(aWriter, aParam.mCacheControlPrivate);
    254    WriteParam(aWriter, aParam.mCacheControlNoStore);
    255    WriteParam(aWriter, aParam.mCacheControlNoCache);
    256    WriteParam(aWriter, aParam.mCacheControlImmutable);
    257    WriteParam(aWriter, aParam.mCacheControlStaleWhileRevalidateSet);
    258    WriteParam(aWriter, aParam.mCacheControlStaleWhileRevalidate);
    259    WriteParam(aWriter, aParam.mCacheControlMaxAgeSet);
    260    WriteParam(aWriter, aParam.mCacheControlMaxAge);
    261    WriteParam(aWriter, aParam.mPragmaNoCache);
    262    aParam.Exit();
    263  }
    264 
    265  static bool Read(MessageReader* aReader, paramType* aResult) {
    266    uint32_t version;
    267    aResult->Enter();
    268    if (!ReadParam(aReader, &aResult->mHeaders) ||
    269        !ReadParam(aReader, &version) ||
    270        !ReadParam(aReader, &aResult->mStatus) ||
    271        !ReadParam(aReader, &aResult->mStatusText) ||
    272        !ReadParam(aReader, &aResult->mContentLength) ||
    273        !ReadParam(aReader, &aResult->mContentType) ||
    274        !ReadParam(aReader, &aResult->mContentCharset) ||
    275        !ReadParam(aReader, &aResult->mHasCacheControl) ||
    276        !ReadParam(aReader, &aResult->mCacheControlPublic) ||
    277        !ReadParam(aReader, &aResult->mCacheControlPrivate) ||
    278        !ReadParam(aReader, &aResult->mCacheControlNoStore) ||
    279        !ReadParam(aReader, &aResult->mCacheControlNoCache) ||
    280        !ReadParam(aReader, &aResult->mCacheControlImmutable) ||
    281        !ReadParam(aReader, &aResult->mCacheControlStaleWhileRevalidateSet) ||
    282        !ReadParam(aReader, &aResult->mCacheControlStaleWhileRevalidate) ||
    283        !ReadParam(aReader, &aResult->mCacheControlMaxAgeSet) ||
    284        !ReadParam(aReader, &aResult->mCacheControlMaxAge) ||
    285        !ReadParam(aReader, &aResult->mPragmaNoCache)) {
    286      aResult->Exit();
    287      return false;
    288    }
    289 
    290    aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
    291    aResult->Exit();
    292    return true;
    293  }
    294 };
    295 
    296 }  // namespace IPC
    297 
    298 #endif  // mozilla_net_PHttpChannelParams_h