usr/src/cmd/cmd-inet/usr.lib/mdnsd/anonymous.c

   1 /* -*- Mode: C; tab-width: 4 -*-
   2  *
   3  * Copyright (c) 2012-2013 Apple Inc. All rights reserved.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include "mDNSEmbeddedAPI.h"
  19 #include "CryptoAlg.h"
  20 #include "anonymous.h"
  21 #include "DNSCommon.h"
  22
  23 // Define ANONYMOUS_DISABLED to remove all the anonymous functionality
  24 // and use the stub functions implemented later in this file.
  25
  26 #ifndef ANONYMOUS_DISABLED
  27
  28 #define ANON_NSEC3_ITERATIONS        1
  29
  30 struct AnonInfoResourceRecord_struct
  31 {
  32     ResourceRecord resrec;
  33     RData          rdatastorage;
  34 };
  35
  36 typedef struct AnonInfoResourceRecord_struct AnonInfoResourceRecord;
  37
  38 mDNSlocal mDNSBool InitializeNSEC3Record(ResourceRecord *rr, const mDNSu8 *AnonData, int len, mDNSu32 salt)
  39 {
  40     const mDNSu8 *ptr;
  41     rdataNSEC3 *nsec3 = (rdataNSEC3 *)rr->rdata->u.data;
  42     mDNSu8 *tmp, *nxt;
  43     unsigned short iter = ANON_NSEC3_ITERATIONS;
  44     int hlen;
  45     const mDNSu8 hashName[NSEC3_MAX_HASH_LEN];
  46
  47     // Construct the RDATA first and construct the owner name based on that.
  48     ptr = (const mDNSu8 *)&salt;
  49     debugf("InitializeNSEC3Record: %x%x%x%x, name %##s", ptr[0], ptr[1], ptr[2], ptr[3], rr->name->c);
  50
  51     // Set the RDATA
  52     nsec3->alg = SHA1_DIGEST_TYPE;
  53     nsec3->flags = 0;
  54     nsec3->iterations = swap16(iter);
  55     nsec3->saltLength = 4;
  56     tmp = (mDNSu8 *)&nsec3->salt;
  57     *tmp++ = ptr[0];
  58     *tmp++ = ptr[1];
  59     *tmp++ = ptr[2];
  60     *tmp++ = ptr[3];
  61
  62     // hashLength, nxt, bitmap
  63     *tmp++ = SHA1_HASH_LENGTH;    // hash length
  64     nxt = tmp;
  65     tmp += SHA1_HASH_LENGTH;
  66     *tmp++ = 0; // window number
  67     *tmp++ = NSEC_MCAST_WINDOW_SIZE; // window length
  68     mDNSPlatformMemZero(tmp, NSEC_MCAST_WINDOW_SIZE);
  69     tmp[kDNSType_PTR >> 3] |= 128 >> (kDNSType_PTR & 7);
  70
  71     // Hash the base service name + salt + AnonData
  72     if (!NSEC3HashName(rr->name, nsec3, AnonData, len, hashName, &hlen))
  73     {
  74         LogMsg("InitializeNSEC3Record: NSEC3HashName failed for ##s", rr->name->c);
  75         return mDNSfalse;
  76     }
  77     if (hlen != SHA1_HASH_LENGTH)
  78     {
  79         LogMsg("InitializeNSEC3Record: hlen wrong %d", hlen);
  80         return mDNSfalse;
  81     }
  82     mDNSPlatformMemCopy(nxt, hashName, hlen);
  83
  84     return mDNStrue;
  85 }
  86
  87 mDNSlocal ResourceRecord *ConstructNSEC3Record(const domainname *service, const mDNSu8 *AnonData, int len, mDNSu32 salt)
  88 {
  89     ResourceRecord *rr;
  90     int dlen;
  91     domainname *name;
  92
  93     // We are just allocating an RData which has StandardAuthRDSize
  94     if (StandardAuthRDSize < MCAST_NSEC3_RDLENGTH)
  95     {
  96         LogMsg("ConstructNSEC3Record: StandardAuthRDSize %d smaller than MCAST_NSEC3_RDLENGTH %d", StandardAuthRDSize, MCAST_NSEC3_RDLENGTH);
  97         return mDNSNULL;
  98     }
  99
 100     dlen = DomainNameLength(service);
 101
 102     // Allocate space for the name and RData.
 103     rr = mDNSPlatformMemAllocate(sizeof(ResourceRecord) + dlen + sizeof(RData));
 104     if (!rr)
 105         return mDNSNULL;
 106     name = (domainname *)((mDNSu8 *)rr + sizeof(ResourceRecord));
 107     rr->RecordType        = kDNSRecordTypePacketAuth;
 108     rr->InterfaceID       = mDNSInterface_Any;
 109     rr->name              = (const domainname *)name;
 110     rr->rrtype            = kDNSType_NSEC3;
 111     rr->rrclass           = kDNSClass_IN;
 112     rr->rroriginalttl     = kStandardTTL;
 113     rr->rDNSServer        = mDNSNULL;
 114     rr->rdlength          = MCAST_NSEC3_RDLENGTH;
 115     rr->rdestimate        = MCAST_NSEC3_RDLENGTH;
 116     rr->rdata             = (RData *)((mDNSu8 *)rr->name + dlen);
 117
 118     AssignDomainName(name, service);
 119     if (!InitializeNSEC3Record(rr, AnonData, len, salt))
 120     {
 121         mDNSPlatformMemFree(rr);
 122         return mDNSNULL;
 123     }
 124     return rr;
 125 }
 126
 127 mDNSlocal ResourceRecord *CopyNSEC3ResourceRecord(AnonymousInfo *si, const ResourceRecord *rr)
 128 {
 129     AnonInfoResourceRecord *anonRR;
 130     domainname *name;
 131     mDNSu32 neededLen;
 132     mDNSu32 extraLen;
 133
 134     if (rr->rdlength < MCAST_NSEC3_RDLENGTH)
 135     {
 136         LogMsg("CopyNSEC3ResourceRecord: rdlength %d smaller than MCAST_NSEC3_RDLENGTH %d", rr->rdlength, MCAST_NSEC3_RDLENGTH);
 137         return mDNSNULL;
 138     }
 139     // Allocate space for the name and the rdata along with the ResourceRecord
 140     neededLen = rr->rdlength + DomainNameLength(rr->name);
 141     extraLen = (neededLen > sizeof(RDataBody)) ? (neededLen - sizeof(RDataBody)) : 0;
 142     anonRR = (AnonInfoResourceRecord *)mDNSPlatformMemAllocate(sizeof(AnonInfoResourceRecord) + extraLen);
 143     if (!anonRR)
 144         return mDNSNULL;
 145
 146     anonRR->resrec = *rr;
 147
 148     anonRR->rdatastorage.MaxRDLength = rr->rdlength;
 149     mDNSPlatformMemCopy(anonRR->rdatastorage.u.data, rr->rdata->u.data, rr->rdlength);
 150
 151     name = (domainname *)(anonRR->rdatastorage.u.data + rr->rdlength);
 152     AssignDomainName(name, rr->name);
 153
 154     anonRR->resrec.name = name;
 155     anonRR->resrec.rdata = &anonRR->rdatastorage;
 156
 157     si->nsec3RR = (ResourceRecord *)anonRR;
 158
 159     return si->nsec3RR;
 160 }
 161
 162 // When a service is started or a browse is started with the Anonymous data, we allocate a new random
 163 // number and based on that allocate a new NSEC3 resource record whose hash is a function of random number (salt) and
 164 // the anonymous data.
 165 //
 166 // If we receive a packet with the NSEC3 option, we need to cache that along with the resource record so that we can
 167 // check against the question to see whether it answers them or not. In that case, we pass the "rr" that we received.
 168 mDNSexport  AnonymousInfo *AllocateAnonInfo(const domainname *service, const mDNSu8 *data, int len, const ResourceRecord *rr)
 169 {
 170     AnonymousInfo *ai;
 171     ai = (AnonymousInfo *)mDNSPlatformMemAllocate(sizeof(AnonymousInfo));
 172     if (!ai)
 173     {
 174         return mDNSNULL;
 175     }
 176     mDNSPlatformMemZero(ai, sizeof(AnonymousInfo));
 177     if (rr)
 178     {
 179         if (!CopyNSEC3ResourceRecord(ai, rr))
 180         {
 181             mDNSPlatformMemFree(ai);
 182             return mDNSNULL;
 183         }
 184         return ai;
 185     }
 186     ai->salt = mDNSRandom(0xFFFFFFFF);
 187     ai->AnonData = mDNSPlatformMemAllocate(len);
 188     if (!ai->AnonData)
 189     {
 190         mDNSPlatformMemFree(ai);
 191         return mDNSNULL;
 192     }
 193     ai->AnonDataLen = len;
 194     mDNSPlatformMemCopy(ai->AnonData, data, len);
 195     ai->nsec3RR = ConstructNSEC3Record(service, data, len, ai->salt);
 196     if (!ai->nsec3RR)
 197     {
 198         mDNSPlatformMemFree(ai);
 199         return mDNSNULL;
 200     }
 201     return ai;
 202 }
 203
 204 mDNSexport void FreeAnonInfo(AnonymousInfo *ai)
 205 {
 206     if (ai->nsec3RR)
 207         mDNSPlatformMemFree(ai->nsec3RR);
 208     if (ai->AnonData)
 209         mDNSPlatformMemFree(ai->AnonData);
 210     mDNSPlatformMemFree(ai);
 211 }
 212
 213 mDNSexport void ReInitAnonInfo(AnonymousInfo **AnonInfo, const domainname *name)
 214 {
 215     if (*AnonInfo)
 216     {
 217         AnonymousInfo *ai = *AnonInfo;
 218         *AnonInfo = AllocateAnonInfo(name, ai->AnonData, ai->AnonDataLen, mDNSNULL);
 219         if (!(*AnonInfo))
 220             *AnonInfo = ai;
 221         else
 222             FreeAnonInfo(ai);
 223     }
 224 }
 225
 226 // This function should be used only if you know that the question and
 227 // the resource record belongs to the same set. The main usage is
 228 // in ProcessQuery where we find the question to be part of the same
 229 // set as the resource record, but it needs the AnonData to be
 230 // initialized so that it can walk the cache records to see if they
 231 // answer the question.
 232 mDNSexport void SetAnonData(DNSQuestion *q, ResourceRecord *rr, mDNSBool ForQuestion)
 233 {
 234     if (!q->AnonInfo || !rr->AnonInfo)
 235     {
 236         LogMsg("SetAnonData: question %##s(%p), rr %##s(%p), NULL", q->qname.c, q->AnonInfo, rr->name->c, rr->AnonInfo);
 237         return;
 238     }
 239
 240     debugf("SetAnonData: question %##s(%p), rr %##s(%p)", q->qname.c, q->AnonInfo, rr->name->c, rr->AnonInfo);
 241     if (ForQuestion)
 242     {
 243         if (!q->AnonInfo->AnonData)
 244         {
 245             q->AnonInfo->AnonData = mDNSPlatformMemAllocate(rr->AnonInfo->AnonDataLen);
 246             if (!q->AnonInfo->AnonData)
 247                 return;
 248         }
 249         mDNSPlatformMemCopy(q->AnonInfo->AnonData, rr->AnonInfo->AnonData, rr->AnonInfo->AnonDataLen);
 250         q->AnonInfo->AnonDataLen = rr->AnonInfo->AnonDataLen;
 251     }
 252     else
 253     {
 254         if (!rr->AnonInfo->AnonData)
 255         {
 256             rr->AnonInfo->AnonData = mDNSPlatformMemAllocate(q->AnonInfo->AnonDataLen);
 257             if (!rr->AnonInfo->AnonData)
 258                 return;
 259         }
 260         mDNSPlatformMemCopy(rr->AnonInfo->AnonData, q->AnonInfo->AnonData, q->AnonInfo->AnonDataLen);
 261         rr->AnonInfo->AnonDataLen = q->AnonInfo->AnonDataLen;
 262     }
 263 }
 264
 265 // returns -1 if the caller should ignore the result
 266 // returns 1 if the record answers the question
 267 // returns 0 if the record does not answer the question
 268 mDNSexport int AnonInfoAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
 269 {
 270     mDNSexport mDNS mDNSStorage;
 271     ResourceRecord *nsec3RR;
 272     int i;
 273     AnonymousInfo *qai, *rai;
 274     mDNSu8 *AnonData;
 275     int AnonDataLen;
 276     rdataNSEC3 *nsec3;
 277     int hlen;
 278     const mDNSu8 hashName[NSEC3_MAX_HASH_LEN];
 279     int nxtLength;
 280     mDNSu8 *nxtName;
 281
 282     debugf("AnonInfoAnswersQuestion: question qname %##s", q->qname.c);
 283
 284     // Currently only PTR records can have anonymous information
 285     if (q->qtype != kDNSType_PTR)
 286     {
 287         return -1;
 288     }
 289
 290     // We allow anonymous questions to be answered by both normal services (without the
 291     // anonymous information) and anonymous services that are part of the same set. And
 292     // normal questions discover normal services and all anonymous services.
 293     //
 294     // The three cases have been enumerated clearly even though they all behave the
 295     // same way.
 296     if (!q->AnonInfo)
 297     {
 298         debugf("AnonInfoAnswersQuestion: not a anonymous type question");
 299         if (!rr->AnonInfo)
 300         {
 301             // case 1
 302             return -1;
 303         }
 304         else
 305         {
 306             // case 2
 307             debugf("AnonInfoAnswersQuestion: Question %##s not answered using anonymous record %##s", q->qname.c, rr->name->c);
 308             return -1;
 309         }
 310     }
 311     else
 312     {
 313         // case 3
 314         if (!rr->AnonInfo)
 315         {
 316             debugf("AnonInfoAnswersQuestion: not a anonymous type record");
 317             return -1;
 318         }
 319     }
 320
 321     // case 4: We have the anonymous information both in the question and the record. We need
 322     // two sets of information to validate.
 323     //
 324     // 1) Anonymous data that identifies the set/group
 325     // 2) NSEC3 record that contains the hash and the salt
 326     //
 327     // If the question is a remote one, it does not have the anonymous information to validate (just
 328     // the NSEC3 record) and hence the anonymous data should come from the local resource record. If the
 329     // question is local, it can come from either of them and if there is a mismatch between the
 330     // question and record, it won't validate.
 331
 332     qai = q->AnonInfo;
 333     rai = rr->AnonInfo;
 334
 335     if (qai->AnonData && rai->AnonData)
 336     {
 337         // Before a cache record is created, if there is a matching question i.e., part
 338         // of the same set, then when the cache is created we also set the anonymous
 339         // information. Otherwise, the cache record contains just the NSEC3 record and we
 340         // won't be here for that case.
 341         //
 342         // It is also possible that a local question is matched against the local AuthRecord
 343         // as that is also the case for which the AnonData would be non-NULL for both.
 344         // We match questions against AuthRecords (rather than the cache) for LocalOnly case and
 345         // to see whether a .local query should be suppressed or not. The latter never happens
 346         // because PTR queries are never suppressed.
 347
 348         // If they don't belong to the same anonymous set, then no point in validating.
 349         if ((qai->AnonDataLen != rai->AnonDataLen) ||
 350             mDNSPlatformMemCmp(qai->AnonData, rai->AnonData, qai->AnonDataLen) != 0)
 351         {
 352             debugf("AnonInfoAnswersQuestion: AnonData mis-match for record  %s question %##s ",
 353                 RRDisplayString(&mDNSStorage, rr), q->qname.c);
 354             return 0;
 355         }
 356         // AnonData matches i.e they belong to the same group and the same service.
 357         LogInfo("AnonInfoAnswersQuestion: Answering qname %##s, rname %##s, without validation", q->qname.c,
 358             rr->name->c);
 359         return 1;
 360     }
 361     else
 362     {
 363         debugf("AnonInfoAnswersQuestion: question %p, record %p", qai->AnonData, rai->AnonData);
 364     }
 365
 366     if (qai->AnonData)
 367     {
 368         // If there is AnonData, then this is a local question. The
 369         // NSEC3 RR comes from the resource record which could be part
 370         // of the cache or local auth record. The cache entry could
 371         // be from a remote host or created when we heard our own
 372         // announcements. In any case, we use that to see if it matches
 373         // the question.
 374         AnonData = qai->AnonData;
 375         AnonDataLen = qai->AnonDataLen;
 376         nsec3RR = rai->nsec3RR;
 377     }
 378     else
 379     {
 380         // Remote question or hearing our own question back
 381         AnonData = rai->AnonData;
 382         AnonDataLen = rai->AnonDataLen;
 383         nsec3RR = qai->nsec3RR;
 384     }
 385
 386     if (!AnonData || !nsec3RR)
 387     {
 388         // AnonData can be NULL for the cache entry and if we are hearing our own question back, AnonData is NULL for
 389         // that too and we can end up here for that case.
 390         debugf("AnonInfoAnswersQuestion: AnonData %p or nsec3RR %p, NULL for question %##s, record %s", AnonData, nsec3RR,
 391             q->qname.c, RRDisplayString(&mDNSStorage, rr));
 392         return 0;
 393     }
 394     debugf("AnonInfoAnswersQuestion: Validating question %##s, ResourceRecord %s", q->qname.c, RRDisplayString(&mDNSStorage, nsec3RR));
 395
 396
 397     nsec3 = (rdataNSEC3 *)nsec3RR->rdata->u.data;
 398
 399     if (!NSEC3HashName(nsec3RR->name, nsec3, AnonData, AnonDataLen, hashName, &hlen))
 400     {
 401         LogMsg("AnonInfoAnswersQuestion: NSEC3HashName failed for ##s", nsec3RR->name->c);
 402         return mDNSfalse;
 403     }
 404     if (hlen != SHA1_HASH_LENGTH)
 405     {
 406         LogMsg("AnonInfoAnswersQuestion: hlen wrong %d", hlen);
 407         return mDNSfalse;
 408     }
 409
 410     NSEC3Parse(nsec3RR, mDNSNULL, &nxtLength, &nxtName, mDNSNULL, mDNSNULL);
 411
 412     if (hlen != nxtLength)
 413     {
 414         LogMsg("AnonInfoAnswersQuestion: ERROR!! hlen %d not same as nxtLength %d", hlen, nxtLength);
 415         return mDNSfalse;
 416     }
 417
 418     for (i = 0; i < nxtLength; i++)
 419     {
 420         if (nxtName[i] != hashName[i])
 421         {
 422             debugf("AnonInfoAnswersQuestion: mismatch output %x, digest %x, i %d", nxtName[i+1], hashName[i], i);
 423             return 0;
 424         }
 425     }
 426     LogInfo("AnonInfoAnswersQuestion: ResourceRecord %s matched question %##s (%s)", RRDisplayString(&mDNSStorage, nsec3RR), q->qname.c, DNSTypeName(q->qtype));
 427     return 1;
 428 }
 429
 430 // Find a matching NSEC3 record for the name. We parse the questions and the records in the packet in order.
 431 // Similarly we also parse the NSEC3 records in order and this mapping to the questions and records
 432 // respectively.
 433 mDNSlocal CacheRecord *FindMatchingNSEC3ForName(mDNS *const m, CacheRecord **nsec3, const domainname *name)
 434 {
 435     CacheRecord *cr;
 436     CacheRecord **prev = nsec3;
 437
 438     (void) m;
 439
 440     for (cr = *nsec3; cr; cr = cr->next)
 441     {
 442         if (SameDomainName(cr->resrec.name, name))
 443         {
 444             debugf("FindMatchingNSEC3ForName: NSEC3 record %s matched %##s", CRDisplayString(m, cr), name->c);
 445             *prev = cr->next;
 446             cr->next = mDNSNULL;
 447             return cr;
 448         }
 449         prev = &cr->next;
 450     }
 451     return mDNSNULL;
 452 }
 453
 454 mDNSexport void InitializeAnonInfoForQuestion(mDNS *const m, CacheRecord **McastNSEC3Records, DNSQuestion *q)
 455 {
 456     CacheRecord *nsec3CR;
 457
 458     if (q->qtype != kDNSType_PTR)
 459         return;
 460
 461     nsec3CR = FindMatchingNSEC3ForName(m, McastNSEC3Records, &q->qname);
 462     if (nsec3CR)
 463     {
 464         q->AnonInfo = AllocateAnonInfo(mDNSNULL, mDNSNULL, 0, &nsec3CR->resrec);
 465         if (q->AnonInfo)
 466         {
 467             debugf("InitializeAnonInfoForQuestion: Found a matching NSEC3 record %s, for %##s (%s)",
 468                 RRDisplayString(m, q->AnonInfo->nsec3RR), q->qname.c, DNSTypeName(q->qtype));
 469         }
 470         ReleaseCacheRecord(m, nsec3CR);
 471     }
 472 }
 473
 474 mDNSexport void InitializeAnonInfoForCR(mDNS *const m, CacheRecord **McastNSEC3Records, CacheRecord *cr)
 475 {
 476     CacheRecord *nsec3CR;
 477
 478     if (!(*McastNSEC3Records))
 479         return;
 480
 481     // If already initialized or not a PTR type, we don't have to do anything
 482     if (cr->resrec.AnonInfo || cr->resrec.rrtype != kDNSType_PTR)
 483         return;
 484
 485     nsec3CR = FindMatchingNSEC3ForName(m, McastNSEC3Records, cr->resrec.name);
 486     if (nsec3CR)
 487     {
 488         cr->resrec.AnonInfo = AllocateAnonInfo(mDNSNULL, mDNSNULL, 0, &nsec3CR->resrec);
 489         if (cr->resrec.AnonInfo)
 490         {
 491             debugf("InitializeAnonInfoForCR: Found a matching NSEC3 record %s, for %##s (%s)",
 492                 RRDisplayString(m, cr->resrec.AnonInfo->nsec3RR), cr->resrec.name->c,
 493                 DNSTypeName(cr->resrec.rrtype));
 494         }
 495         ReleaseCacheRecord(m, nsec3CR);
 496     }
 497 }
 498
 499 mDNSexport mDNSBool IdenticalAnonInfo(AnonymousInfo *a1, AnonymousInfo *a2)
 500 {
 501     // if a1 is NULL and a2 is not NULL AND vice-versa
 502     // return false as there is a change.
 503     if ((a1 != mDNSNULL) != (a2 != mDNSNULL))
 504         return mDNSfalse;
 505
 506     // Both could be NULL or non-NULL
 507     if (a1 && a2)
 508     {
 509         // The caller already verified that the owner name is the same.
 510         // Check whether the RData is same.
 511         if (!IdenticalSameNameRecord(a1->nsec3RR, a2->nsec3RR))
 512         {
 513             debugf("IdenticalAnonInfo: nsec3RR mismatch");
 514             return mDNSfalse;
 515         }
 516     }
 517     return mDNStrue;
 518 }
 519
 520 mDNSexport void CopyAnonInfoForCR(mDNS *const m, CacheRecord *crto, CacheRecord *crfrom)
 521 {
 522     AnonymousInfo *aifrom = crfrom->resrec.AnonInfo;
 523     AnonymousInfo *aito = crto->resrec.AnonInfo;
 524
 525     (void) m;
 526
 527     if (!aifrom)
 528         return;
 529
 530     if (aito)
 531     {
 532         crto->resrec.AnonInfo = aifrom;
 533         FreeAnonInfo(aito);
 534         crfrom->resrec.AnonInfo = mDNSNULL;
 535     }
 536     else
 537     {
 538         FreeAnonInfo(aifrom);
 539         crfrom->resrec.AnonInfo = mDNSNULL;
 540     }
 541 }
 542
 543 #else // !ANONYMOUS_DISABLED
 544
 545 mDNSexport void ReInitAnonInfo(AnonymousInfo **si, const domainname *name)
 546 {
 547         (void)si;
 548         (void)name;
 549 }
 550
 551 mDNSexport AnonymousInfo * AllocateAnonInfo(const domainname *service, const mDNSu8 *AnonData, int len, const ResourceRecord *rr)
 552 {
 553         (void)service;
 554         (void)AnonData;
 555         (void)len;
 556         (void)rr;
 557
 558         return mDNSNULL;
 559 }
 560
 561 mDNSexport void FreeAnonInfo(AnonymousInfo *ai)
 562 {
 563         (void)ai;
 564 }
 565
 566 mDNSexport void SetAnonData(DNSQuestion *q, ResourceRecord *rr, mDNSBool ForQuestion)
 567 {
 568         (void)q;
 569         (void)rr;
 570         (void)ForQuestion;
 571 }
 572
 573 mDNSexport int AnonInfoAnswersQuestion(const ResourceRecord *const rr, const DNSQuestion *const q)
 574 {
 575         (void)rr;
 576         (void)q;
 577
 578         return mDNSfalse;
 579 }
 580
 581 mDNSexport void InitializeAnonInfoForQuestion(mDNS *const m, CacheRecord **McastNSEC3Records, DNSQuestion *q)
 582 {
 583         (void)m;
 584         (void)McastNSEC3Records;
 585         (void)q;
 586 }
 587
 588 mDNSexport void InitializeAnonInfoForCR(mDNS *const m, CacheRecord **McastNSEC3Records, CacheRecord *cr)
 589 {
 590         (void)m;
 591         (void)McastNSEC3Records;
 592         (void)cr;
 593 }
 594
 595 mDNSexport void CopyAnonInfoForCR(mDNS *const m, CacheRecord *crto, CacheRecord *crfrom)
 596 {
 597         (void)m;
 598         (void)crto;
 599         (void)crfrom;
 600 }
 601
 602 mDNSexport mDNSBool IdenticalAnonInfo(AnonymousInfo *a1, AnonymousInfo *a2)
 603 {
 604         (void)a1;
 605         (void)a2;
 606
 607         return mDNStrue;
 608 }
 609
 610 #endif // !ANONYMOUS_DISABLED