netwerk/dns/DNSByTypeRecord.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef DNSByTypeRecord_h__
   6 #define DNSByTypeRecord_h__
   7
   8 #include "mozilla/net/HTTPSSVC.h"
   9 #include "mozilla/ipc/IPDLParamTraits.h"
  10 #include "ipc/IPCMessageUtils.h"
  11 #include "mozilla/net/NeckoMessageUtils.h"
  12
  13 namespace mozilla {
  14 namespace net {
  15
  16 // The types of nsIDNSByTypeRecord: Nothing, TXT, HTTPSSVC
  17 using TypeRecordEmpty = Nothing;
  18 using TypeRecordTxt = CopyableTArray<nsCString>;
  19 using TypeRecordHTTPSSVC = CopyableTArray<SVCB>;
  20
  21 // This variant reflects the multiple types of data a nsIDNSByTypeRecord
  22 // can hold.
  23 using TypeRecordResultType =
  24     Variant<TypeRecordEmpty, TypeRecordTxt, TypeRecordHTTPSSVC>;
  25
  26 // TypeRecordResultType is a variant, but since it doesn't have a default
  27 // constructor it's not a type we can pass directly over IPC.
  28 struct IPCTypeRecord {
  29   bool operator==(const IPCTypeRecord& aOther) const {
  30     return mData == aOther.mData;
  31   }
  32   explicit IPCTypeRecord() : mData(Nothing{}) {}
  33   TypeRecordResultType mData;
  34   uint32_t mTTL = 0;
  35 };
  36
  37 }  // namespace net
  38 }  // namespace mozilla
  39
  40 namespace mozilla {
  41 namespace ipc {
  42
  43 template <>
  44 struct IPDLParamTraits<mozilla::net::IPCTypeRecord> {
  45   typedef mozilla::net::IPCTypeRecord paramType;
  46   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
  47                     const paramType& aParam) {
  48     WriteIPDLParam(aWriter, aActor, aParam.mData);
  49     WriteIPDLParam(aWriter, aActor, aParam.mTTL);
  50   }
  51
  52   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
  53                    paramType* aResult) {
  54     if (!ReadIPDLParam(aReader, aActor, &aResult->mData)) {
  55       return false;
  56     }
  57     if (!ReadIPDLParam(aReader, aActor, &aResult->mTTL)) {
  58       return false;
  59     }
  60     return true;
  61   }
  62 };
  63
  64 template <>
  65 struct IPDLParamTraits<mozilla::Nothing> {
  66   typedef mozilla::Nothing paramType;
  67   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
  68                     const paramType& aParam) {
  69     bool isSome = false;
  70     WriteIPDLParam(aWriter, aActor, isSome);
  71   }
  72
  73   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
  74                    paramType* aResult) {
  75     bool isSome;
  76     if (!ReadIPDLParam(aReader, aActor, &isSome)) {
  77       return false;
  78     }
  79     *aResult = Nothing();
  80     return true;
  81   }
  82 };
  83
  84 template <>
  85 struct IPDLParamTraits<mozilla::net::SVCB> {
  86   typedef mozilla::net::SVCB paramType;
  87   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
  88                     const paramType& aParam) {
  89     WriteIPDLParam(aWriter, aActor, aParam.mSvcFieldPriority);
  90     WriteIPDLParam(aWriter, aActor, aParam.mSvcDomainName);
  91     WriteIPDLParam(aWriter, aActor, aParam.mEchConfig);
  92     WriteIPDLParam(aWriter, aActor, aParam.mODoHConfig);
  93     WriteIPDLParam(aWriter, aActor, aParam.mHasIPHints);
  94     WriteIPDLParam(aWriter, aActor, aParam.mHasEchConfig);
  95     WriteIPDLParam(aWriter, aActor, aParam.mSvcFieldValue);
  96   }
  97
  98   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
  99                    paramType* aResult) {
 100     if (!ReadIPDLParam(aReader, aActor, &aResult->mSvcFieldPriority)) {
 101       return false;
 102     }
 103     if (!ReadIPDLParam(aReader, aActor, &aResult->mSvcDomainName)) {
 104       return false;
 105     }
 106     if (!ReadIPDLParam(aReader, aActor, &aResult->mEchConfig)) {
 107       return false;
 108     }
 109     if (!ReadIPDLParam(aReader, aActor, &aResult->mODoHConfig)) {
 110       return false;
 111     }
 112     if (!ReadIPDLParam(aReader, aActor, &aResult->mHasIPHints)) {
 113       return false;
 114     }
 115     if (!ReadIPDLParam(aReader, aActor, &aResult->mHasEchConfig)) {
 116       return false;
 117     }
 118     if (!ReadIPDLParam(aReader, aActor, &aResult->mSvcFieldValue)) {
 119       return false;
 120     }
 121     return true;
 122   }
 123 };
 124
 125 template <>
 126 struct IPDLParamTraits<mozilla::net::SvcParamAlpn> {
 127   typedef mozilla::net::SvcParamAlpn paramType;
 128   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 129                     const paramType& aParam) {
 130     WriteIPDLParam(aWriter, aActor, aParam.mValue);
 131   }
 132
 133   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 134                    paramType* aResult) {
 135     if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
 136       return false;
 137     }
 138     return true;
 139   }
 140 };
 141
 142 template <>
 143 struct IPDLParamTraits<mozilla::net::SvcParamNoDefaultAlpn> {
 144   typedef mozilla::net::SvcParamNoDefaultAlpn paramType;
 145   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 146                     const paramType& aParam) {}
 147
 148   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 149                    paramType* aResult) {
 150     return true;
 151   }
 152 };
 153
 154 template <>
 155 struct IPDLParamTraits<mozilla::net::SvcParamPort> {
 156   typedef mozilla::net::SvcParamPort paramType;
 157   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 158                     const paramType& aParam) {
 159     WriteIPDLParam(aWriter, aActor, aParam.mValue);
 160   }
 161
 162   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 163                    paramType* aResult) {
 164     if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
 165       return false;
 166     }
 167     return true;
 168   }
 169 };
 170
 171 template <>
 172 struct IPDLParamTraits<mozilla::net::SvcParamIpv4Hint> {
 173   typedef mozilla::net::SvcParamIpv4Hint paramType;
 174   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 175                     const paramType& aParam) {
 176     WriteIPDLParam(aWriter, aActor, aParam.mValue);
 177   }
 178
 179   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 180                    paramType* aResult) {
 181     if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
 182       return false;
 183     }
 184     return true;
 185   }
 186 };
 187
 188 template <>
 189 struct IPDLParamTraits<mozilla::net::SvcParamEchConfig> {
 190   typedef mozilla::net::SvcParamEchConfig paramType;
 191   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 192                     const paramType& aParam) {
 193     WriteIPDLParam(aWriter, aActor, aParam.mValue);
 194   }
 195
 196   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 197                    paramType* aResult) {
 198     if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
 199       return false;
 200     }
 201     return true;
 202   }
 203 };
 204
 205 template <>
 206 struct IPDLParamTraits<mozilla::net::SvcParamIpv6Hint> {
 207   typedef mozilla::net::SvcParamIpv6Hint paramType;
 208   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 209                     const paramType& aParam) {
 210     WriteIPDLParam(aWriter, aActor, aParam.mValue);
 211   }
 212
 213   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 214                    paramType* aResult) {
 215     if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
 216       return false;
 217     }
 218     return true;
 219   }
 220 };
 221
 222 template <>
 223 struct IPDLParamTraits<mozilla::net::SvcParamODoHConfig> {
 224   typedef mozilla::net::SvcParamODoHConfig paramType;
 225   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 226                     const paramType& aParam) {
 227     WriteIPDLParam(aWriter, aActor, aParam.mValue);
 228   }
 229
 230   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 231                    paramType* aResult) {
 232     if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
 233       return false;
 234     }
 235     return true;
 236   }
 237 };
 238
 239 template <>
 240 struct IPDLParamTraits<mozilla::net::SvcFieldValue> {
 241   typedef mozilla::net::SvcFieldValue paramType;
 242   static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
 243                     const paramType& aParam) {
 244     WriteIPDLParam(aWriter, aActor, aParam.mValue);
 245   }
 246
 247   static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
 248                    paramType* aResult) {
 249     if (!ReadIPDLParam(aReader, aActor, &aResult->mValue)) {
 250       return false;
 251     }
 252     return true;
 253   }
 254 };
 255
 256 }  // namespace ipc
 257 }  // namespace mozilla
 258
 259 #endif  // DNSByTypeRecord_h__