Lines Matching refs:ptr
238 mDNSu8 *ptr = (mDNSu8 *)&x;
239 return (mDNSu32)((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]);
244 mDNSu8 *ptr = (mDNSu8 *)&x;
245 return (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
370 char *ptr = buffer;
546 for (ptr = buffer; *ptr; ptr++) if (*ptr < ' ') *ptr = '.';
750 const mDNSu8 *ptr;
751 for (ptr = d->c; *ptr; ptr = ptr + ptr[0] + 1) count++;
772 mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
774 const mDNSu8 *const lim2 = ptr + 1 + MAX_DOMAIN_LABEL;
776 mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
778 while (*cstr && ptr < lim) *ptr++ = (mDNSu8)*cstr++; // Copy the data
779 *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
780 *ptr++ = 0; // Put the null root label on the end
782 else return(ptr); // Success: return new value of ptr
795 mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
797 while (*cstr && ptr < lim) // While more characters, and space to put them...
799 mDNSu8 *lengthbyte = ptr++; // Record where the length is going to go
801 while (*cstr && *cstr != '.' && ptr < lim) // While we have characters in the label...
816 *ptr++ = c; // Write the character
819 if (ptr - lengthbyte - 1 > MAX_DOMAIN_LABEL) // If illegal label, abort
821 *lengthbyte = (mDNSu8)(ptr - lengthbyte - 1); // Fill in the length byte
824 *ptr++ = 0; // Put the null root label on the end
826 else return(ptr); // Success: return new value of ptr
837 mDNSu8 *ptr = name->c + DomainNameLength(name) - 1;
842 // Check that ptr + length byte + data bytes + final zero does not exceed our limit
843 if (ptr + 1 + label->c[0] + 1 > name->c + MAX_DOMAIN_NAME) return(mDNSNULL);
845 for (i=0; i<=label->c[0]; i++) *ptr++ = label->c[i]; // Copy the label data
846 *ptr++ = 0; // Put the null root label on the end
847 return(ptr);
852 mDNSu8 * ptr = name->c + DomainNameLength(name) - 1; // Find end of current name
858 if (ptr + 1 + src[0] > lim) return(mDNSNULL);
859 for (i=0; i<=src[0]; i++) *ptr++ = src[i];
860 *ptr = 0; // Put the null root label on the end
863 return(ptr);
874 mDNSu8 * ptr = label->c + 1; // Where we're putting it
876 while (*cstr && ptr < limit) *ptr++ = (mDNSu8)*cstr++; // Copy the label
877 label->c[0] = (mDNSu8)(ptr - label->c - 1); // Set the length byte
894 mDNSexport char *ConvertDomainLabelToCString_withescape(const domainlabel *const label, char *ptr, char esc)
906 *ptr++ = esc; // Output escape character
909 *ptr++ = esc;
910 *ptr++ = (char) ('0' + (c / 100) );
911 *ptr++ = (char) ('0' + (c / 10) % 10);
915 *ptr++ = (char)c; // Copy the character
917 *ptr = 0; // Null-terminate the string
918 return(ptr); // and return
922 mDNSexport char *ConvertDomainNameToCString_withescape(const domainname *const name, char *ptr, char esc)
927 if (*src == 0) *ptr++ = '.'; // Special case: For root, just write a dot
932 ptr = ConvertDomainLabelToCString_withescape((const domainlabel *)src, ptr, esc);
933 if (!ptr) return(mDNSNULL);
935 *ptr++ = '.'; // Write the dot after the label
938 *ptr++ = 0; // Null-terminate the string
939 return(ptr); // and return
951 mDNSu8 * ptr = &hostlabel->c[1];
959 if (ptr < lim)
961 if (mDNSValidHostChar(*src, (ptr > &hostlabel->c[1]), (src < end-1))) *ptr++ = *src;
962 else if (ptr > &hostlabel->c[1] && ptr[-1] != '-') *ptr++ = '-';
966 while (ptr > &hostlabel->c[1] && ptr[-1] == '-') ptr--; // Truncate trailing '-' marks
967 hostlabel->c[0] = (mDNSu8)(ptr - &hostlabel->c[1]);
1494 const mDNSu8 *ptr = rdb->data;
1536 ptr += dlen;
1546 sum += (((mDNSu32)(ptr[i])) << 8) | ptr[i+1];
1551 sum += ((mDNSu32)(ptr[i])) << 8;
2062 const mDNSu8 *ptr = rd->u.txt.c;
2064 while (ptr < end) ptr += 1 + ptr[0];
2065 return (ptr == end);
2148 // ptr points to where we want to put the name
2152 mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name)
2158 const mDNSu8 *const searchlimit = ptr;
2160 if (!ptr) { LogMsg("putDomainNameAsLabels %##s ptr is null", name->c); return(mDNSNULL); }
2164 if (ptr >= limit) return(mDNSNULL);
2188 if (ptr+2 > limit) return(mDNSNULL); // If we don't have two bytes of space left, give up
2189 *ptr++ = (mDNSu8)(0xC0 | (offset >> 8));
2190 *ptr++ = (mDNSu8)( offset & 0xFF);
2191 return(ptr);
2198 if (ptr + 1 + len >= limit) return(mDNSNULL);
2199 *ptr++ = len;
2200 for (i=0; i<len; i++) *ptr++ = *np++;
2205 *ptr++ = 0; // Put the final root label
2206 return(ptr);
2209 mDNSlocal mDNSu8 *putVal16(mDNSu8 *ptr, mDNSu16 val)
2211 ptr[0] = (mDNSu8)((val >> 8 ) & 0xFF);
2212 ptr[1] = (mDNSu8)((val ) & 0xFF);
2213 return ptr + sizeof(mDNSOpaque16);
2216 mDNSlocal mDNSu8 *putVal32(mDNSu8 *ptr, mDNSu32 val)
2218 ptr[0] = (mDNSu8)((val >> 24) & 0xFF);
2219 ptr[1] = (mDNSu8)((val >> 16) & 0xFF);
2220 ptr[2] = (mDNSu8)((val >> 8) & 0xFF);
2221 ptr[3] = (mDNSu8)((val ) & 0xFF);
2222 return ptr + sizeof(mDNSu32);
2228 mDNSexport mDNSu8 *putRData(const DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const ResourceRecord *const rr)
2235 if (ptr + 4 > limit) return(mDNSNULL);
2236 *ptr++ = rdb->ipv4.b[0];
2237 *ptr++ = rdb->ipv4.b[1];
2238 *ptr++ = rdb->ipv4.b[2];
2239 *ptr++ = rdb->ipv4.b[3];
2240 return(ptr);
2245 case kDNSType_DNAME: return(putDomainNameAsLabels(msg, ptr, limit, &rdb->name));
2247 case kDNSType_SOA: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.mname);
2248 if (!ptr) return(mDNSNULL);
2249 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->soa.rname);
2250 if (!ptr || ptr + 20 > limit) return(mDNSNULL);
2251 ptr = putVal32(ptr, rdb->soa.serial);
2252 ptr = putVal32(ptr, rdb->soa.refresh);
2253 ptr = putVal32(ptr, rdb->soa.retry);
2254 ptr = putVal32(ptr, rdb->soa.expire);
2255 ptr = putVal32(ptr, rdb->soa.min);
2256 return(ptr);
2265 case kDNSType_DHCID: if (ptr + rr->rdlength > limit) return(mDNSNULL);
2266 mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
2267 return(ptr + rr->rdlength);
2272 case kDNSType_KX: if (ptr + 3 > limit) return(mDNSNULL);
2273 ptr = putVal16(ptr, rdb->mx.preference);
2274 return(putDomainNameAsLabels(msg, ptr, limit, &rdb->mx.exchange));
2276 case kDNSType_RP: ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.mbox);
2277 if (!ptr) return(mDNSNULL);
2278 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->rp.txt);
2279 return(ptr);
2281 case kDNSType_PX: if (ptr + 5 > limit) return(mDNSNULL);
2282 ptr = putVal16(ptr, rdb->px.preference);
2283 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.map822);
2284 if (!ptr) return(mDNSNULL);
2285 ptr = putDomainNameAsLabels(msg, ptr, limit, &rdb->px.mapx400);
2286 return(ptr);
2290 if (ptr + sizeof(rdb->ipv6) > limit) return(mDNSNULL);
2291 mDNSPlatformMemCopy(ptr, &rdb->ipv6, sizeof(rdb->ipv6));
2292 return(ptr + sizeof(rdb->ipv6));
2294 case kDNSType_SRV: if (ptr + 7 > limit) return(mDNSNULL);
2295 *ptr++ = (mDNSu8)(rdb->srv.priority >> 8);
2296 *ptr++ = (mDNSu8)(rdb->srv.priority & 0xFF);
2297 *ptr++ = (mDNSu8)(rdb->srv.weight >> 8);
2298 *ptr++ = (mDNSu8)(rdb->srv.weight & 0xFF);
2299 *ptr++ = rdb->srv.port.b[0];
2300 *ptr++ = rdb->srv.port.b[1];
2301 return(putDomainNameAsLabels(msg, ptr, limit, &rdb->srv.target));
2309 if (ptr + len > limit)
2317 ptr = putVal16(ptr, opt->opt);
2318 ptr = putVal16(ptr, (mDNSu16)space - 4);
2322 ptr = putVal16(ptr, opt->u.llq.vers);
2323 ptr = putVal16(ptr, opt->u.llq.llqOp);
2324 ptr = putVal16(ptr, opt->u.llq.err);
2325 mDNSPlatformMemCopy(ptr, opt->u.llq.id.b, 8); // 8-byte id
2326 ptr += 8;
2327 ptr = putVal32(ptr, opt->u.llq.llqlease);
2330 ptr = putVal32(ptr, opt->u.updatelease);
2333 *ptr++ = opt->u.owner.vers;
2334 *ptr++ = opt->u.owner.seq;
2335 mDNSPlatformMemCopy(ptr, opt->u.owner.HMAC.b, 6); // 6-byte Host identifier
2336 ptr += 6;
2339 mDNSPlatformMemCopy(ptr, opt->u.owner.IMAC.b, 6); // 6-byte interface MAC
2340 ptr += 6;
2343 mDNSPlatformMemCopy(ptr, opt->u.owner.password.b, space - DNSOpt_OwnerData_ID_Wake_Space);
2344 ptr += space - DNSOpt_OwnerData_ID_Wake_Space;
2349 *ptr++ = opt->u.tracer.platf;
2350 ptr = putVal32(ptr, opt->u.tracer.mDNSv);
2354 return ptr;
2375 mDNSu8 *save = ptr;
2395 ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
2396 if (!ptr) { LogInfo("putRData: Can't put name, Length %d, record %##s", limit - save, rr->name->c); return(mDNSNULL); }
2399 if (ptr + 2 + i > limit) { LogInfo("putRData: Can't put window, Length %d, i %d, record %##s", limit - ptr, i, rr->name->c); return(mDNSNULL); }
2400 *ptr++ = 0;
2401 *ptr++ = (mDNSu8)i;
2402 for (j=0; j<i; j++) *ptr++ = nsec[j];
2404 return ptr;
2427 if (ptr + rr->rdlength > limit) { LogMsg("putRData: NSEC rdlength beyond limit %##s (%s), ptr %p, rdlength %d, limit %p", rr->name->c, DNSTypeName(rr->rrtype), ptr, rr->rdlength, limit); return(mDNSNULL);}
2430 mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
2431 return(ptr + rr->rdlength);
2436 if (ptr + rr->rdlength > limit) return(mDNSNULL);
2437 mDNSPlatformMemCopy(ptr, rdb->data, rr->rdlength);
2438 return(ptr + rr->rdlength);
2444 mDNSexport mDNSu8 *PutResourceRecordTTLWithLimit(DNSMessage *const msg, mDNSu8 *ptr, mDNSu16 *count, ResourceRecord *rr, mDNSu32 ttl, const mDNSu8 *limit)
2454 return(ptr);
2457 if (!ptr)
2459 LogMsg("PutResourceRecordTTLWithLimit ptr is null %##s (%s)", rr->name->c, DNSTypeName(rr->rrtype));
2463 ptr = putDomainNameAsLabels(msg, ptr, limit, rr->name);
2465 if (!ptr || ptr + 10 >= limit)
2467 LogInfo("PutResourceRecordTTLWithLimit: can't put name, out of space %##s (%s), ptr %p, limit %p", rr->name->c,
2468 DNSTypeName(rr->rrtype), ptr, limit);
2471 ptr[0] = (mDNSu8)(rr->rrtype >> 8);
2472 ptr[1] = (mDNSu8)(rr->rrtype & 0xFF);
2473 ptr[2] = (mDNSu8)(rr->rrclass >> 8);
2474 ptr[3] = (mDNSu8)(rr->rrclass & 0xFF);
2475 ptr[4] = (mDNSu8)((ttl >> 24) & 0xFF);
2476 ptr[5] = (mDNSu8)((ttl >> 16) & 0xFF);
2477 ptr[6] = (mDNSu8)((ttl >> 8) & 0xFF);
2478 ptr[7] = (mDNSu8)( ttl & 0xFF);
2479 // ptr[8] and ptr[9] filled in *after* we find out how much space the rdata takes
2481 endofrdata = putRData(rdatacompressionbase, ptr+10, limit, rr);
2484 LogInfo("PutResourceRecordTTLWithLimit: Ran out of space in PutResourceRecord for %##s (%s), ptr %p, limit %p", rr->name->c,
2485 DNSTypeName(rr->rrtype), ptr+10, limit);
2491 actualLength = (mDNSu16)(endofrdata - ptr - 10);
2492 ptr[8] = (mDNSu8)(actualLength >> 8);
2493 ptr[9] = (mDNSu8)(actualLength & 0xFF);
2500 mDNSlocal mDNSu8 *putEmptyResourceRecord(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, mDNSu16 *count, const AuthRecord *rr)
2502 ptr = putDomainNameAsLabels(msg, ptr, limit, rr->resrec.name);
2503 if (!ptr || ptr + 10 > limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
2504 ptr[0] = (mDNSu8)(rr->resrec.rrtype >> 8); // Put type
2505 ptr[1] = (mDNSu8)(rr->resrec.rrtype & 0xFF);
2506 ptr[2] = (mDNSu8)(rr->resrec.rrclass >> 8); // Put class
2507 ptr[3] = (mDNSu8)(rr->resrec.rrclass & 0xFF);
2508 ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // TTL is zero
2509 ptr[8] = ptr[9] = 0; // RDATA length is zero
2511 return(ptr + 10);
2514 mDNSexport mDNSu8 *putQuestion(DNSMessage *const msg, mDNSu8 *ptr, const mDNSu8 *const limit, const domainname *const name, mDNSu16 rrtype, mDNSu16 rrclass)
2516 ptr = putDomainNameAsLabels(msg, ptr, limit, name);
2517 if (!ptr || ptr+4 >= limit) return(mDNSNULL); // If we're out-of-space, return mDNSNULL
2518 ptr[0] = (mDNSu8)(rrtype >> 8);
2519 ptr[1] = (mDNSu8)(rrtype & 0xFF);
2520 ptr[2] = (mDNSu8)(rrclass >> 8);
2521 ptr[3] = (mDNSu8)(rrclass & 0xFF);
2523 return(ptr+4);
2527 mDNSexport mDNSu8 *putZone(DNSMessage *const msg, mDNSu8 *ptr, mDNSu8 *limit, const domainname *zone, mDNSOpaque16 zoneClass)
2529 ptr = putDomainNameAsLabels(msg, ptr, limit, zone);
2530 if (!ptr || ptr + 4 > limit) return mDNSNULL; // If we're out-of-space, return NULL
2531 *ptr++ = (mDNSu8)(kDNSType_SOA >> 8);
2532 *ptr++ = (mDNSu8)(kDNSType_SOA & 0xFF);
2533 *ptr++ = zoneClass.b[0];
2534 *ptr++ = zoneClass.b[1];
2536 return ptr;
2540 mDNSexport mDNSu8 *putPrereqNameNotInUse(const domainname *const name, DNSMessage *const msg, mDNSu8 *const ptr, mDNSu8 *const end)
2547 return putEmptyResourceRecord(msg, ptr, end, &msg->h.mDNS_numPrereqs, &prereq);
2551 mDNSexport mDNSu8 *putDeletionRecord(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr)
2556 ptr = PutResourceRecordTTLJumbo(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0);
2558 return ptr;
2562 mDNSexport mDNSu8 *putDeletionRecordWithLimit(DNSMessage *msg, mDNSu8 *ptr, ResourceRecord *rr, mDNSu8 *limit)
2567 ptr = PutResourceRecordTTLWithLimit(msg, ptr, &msg->h.mDNS_numUpdates, rr, 0, limit);
2569 return ptr;
2572 mDNSexport mDNSu8 *putDeleteRRSetWithLimit(DNSMessage *msg, mDNSu8 *ptr, const domainname *name, mDNSu16 rrtype, mDNSu8 *limit)
2576 ptr = putDomainNameAsLabels(msg, ptr, limit, name);
2577 if (!ptr || ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL
2578 ptr[0] = (mDNSu8)(rrtype >> 8);
2579 ptr[1] = (mDNSu8)(rrtype & 0xFF);
2580 ptr[2] = (mDNSu8)(class >> 8);
2581 ptr[3] = (mDNSu8)(class & 0xFF);
2582 ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
2583 ptr[8] = ptr[9] = 0; // zero rdlength/rdata
2586 return ptr + 10;
2590 mDNSexport mDNSu8 *putDeleteAllRRSets(DNSMessage *msg, mDNSu8 *ptr, const domainname *name)
2596 ptr = putDomainNameAsLabels(msg, ptr, limit, name);
2597 if (!ptr || ptr + 10 >= limit) return mDNSNULL; // If we're out-of-space, return mDNSNULL
2598 ptr[0] = (mDNSu8)(rrtype >> 8);
2599 ptr[1] = (mDNSu8)(rrtype & 0xFF);
2600 ptr[2] = (mDNSu8)(class >> 8);
2601 ptr[3] = (mDNSu8)(class & 0xFF);
2602 ptr[4] = ptr[5] = ptr[6] = ptr[7] = 0; // zero ttl
2603 ptr[8] = ptr[9] = 0; // zero rdlength/rdata
2606 return ptr + 10;
2717 mDNSexport const mDNSu8 *skipDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end)
2721 if (ptr < (mDNSu8*)msg || ptr >= end)
2722 { debugf("skipDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
2726 const mDNSu8 len = *ptr++; // Read length of this label
2727 if (len == 0) return(ptr); // If length is zero, that means this name is complete
2730 case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
2734 ptr += len;
2740 case 0xC0: return(ptr+1);
2746 mDNSexport const mDNSu8 *getDomainName(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end,
2753 if (ptr < (mDNSu8*)msg || ptr >= end)
2754 { debugf("getDomainName: Illegal ptr not within packet boundaries"); return(mDNSNULL); }
2760 const mDNSu8 len = *ptr++; // Read length of this label
2767 case 0x00: if (ptr + len >= end) // Remember: expect at least one more byte for the root label
2772 for (i=0; i<len; i++) *np++ = *ptr++;
2781 case 0xC0: offset = (mDNSu16)((((mDNSu16)(len & 0x3F)) << 8) | *ptr++);
2782 if (!nextbyte) nextbyte = ptr; // Record where we got to before we started following pointers
2783 ptr = (mDNSu8 *)msg + offset;
2784 if (ptr < (mDNSu8*)msg || ptr >= end)
2786 if (*ptr & 0xC0)
2793 else return(ptr);
2796 mDNSexport const mDNSu8 *skipResourceRecord(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
2800 ptr = skipDomainName(msg, ptr, end);
2801 if (!ptr) { debugf("skipResourceRecord: Malformed RR name"); return(mDNSNULL); }
2803 if (ptr + 10 > end) { debugf("skipResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
2804 pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
2805 ptr += 10;
2806 if (ptr + pktrdlength > end) { debugf("skipResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
2808 return(ptr + pktrdlength);
2845 // pointed to by "ptr". Some resource records like SOA, SRV are converted to host order and also expanded
2848 // This function can also be called with "NULL" msg to parse a single resource record pointed to by ptr.
2851 mDNSexport mDNSBool SetRData(const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *end,
2862 rdb->ipv4.b[0] = ptr[0];
2863 rdb->ipv4.b[1] = ptr[1];
2864 rdb->ipv4.b[2] = ptr[2];
2865 rdb->ipv4.b[3] = ptr[3];
2880 ptr = getDomainName(msg, ptr, end, &rdb->name);
2884 AssignDomainName(&rdb->name, (domainname *)ptr);
2885 ptr += DomainNameLength(&rdb->name);
2887 if (ptr != end)
2897 ptr = getDomainName(msg, ptr, end, &rdb->soa.mname);
2901 AssignDomainName(&rdb->soa.mname, (domainname *)ptr);
2902 ptr += DomainNameLength(&rdb->soa.mname);
2904 if (!ptr)
2911 ptr = getDomainName(msg, ptr, end, &rdb->soa.rname);
2915 AssignDomainName(&rdb->soa.rname, (domainname *)ptr);
2916 ptr += DomainNameLength(&rdb->soa.rname);
2918 if (!ptr)
2923 if (ptr + 0x14 != end)
2928 rdb->soa.serial = (mDNSs32) ((mDNSs32)ptr[0x00] << 24 | (mDNSs32)ptr[0x01] << 16 | (mDNSs32)ptr[0x02] << 8 | ptr[0x03]);
2929 rdb->soa.refresh = (mDNSu32) ((mDNSu32)ptr[0x04] << 24 | (mDNSu32)ptr[0x05] << 16 | (mDNSu32)ptr[0x06] << 8 | ptr[0x07]);
2930 rdb->soa.retry = (mDNSu32) ((mDNSu32)ptr[0x08] << 24 | (mDNSu32)ptr[0x09] << 16 | (mDNSu32)ptr[0x0A] << 8 | ptr[0x0B]);
2931 rdb->soa.expire = (mDNSu32) ((mDNSu32)ptr[0x0C] << 24 | (mDNSu32)ptr[0x0D] << 16 | (mDNSu32)ptr[0x0E] << 8 | ptr[0x0F]);
2932 rdb->soa.min = (mDNSu32) ((mDNSu32)ptr[0x10] << 24 | (mDNSu32)ptr[0x11] << 16 | (mDNSu32)ptr[0x12] << 8 | ptr[0x13]);
2943 mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
2953 rdb->mx.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
2954 ptr += 2;
2957 ptr = getDomainName(msg, ptr, end, &rdb->mx.exchange);
2961 AssignDomainName(&rdb->mx.exchange, (domainname *)ptr);
2962 ptr += DomainNameLength(&rdb->mx.exchange);
2964 if (ptr != end)
2976 ptr = getDomainName(msg, ptr, end, &rdb->rp.mbox);
2980 AssignDomainName(&rdb->rp.mbox, (domainname *)ptr);
2981 ptr += DomainNameLength(&rdb->rp.mbox);
2983 if (!ptr)
2990 ptr = getDomainName(msg, ptr, end, &rdb->rp.txt);
2994 AssignDomainName(&rdb->rp.txt, (domainname *)ptr);
2995 ptr += DomainNameLength(&rdb->rp.txt);
2997 if (ptr != end)
3008 rdb->px.preference = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
3009 ptr += 2;
3012 ptr = getDomainName(msg, ptr, end, &rdb->px.map822);
3016 AssignDomainName(&rdb->px.map822, (domainname *)ptr);
3017 ptr += DomainNameLength(&rdb->px.map822);
3019 if (!ptr)
3026 ptr = getDomainName(msg, ptr, end, &rdb->px.mapx400);
3030 AssignDomainName(&rdb->px.mapx400, (domainname *)ptr);
3031 ptr += DomainNameLength(&rdb->px.mapx400);
3033 if (ptr != end)
3043 mDNSPlatformMemCopy(&rdb->ipv6, ptr, sizeof(rdb->ipv6));
3050 rdb->srv.priority = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
3051 rdb->srv.weight = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
3052 rdb->srv.port.b[0] = ptr[4];
3053 rdb->srv.port.b[1] = ptr[5];
3054 ptr += 6;
3057 ptr = getDomainName(msg, ptr, end, &rdb->srv.target);
3061 AssignDomainName(&rdb->srv.target, (domainname *)ptr);
3062 ptr += DomainNameLength(&rdb->srv.target);
3064 if (ptr != end)
3075 const mDNSu8 *orig = ptr;
3086 ptr += 4;
3089 len = *ptr + 1;
3090 ptr += len;
3091 if (ptr >= end)
3098 len = *ptr + 1;
3099 ptr += len;
3100 if (ptr >= end)
3107 len = *ptr + 1;
3108 ptr += len;
3109 if (ptr >= end)
3115 savelen = ptr - orig;
3122 ptr = getDomainName(msg, ptr, end, &name);
3126 AssignDomainName(&name, (domainname *)ptr);
3127 ptr += DomainNameLength(&name);
3129 if (ptr != end)
3151 while (ptr < end && (mDNSu8 *)(opt+1) < &dataend[MaximumRDSize])
3154 if (ptr + 4 > end) { LogInfo("SetRData: OPT RDATA ptr + 4 > end"); goto fail; }
3155 opt->opt = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
3156 opt->optlen = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
3157 ptr += 4;
3158 if (ptr + opt->optlen > end) { LogInfo("SetRData: ptr + opt->optlen > end"); goto fail; }
3164 opt->u.llq.vers = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]);
3165 opt->u.llq.llqOp = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]);
3166 opt->u.llq.err = (mDNSu16)((mDNSu16)ptr[4] << 8 | ptr[5]);
3167 mDNSPlatformMemCopy(opt->u.llq.id.b, ptr+6, 8);
3168 opt->u.llq.llqlease = (mDNSu32) ((mDNSu32)ptr[14] << 24 | (mDNSu32)ptr[15] << 16 | (mDNSu32)ptr[16] << 8 | ptr[17]);
3177 opt->u.updatelease = (mDNSu32) ((mDNSu32)ptr[0] << 24 | (mDNSu32)ptr[1] << 16 | (mDNSu32)ptr[2] << 8 | ptr[3]);
3186 opt->u.owner.vers = ptr[0];
3187 opt->u.owner.seq = ptr[1];
3188 mDNSPlatformMemCopy(opt->u.owner.HMAC.b, ptr+2, 6); // 6-byte MAC address
3189 mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+2, 6); // 6-byte MAC address
3193 mDNSPlatformMemCopy(opt->u.owner.IMAC.b, ptr+8, 6); // 6-byte MAC address
3197 mDNSPlatformMemCopy(opt->u.owner.password.b, ptr+14, opt->optlen - (DNSOpt_OwnerData_ID_Wake_Space-4));
3205 opt->u.tracer.platf = ptr[0];
3206 opt->u.tracer.mDNSv = (mDNSu32) ((mDNSu32)ptr[1] << 24 | (mDNSu32)ptr[2] << 16 | (mDNSu32)ptr[3] << 8 | ptr[4]);
3217 ptr += currentopt->optlen;
3220 if (ptr != end) { LogInfo("SetRData: Malformed OptRdata"); goto fail; }
3228 const mDNSu8 *orig = ptr;
3233 ptr = getDomainName(msg, ptr, end, &name);
3237 AssignDomainName(&name, (domainname *)ptr);
3238 ptr += DomainNameLength(&name);
3240 if (!ptr)
3252 len -= (ptr - orig);
3254 bmap = ptr;
3255 ptr = SanityCheckBitMap(bmap, end, len);
3256 if (!ptr)
3258 if (ptr != end)
3281 rdataNSEC3 *nsec3 = (rdataNSEC3 *)ptr;
3321 bitmaplen = rdlength - (int)(p - ptr);
3326 mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3339 ptr = getDomainName(msg, ptr, end, &name);
3343 AssignDomainName(&name, (domainname *)ptr);
3344 ptr += DomainNameLength(&name);
3346 if (!ptr)
3352 rlen = end - ptr;
3355 mDNSPlatformMemCopy(rdb->data + dlen, ptr, rlen);
3360 const mDNSu8 *sig = ptr + RRSIG_FIXED_SIZE;
3395 mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3406 mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3417 mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3429 mDNSPlatformMemCopy(rdb->data, ptr, rdlength);
3437 mDNSexport const mDNSu8 *GetLargeResourceRecord(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr,
3473 ptr = getDomainName(msg, ptr, end, &largecr->namestorage); // Will bail out correctly if ptr is NULL
3474 if (!ptr) { debugf("GetLargeResourceRecord: Malformed RR name"); return(mDNSNULL); }
3477 if (ptr + 10 > end) { debugf("GetLargeResourceRecord: Malformed RR -- no type/class/ttl/len!"); return(mDNSNULL); }
3479 rr->resrec.rrtype = (mDNSu16) ((mDNSu16)ptr[0] << 8 | ptr[1]);
3480 rr->resrec.rrclass = (mDNSu16)(((mDNSu16)ptr[2] << 8 | ptr[3]) & kDNSClass_Mask);
3481 rr->resrec.rroriginalttl = (mDNSu32) ((mDNSu32)ptr[4] << 24 | (mDNSu32)ptr[5] << 16 | (mDNSu32)ptr[6] << 8 | ptr[7]);
3486 pktrdlength = (mDNSu16)((mDNSu16)ptr[8] << 8 | ptr[9]);
3491 if (ptr[2] & (kDNSClass_UniqueRRSet >> 8) || (!InterfaceID && !(msg->h.flags.b[0] & kDNSFlag0_TC)))
3493 ptr += 10;
3494 if (ptr + pktrdlength > end) { debugf("GetLargeResourceRecord: RDATA exceeds end of packet"); return(mDNSNULL); }
3495 end = ptr + pktrdlength; // Adjust end to indicate the end of the rdata for this resource record
3516 else if (!SetRData(msg, ptr, end, largecr, pktrdlength))
3535 mDNSexport const mDNSu8 *skipQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end)
3537 ptr = skipDomainName(msg, ptr, end);
3538 if (!ptr) { debugf("skipQuestion: Malformed domain name in DNS question section"); return(mDNSNULL); }
3539 if (ptr+4 > end) { debugf("skipQuestion: Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
3540 return(ptr+4);
3543 mDNSexport const mDNSu8 *getQuestion(const DNSMessage *msg, const mDNSu8 *ptr, const mDNSu8 *end, const mDNSInterfaceID InterfaceID,
3549 ptr = getDomainName(msg, ptr, end, &question->qname);
3550 if (!ptr) { debugf("Malformed domain name in DNS question section"); return(mDNSNULL); }
3551 if (ptr+4 > end) { debugf("Malformed DNS question section -- no query type and class!"); return(mDNSNULL); }
3554 question->qtype = (mDNSu16)((mDNSu16)ptr[0] << 8 | ptr[1]); // Get type
3555 question->qclass = (mDNSu16)((mDNSu16)ptr[2] << 8 | ptr[3]); // and class
3556 return(ptr+4);
3562 const mDNSu8 *ptr = msg->data;
3563 for (i = 0; i < msg->h.numQuestions && ptr; i++) ptr = skipQuestion(msg, ptr, end);
3564 return(ptr);
3570 const mDNSu8 *ptr = LocateAnswers(msg, end);
3571 for (i = 0; i < msg->h.numAnswers && ptr; i++) ptr = skipResourceRecord(msg, ptr, end);
3572 return(ptr);
3578 const mDNSu8 *ptr = LocateAuthorities(msg, end);
3579 for (i = 0; i < msg->h.numAuthorities; i++) ptr = skipResourceRecord(msg, ptr, end);
3580 return (ptr);
3586 const mDNSu8 *ptr = LocateAdditionals(msg, end);
3592 for (i = 0; ptr && i < msg->h.numAdditionals; i++)
3594 if (ptr + DNSOpt_Header_Space + minsize <= end && // Make sure we have 11+minsize bytes of data
3595 ptr[0] == 0 && // Name must be root label
3596 ptr[1] == (kDNSType_OPT >> 8 ) && // rrtype OPT
3597 ptr[2] == (kDNSType_OPT & 0xFF) &&
3598 ((mDNSu16)ptr[9] << 8 | (mDNSu16)ptr[10]) >= (mDNSu16)minsize)
3599 return(ptr);
3601 ptr = skipResourceRecord(msg, ptr, end);
3612 const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LLQData_Space);
3613 if (ptr)
3615 ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
3616 if (ptr && m->rec.r.resrec.RecordType != kDNSRecordTypePacketNegative) return(&m->rec.r.resrec.rdata->u.opt[0]);
3626 const mDNSu8 *ptr = LocateOptRR(msg, end, DNSOpt_LeaseData_Space);
3627 if (ptr) ptr = GetLargeResourceRecord(m, msg, ptr, end, 0, kDNSRecordTypePacketAdd, &m->rec);
3628 if (ptr && m->rec.r.resrec.rdlength >= DNSOpt_LeaseData_Space && m->rec.r.resrec.rdata->u.opt[0].opt == kDNSOpt_Lease)
3634 mDNSlocal const mDNSu8 *DumpRecords(mDNS *const m, const DNSMessage *const msg, const mDNSu8 *ptr, const mDNSu8 *const end, int count, char *label)
3638 for (i = 0; i < count && ptr; i++)
3644 ptr = GetLargeResourceRecord(m, msg, ptr, end, mDNSInterface_Any, kDNSRecordTypePacketAns, &largecr);
3645 if (ptr) LogMsg("%2d TTL%8d %s", i, largecr.r.resrec.rroriginalttl, CRDisplayString(m, &largecr.r));
3647 if (!ptr) LogMsg("DumpRecords: ERROR: Premature end of packet data");
3648 return(ptr);
3678 const mDNSu8 *ptr = msg->data;
3709 for (i = 0; i < msg->h.numQuestions && ptr; i++)
3711 ptr = getQuestion(msg, ptr, end, mDNSInterface_Any, &q);
3712 if (ptr) LogMsg("%2d %##s %s", i, q.qname.c, DNSTypeName(q.qtype));
3714 ptr = DumpRecords(m, msg, ptr, end, msg->h.numAnswers, IsUpdate ? "Prerequisites" : "Answers");
3715 ptr = DumpRecords(m, msg, ptr, end, msg->h.numAuthorities, IsUpdate ? "Updates" : "Authorities");
3716 ptr = DumpRecords(m, msg, ptr, end, msg->h.numAdditionals, "Additionals");
4329 va_list ptr;
4330 va_start(ptr,fmt);
4331 length = mDNS_vsnprintf(sbuffer, buflen, fmt, ptr);
4332 va_end(ptr);