_ZN7DNSName19throwSafeRangeErrorERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEPKcm: 61| 808|{ 62| 808| std::string dots; 63| 808| if (length > s_maxDNSNameLength) { ------------------ | Branch (63:7): [True: 0, False: 808] ------------------ 64| 0| length = s_maxDNSNameLength; 65| 0| dots = "..."; 66| 0| } 67| 808| std::string label; 68| 808| DNSName::appendEscapedLabel(label, buf, length); 69| 808| throw std::range_error(msg + label + dots); 70| 808|} _ZN7DNSNameC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 73| 16.9k|{ 74| 16.9k| const char* p = sw.data(); 75| 16.9k| size_t length = sw.length(); 76| | 77| 16.9k| if(length == 0 || (length == 1 && p[0]=='.')) { ------------------ | Branch (77:6): [True: 0, False: 16.9k] | Branch (77:22): [True: 9.16k, False: 7.77k] | Branch (77:37): [True: 9.16k, False: 2] ------------------ 78| 9.16k| d_storage.assign(1, '\0'); 79| 9.16k| } else { 80| 7.77k| if(!std::memchr(p, '\\', length)) { ------------------ | Branch (80:8): [True: 7.77k, False: 0] ------------------ 81| 7.77k| unsigned char lenpos=0; 82| 7.77k| unsigned char labellen=0; 83| 7.77k| const char* const pbegin=p, *pend=p+length; 84| | 85| 7.77k| d_storage.reserve(length+1); 86| 27.7k| for(auto iter = pbegin; iter != pend; ) { ------------------ | Branch (86:31): [True: 20.0k, False: 7.77k] ------------------ 87| 20.0k| lenpos = d_storage.size(); 88| 20.0k| if(*iter=='.') ------------------ | Branch (88:12): [True: 808, False: 19.2k] ------------------ 89| 808| throwSafeRangeError("Found . in wrong position in DNSName: ", p, length); 90| 20.0k| d_storage.append(1, '\0'); 91| 20.0k| labellen=0; 92| 20.0k| auto begiter=iter; 93| 129k| for(; iter != pend && *iter!='.'; ++iter) { ------------------ | Branch (93:15): [True: 128k, False: 834] | Branch (93:31): [True: 109k, False: 19.1k] ------------------ 94| 109k| labellen++; 95| 109k| } 96| 20.0k| d_storage.append(begiter,iter); 97| 20.0k| if(iter != pend) ------------------ | Branch (97:12): [True: 19.1k, False: 834] ------------------ 98| 19.1k| ++iter; 99| 20.0k| if(labellen > s_maxDNSLabelLength) { ------------------ | Branch (99:12): [True: 0, False: 20.0k] ------------------ 100| 0| throwSafeRangeError("label too long to append: ", p, length); 101| 0| } 102| | 103| 20.0k| if(iter-pbegin > static_cast(s_maxDNSNameLength - 1)) // reserve two bytes, one for length and one for the root label ------------------ | Branch (103:12): [True: 0, False: 20.0k] ------------------ 104| 0| throwSafeRangeError("name too long to append: ", p, length); 105| | 106| 20.0k| d_storage[lenpos]=labellen; 107| 20.0k| } 108| 7.77k| d_storage.append(1, '\0'); 109| 7.77k| } 110| 0| else { 111| 0| d_storage=segmentDNSNameRaw(p, length); 112| 0| if(d_storage.size() > s_maxDNSNameLength) { ------------------ | Branch (112:10): [True: 0, False: 0] ------------------ 113| 0| throwSafeRangeError("name too long: ", p, length); 114| 0| } 115| 0| } 116| 7.77k| } 117| 16.9k|} _ZN7DNSNameC2EPKcmmbPtS2_Pjt: 120| 20.8k|{ 121| 20.8k| if (offset >= len) ------------------ | Branch (121:7): [True: 151, False: 20.7k] ------------------ 122| 151| throw std::range_error("Trying to read past the end of the buffer ("+std::to_string(offset)+ " >= "+std::to_string(len)+")"); 123| | 124| 20.7k| if(!uncompress) { ------------------ | Branch (124:6): [True: 0, False: 20.7k] ------------------ 125| 0| if(const void * fnd=memchr(pos+offset, 0, len-offset)) { ------------------ | Branch (125:21): [True: 0, False: 0] ------------------ 126| 0| d_storage.reserve(2+(const char*)fnd-(pos+offset)); 127| 0| } 128| 0| } 129| | 130| 20.7k| packetParser(pos, len, offset, uncompress, qtype, qclass, consumed, 0, minOffset); 131| 20.7k|} _ZN7DNSName23parsePacketUncompressedERKN4pdns5views16UnsignedCharViewEmb: 145| 25.0k|{ 146| 25.0k| const size_t initialPos = pos; 147| 25.0k| auto existingSize = d_storage.size(); 148| 25.0k| const size_t neededSizeForFinalLabel = /* final empty label length */ (existingSize == 0 ? 1U : 0U); ------------------ | Branch (148:74): [True: 22.3k, False: 2.73k] ------------------ 149| 25.0k| size_t totalLength = 0; 150| 25.0k| unsigned char labellen = 0; 151| | 152| 45.1k| do { 153| 45.1k| labellen = view.at(pos); 154| 45.1k| ++pos; 155| | 156| 45.1k| if (labellen == 0) { ------------------ | Branch (156:9): [True: 20.4k, False: 24.6k] ------------------ 157| 20.4k| --pos; 158| 20.4k| break; 159| 20.4k| } 160| | 161| 24.6k| if (labellen >= 0xc0) { ------------------ | Branch (161:9): [True: 4.40k, False: 20.2k] ------------------ 162| 4.40k| if (!uncompress) { ------------------ | Branch (162:11): [True: 0, False: 4.40k] ------------------ 163| 0| throw std::range_error("Found compressed label, instructed not to follow"); 164| 0| } 165| 4.40k| --pos; 166| 4.40k| break; 167| 4.40k| } 168| | 169| 20.2k| if ((labellen & 0xc0) != 0) { ------------------ | Branch (169:9): [True: 63, False: 20.1k] ------------------ 170| 63| throw std::range_error("Found an invalid label length in qname (only one of the first two bits is set)"); 171| 63| } 172| 20.1k| checkLabelLength(labellen); 173| | 174| | // reserve one byte for the label length, plus one byte for the final empty label if we were empty before 175| 20.1k| if ((existingSize + totalLength + labellen + 1U + neededSizeForFinalLabel) > s_maxDNSNameLength) { ------------------ | Branch (175:9): [True: 5, False: 20.1k] ------------------ 176| 5| throw std::range_error("name too long to append"); 177| 5| } 178| 20.1k| if (pos + labellen >= view.size()) { ------------------ | Branch (178:9): [True: 80, False: 20.0k] ------------------ 179| 80| throw std::range_error("Found an invalid label length in qname"); 180| 80| } 181| 20.0k| pos += labellen; 182| 20.0k| totalLength += 1U + labellen; 183| 20.0k| } 184| 25.0k| while (pos < view.size()); ------------------ | Branch (184:10): [True: 20.0k, False: 0] ------------------ 185| | 186| 24.8k| if (totalLength != 0) { ------------------ | Branch (186:7): [True: 10.1k, False: 14.7k] ------------------ 187| 10.1k| if (existingSize > 0) { ------------------ | Branch (187:9): [True: 2.70k, False: 7.49k] ------------------ 188| | // remove the last label count, we are about to override it */ 189| 2.70k| --existingSize; 190| 2.70k| } 191| 10.1k| if ((existingSize + totalLength + 1U) > s_maxDNSNameLength) { ------------------ | Branch (191:9): [True: 0, False: 10.1k] ------------------ 192| 0| throw std::range_error("name too long to append"); 193| 0| } 194| 10.1k| d_storage.reserve(existingSize + totalLength + 1); 195| 10.1k| d_storage.resize(existingSize + totalLength); 196| 10.1k| memcpy(&d_storage.at(existingSize), &view.at(initialPos), totalLength); 197| 10.1k| d_storage.append(1, static_cast(0)); 198| 10.1k| } 199| 24.8k| return pos; 200| 24.8k|} _ZN7DNSName12packetParserEPKcmmbPtS2_Pjit: 204| 25.0k|{ 205| 25.0k| if (offset >= len) { ------------------ | Branch (205:7): [True: 0, False: 25.0k] ------------------ 206| 0| throw std::range_error("Trying to read past the end of the buffer ("+std::to_string(offset)+ " >= "+std::to_string(len)+")"); 207| 0| } 208| | 209| 25.0k| if (offset < static_cast(minOffset)) { ------------------ | Branch (209:7): [True: 0, False: 25.0k] ------------------ 210| 0| throw std::range_error("Trying to read before the beginning of the buffer ("+std::to_string(offset)+ " < "+std::to_string(minOffset)+")"); 211| 0| } 212| 25.0k| unsigned char labellen{0}; 213| | 214| 25.0k| pdns::views::UnsignedCharView view(qpos, len); 215| 25.0k| auto pos = parsePacketUncompressed(view, offset, uncompress); 216| | 217| 25.0k| labellen = view.at(pos); 218| 25.0k| pos++; 219| 25.0k| if (labellen != 0 && pos < view.size()) { ------------------ | Branch (219:7): [True: 4.40k, False: 20.6k] | Branch (219:24): [True: 4.37k, False: 31] ------------------ 220| 4.37k| if (labellen < 0xc0) { ------------------ | Branch (220:9): [True: 0, False: 4.37k] ------------------ 221| 0| throw std::range_error("Invalid label byte during decompression ("+std::to_string(labellen)+")"); 222| 0| } 223| | 224| 4.37k| if (!uncompress) { ------------------ | Branch (224:9): [True: 0, False: 4.37k] ------------------ 225| 0| throw std::range_error("Found compressed label, instructed not to follow"); 226| 0| } 227| | 228| 4.37k| labellen &= (~0xc0); 229| 4.37k| size_t newpos = (labellen << 8) + view.at(pos); 230| | 231| 4.37k| if (newpos >= offset) { ------------------ | Branch (231:9): [True: 57, False: 4.32k] ------------------ 232| 57| throw std::range_error("Found a forward reference during label decompression"); 233| 57| } 234| | 235| 4.32k| if (newpos < minOffset) { ------------------ | Branch (235:9): [True: 7, False: 4.31k] ------------------ 236| 7| throw std::range_error("Invalid label position during decompression ("+std::to_string(newpos)+ " < "+std::to_string(minOffset)+")"); 237| 7| } 238| | 239| 4.31k| if (++depth > 100) { ------------------ | Branch (239:9): [True: 0, False: 4.31k] ------------------ 240| 0| throw std::range_error("Abort label decompression after 100 redirects"); 241| 0| } 242| | 243| 4.31k| packetParser(qpos, len, newpos, true, nullptr, nullptr, nullptr, depth, minOffset); 244| | 245| 4.31k| pos++; 246| 4.31k| } 247| | 248| 24.9k| if (d_storage.empty()) { ------------------ | Branch (248:7): [True: 13.0k, False: 11.9k] ------------------ 249| 13.0k| d_storage.append(1, static_cast(0)); // we just parsed the root 250| 13.0k| } 251| | 252| 24.9k| if (consumed != nullptr) { ------------------ | Branch (252:7): [True: 20.5k, False: 4.46k] ------------------ 253| 20.5k| *consumed = pos - offset; 254| 20.5k| } 255| | 256| 24.9k| if (qtype != nullptr) { ------------------ | Branch (256:7): [True: 0, False: 24.9k] ------------------ 257| 0| if (pos + 2 > view.size()) { ------------------ | Branch (257:9): [True: 0, False: 0] ------------------ 258| 0| throw std::range_error("Trying to read qtype past the end of the buffer ("+std::to_string(pos + 2)+ " > "+std::to_string(len)+")"); 259| 0| } 260| 0| *qtype = view.at(pos)*256 + view.at(pos+1); 261| 0| } 262| | 263| 24.9k| pos += 2; 264| 24.9k| if (qclass != nullptr) { ------------------ | Branch (264:7): [True: 0, False: 24.9k] ------------------ 265| 0| if (pos + 2 > view.size()) { ------------------ | Branch (265:9): [True: 0, False: 0] ------------------ 266| 0| throw std::range_error("Trying to read qclass past the end of the buffer ("+std::to_string(pos + 2)+ " > "+std::to_string(len)+")"); 267| 0| } 268| 0| *qclass = view.at(pos)*256 + view.at(pos+1); 269| 0| } 270| 24.9k|} _ZNK7DNSName11toLogStringEv: 312| 23|{ 313| 23| if (empty()) { ------------------ | Branch (313:7): [True: 0, False: 23] ------------------ 314| 0| return "(empty)"; 315| 0| } 316| | 317| 23| return toStringRootDot(); 318| 23|} _ZNK7DNSName10wirelengthEv: 341| 4.87k|size_t DNSName::wirelength() const { 342| 4.87k| return d_storage.length(); 343| 4.87k|} _ZN7DNSName18appendEscapedLabelERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEPKcm: 697| 808|{ 698| 808| size_t pos = 0; 699| | 700| 11.4k| while (pos < len) { ------------------ | Branch (700:10): [True: 10.6k, False: 808] ------------------ 701| 10.6k| auto p = static_cast(orig[pos]); 702| 10.6k| if (p=='.') { ------------------ | Branch (702:9): [True: 1.61k, False: 9.04k] ------------------ 703| 1.61k| appendTo+="\\."; 704| 1.61k| } 705| 9.04k| else if (p=='\\') { ------------------ | Branch (705:14): [True: 0, False: 9.04k] ------------------ 706| 0| appendTo+="\\\\"; 707| 0| } 708| 9.04k| else if (p > 0x20 && p < 0x7f) { ------------------ | Branch (708:14): [True: 9.04k, False: 0] | Branch (708:26): [True: 9.04k, False: 0] ------------------ 709| 9.04k| appendTo.append(1, static_cast(p)); 710| 9.04k| } 711| 0| else { 712| 0| char buf[] = "000"; 713| 0| auto got = snprintf(buf, sizeof(buf), "%03" PRIu8, p); 714| 0| if (got < 0 || static_cast(got) >= sizeof(buf)) { ------------------ | Branch (714:11): [True: 0, False: 0] | Branch (714:22): [True: 0, False: 0] ------------------ 715| 0| throw std::runtime_error("Error, snprintf returned " + std::to_string(got) + " while escaping label " + std::string(orig, len)); 716| 0| } 717| 0| appendTo.append(1, '\\'); 718| 0| appendTo += buf; 719| 0| } 720| 10.6k| ++pos; 721| 10.6k| } 722| 808|} _ZN8ZoneName20findVariantSeparatorENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 913| 2|{ 914| 2| std::string_view::size_type pos{0}; 915| | 916| | // Try to be as fast as possible in the non-variant case and exit 917| | // quickly if we don't find two dots in a row. 918| 2| while ((pos = name.find('.', pos)) != std::string_view::npos) { ------------------ | Branch (918:10): [True: 2, False: 0] ------------------ 919| 2| ++pos; 920| 2| if (pos >= name.length()) { // trailing single dot ------------------ | Branch (920:9): [True: 2, False: 0] ------------------ 921| 2| return std::string_view::npos; 922| 2| } 923| 0| if (name.at(pos) == '.') { ------------------ | Branch (923:9): [True: 0, False: 0] ------------------ 924| | // We have found two dots in a row, but the first dot might have been 925| | // escaped. So we now need to count how many \ characters we can find a 926| | // row before it; if their number is odd, the first dot is escaped and 927| | // we need to keep searching. 928| 0| size_t slashes{0}; 929| 0| while (pos >= 2 + slashes && name.at(pos - 2 - slashes) == '\\') { ------------------ | Branch (929:14): [True: 0, False: 0] | Branch (929:36): [True: 0, False: 0] ------------------ 930| 0| ++slashes; 931| 0| } 932| 0| if ((slashes % 2) == 0) { ------------------ | Branch (932:11): [True: 0, False: 0] ------------------ 933| 0| break; 934| 0| } 935| 0| } 936| 0| } 937| 0| return pos; 938| 2|} _ZN8ZoneNameC2ENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 941| 2|{ 942| 2| if (auto sep = findVariantSeparator(name); sep != std::string_view::npos) { ------------------ | Branch (942:46): [True: 0, False: 2] ------------------ 943| 0| setVariant(name.substr(sep + 1)); // ignore leading dot in variant name 944| 0| name = name.substr(0, sep); // keep trailing dot in zone name 945| 0| } 946| 2| d_name = DNSName(name); 947| 2|} dnsname.cc:_ZL16checkLabelLengthh: 134| 20.1k|{ 135| 20.1k| if (length == 0) { ------------------ | Branch (135:7): [True: 0, False: 20.1k] ------------------ 136| 0| throw std::range_error("no such thing as an empty label to append"); 137| 0| } 138| 20.1k| if (length > DNSName::s_maxDNSLabelLength) { ------------------ | Branch (138:7): [True: 0, False: 20.1k] ------------------ 139| 0| throw std::range_error("label too long to append"); 140| 0| } 141| 20.1k|} _Z11dns_tolowerh: 58| 1.09k|{ 59| 1.09k| return dns_tolower_table[chr]; 60| 1.09k|} _Z39pdns_ilexicographical_compare_three_wayNSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_: 64| 10.5k|{ 65| 10.5k| const unsigned char *aPtr = (const unsigned char*)a.data(), *bPtr = (const unsigned char*)b.data(); 66| 10.5k| const unsigned char *aEptr = aPtr + a.length(), *bEptr = bPtr + b.length(); 67| 54.2k| while(aPtr != aEptr && bPtr != bEptr) { ------------------ | Branch (67:9): [True: 44.1k, False: 10.0k] | Branch (67:26): [True: 44.1k, False: 0] ------------------ 68| 44.1k| if (*aPtr != *bPtr) { ------------------ | Branch (68:9): [True: 546, False: 43.6k] ------------------ 69| 546| if (int rc = dns_tolower(*aPtr) - dns_tolower(*bPtr); rc != 0) { ------------------ | Branch (69:61): [True: 546, False: 0] ------------------ 70| 546| return rc; 71| 546| } 72| 546| } 73| 43.6k| aPtr++; 74| 43.6k| bPtr++; 75| 43.6k| } 76| | // At this point, one of the strings has been completely processed. 77| | // Either both have the same length, and they are equal, or one of them 78| | // is larger, and compares as higher. 79| 10.0k| if (aPtr == aEptr) { ------------------ | Branch (79:7): [True: 10.0k, False: 0] ------------------ 80| 10.0k| if (bPtr != bEptr) { ------------------ | Branch (80:9): [True: 0, False: 10.0k] ------------------ 81| 0| return -1; // a < b 82| 0| } 83| 10.0k| } 84| 0| else { 85| 0| return 1; // a > b 86| 0| } 87| 10.0k| return 0; // a == b 88| 10.0k|} _ZN7DNSNameaSERKS_: 149| 808| { 150| 808| if (this != &rhs) { ------------------ | Branch (150:9): [True: 808, False: 0] ------------------ 151| 808| d_storage = rhs.d_storage; 152| 808| } 153| 808| return *this; 154| 808| } _ZN7DNSNameaSEOS_: 156| 31.3k| { 157| 31.3k| if (this != &rhs) { ------------------ | Branch (157:9): [True: 31.3k, False: 0] ------------------ 158| 31.3k| d_storage = std::move(rhs.d_storage); 159| 31.3k| } 160| 31.3k| return *this; 161| 31.3k| } _ZNK7DNSName15toStringRootDotEv: 178| 23| std::string toStringRootDot() const { if(isRoot()) return "."; else return toString(".", false); } ------------------ | Branch (178:44): [True: 23, False: 0] ------------------ _ZNK7DNSName5emptyEv: 208| 31.8k| bool empty() const { return d_storage.empty(); } _ZNK7DNSName6isRootEv: 209| 29.9k| bool isRoot() const { return d_storage.size()==1 && d_storage[0]==0; } ------------------ | Branch (209:32): [True: 16.1k, False: 13.8k] | Branch (209:55): [True: 16.1k, False: 0] ------------------ _ZNK7DNSName10getStorageEv: 253| 13.8k| const string_t& getStorage() const { 254| 13.8k| return d_storage; 255| 13.8k| } _ZNK7DNSNameeqERKS_: 818| 6.93k|{ 819| 6.93k| if (rhs.empty() != empty() || rhs.d_storage.size() != d_storage.size()) { ------------------ | Branch (819:7): [True: 0, False: 6.93k] | Branch (819:33): [True: 6.93k, False: 0] ------------------ 820| 6.93k| return false; 821| 6.93k| } 822| | 823| 0| const auto* us = d_storage.cbegin(); 824| 0| const auto* p = rhs.d_storage.cbegin(); 825| 0| for (; us != d_storage.cend() && p != rhs.d_storage.cend(); ++us, ++p) { ------------------ | Branch (825:10): [True: 0, False: 0] | Branch (825:36): [True: 0, False: 0] ------------------ 826| 0| if (dns_tolower(*p) != dns_tolower(*us)) { ------------------ | Branch (826:9): [True: 0, False: 0] ------------------ 827| 0| return false; 828| 0| } 829| 0| } 830| 0| return true; 831| 0|} _ZN7DNSNameC2ERKS_: 162| 6.72k| DNSName(const DNSName& a) = default; _ZN7DNSNameC2Ev: 146| 33.1k| DNSName() = default; //!< Constructs an *empty* DNSName, NOT the root! _ZN7DNSNameC2EOS_: 163| 8.70k| DNSName(DNSName&& a) = default; _ZN16DNSRecordContent4makeERK9DNSRecordR12PacketReadert: 243| 10.7k|{ 244| | // For opcode UPDATE and where the DNSRecord is an answer record, we don't care about content, because this is 245| | // not used within the prerequisite section of RFC2136, so - we can simply use unknownrecordcontent. 246| | // For section 3.2.3, we do need content so we need to get it properly. But only for the correct QClasses. 247| 10.7k| if (oc == Opcode::Update && dr.d_place == DNSResourceRecord::ANSWER && dr.d_class != 1) ------------------ | Branch (247:7): [True: 0, False: 10.7k] | Branch (247:31): [True: 0, False: 0] | Branch (247:74): [True: 0, False: 0] ------------------ 248| 0| return std::make_shared(dr, pr); 249| | 250| 10.7k| uint16_t searchclass = (dr.d_type == QType::OPT) ? 1 : dr.d_class; // class is invalid for OPT ------------------ | Branch (250:26): [True: 472, False: 10.2k] ------------------ 251| | 252| 10.7k| auto i = getTypemap().find(pair(searchclass, dr.d_type)); 253| 10.7k| if(i==getTypemap().end() || !i->second) { ------------------ | Branch (253:6): [True: 1.85k, False: 8.90k] | Branch (253:6): [True: 1.85k, False: 8.90k] | Branch (253:31): [True: 0, False: 8.90k] ------------------ 254| 1.85k| return std::make_shared(dr, pr); 255| 1.85k| } 256| | 257| 8.90k| return i->second(dr, pr); 258| 10.7k|} _ZN16DNSRecordContent10getTypemapEv: 268| 21.6k|{ 269| 21.6k| static DNSRecordContent::typemap_t typemap; 270| 21.6k| return typemap; 271| 21.6k|} _ZN16DNSRecordContent12getN2TypemapEv: 274| 118|{ 275| 118| static DNSRecordContent::n2typemap_t n2typemap; 276| 118| return n2typemap; 277| 118|} _ZN16DNSRecordContent12getT2NamemapEv: 280| 118|{ 281| 118| static DNSRecordContent::t2namemap_t t2namemap; 282| 118| return t2namemap; 283| 118|} _ZN16DNSRecordContent12getZmakermapEv: 286| 115|{ 287| 115| static DNSRecordContent::zmakermap_t zmakermap; 288| 115| return zmakermap; 289| 115|} _ZN12MOADNSParser4initEbRKNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 320| 4.81k|{ 321| 4.81k| if (packet.size() < sizeof(dnsheader)) ------------------ | Branch (321:7): [True: 0, False: 4.81k] ------------------ 322| 0| throw MOADNSException("Packet shorter than minimal header"); 323| | 324| 4.81k| memcpy(&d_header, packet.data(), sizeof(dnsheader)); 325| | 326| 4.81k| if(d_header.opcode != Opcode::Query && d_header.opcode != Opcode::Notify && d_header.opcode != Opcode::Update) ------------------ | Branch (326:6): [True: 0, False: 4.81k] | Branch (326:42): [True: 0, False: 0] | Branch (326:79): [True: 0, False: 0] ------------------ 327| 0| throw MOADNSException("Can't parse non-query packet with opcode="+ std::to_string(d_header.opcode)); 328| | 329| 4.81k| d_header.qdcount=ntohs(d_header.qdcount); 330| 4.81k| d_header.ancount=ntohs(d_header.ancount); 331| 4.81k| d_header.nscount=ntohs(d_header.nscount); 332| 4.81k| d_header.arcount=ntohs(d_header.arcount); 333| | 334| 4.81k| if (query && (d_header.qdcount > 1)) ------------------ | Branch (334:7): [True: 0, False: 4.81k] | Branch (334:16): [True: 0, False: 0] ------------------ 335| 0| throw MOADNSException("Query with QD > 1 ("+std::to_string(d_header.qdcount)+")"); 336| | 337| 4.81k| unsigned int n=0; 338| | 339| 4.81k| PacketReader pr(packet); 340| 4.81k| bool validPacket=false; 341| 4.81k| try { 342| 4.81k| d_qtype = d_qclass = 0; // sometimes replies come in with no question, don't present garbage then 343| | 344| 9.63k| for(n=0;n < d_header.qdcount; ++n) { ------------------ | Branch (344:13): [True: 4.81k, False: 4.81k] ------------------ 345| 4.81k| d_qname=pr.getName(); 346| 4.81k| d_qtype=pr.get16BitInt(); 347| 4.81k| d_qclass=pr.get16BitInt(); 348| 4.81k| } 349| | 350| 4.81k| struct dnsrecordheader ah; 351| 4.81k| vector record; 352| 4.81k| bool seenTSIG = false; 353| 4.81k| validPacket=true; 354| 4.81k| unsigned int supposedRecordCount = d_header.ancount + d_header.nscount + d_header.arcount; 355| | // No need to reserve more memory for more records than the request can 356| | // contain. We could try to be smarter and actually count the records 357| | // by doing getDnsrecordheader and skip the payload in a loop, but all 358| | // we really want here is to avoid reserving too much memory in case of 359| | // maliciously high record counts. 360| 4.81k| auto reserveRecordCount = std::min(1 + (packet.size() - sizeof(dnsheader)) / sizeof(dnsrecordheader), static_cast(supposedRecordCount)); 361| 4.81k| d_answers.reserve(reserveRecordCount); 362| 16.1k| for (n = 0; n < supposedRecordCount; ++n) { ------------------ | Branch (362:17): [True: 11.3k, False: 4.79k] ------------------ 363| 11.3k| DNSRecord dr; 364| | 365| 11.3k| if(n < d_header.ancount) ------------------ | Branch (365:10): [True: 10.8k, False: 500] ------------------ 366| 10.8k| dr.d_place=DNSResourceRecord::ANSWER; 367| 500| else if(n < d_header.ancount + d_header.nscount) ------------------ | Branch (367:15): [True: 0, False: 500] ------------------ 368| 0| dr.d_place=DNSResourceRecord::AUTHORITY; 369| 500| else 370| 500| dr.d_place=DNSResourceRecord::ADDITIONAL; 371| | 372| 11.3k| unsigned int recordStartPos=pr.getPosition(); 373| | 374| 11.3k| DNSName name=pr.getName(); 375| | 376| 11.3k| pr.getDnsrecordheader(ah); 377| 11.3k| dr.d_ttl=ah.d_ttl; 378| 11.3k| dr.d_type=ah.d_type; 379| 11.3k| dr.d_class=ah.d_class; 380| | 381| 11.3k| dr.d_name = std::move(name); 382| 11.3k| dr.d_clen = ah.d_clen; 383| | 384| 11.3k| if (query && ------------------ | Branch (384:11): [True: 0, False: 11.3k] ------------------ 385| 0| !(d_qtype == QType::IXFR && dr.d_place == DNSResourceRecord::AUTHORITY && dr.d_type == QType::SOA) && // IXFR queries have a SOA in their AUTHORITY section ------------------ | Branch (385:13): [True: 0, False: 0] | Branch (385:39): [True: 0, False: 0] | Branch (385:85): [True: 0, False: 0] ------------------ 386| 0| (dr.d_place == DNSResourceRecord::ANSWER || dr.d_place == DNSResourceRecord::AUTHORITY || (dr.d_type != QType::OPT && dr.d_type != QType::TSIG && dr.d_type != QType::SIG && dr.d_type != QType::TKEY) || ((dr.d_type == QType::TSIG || dr.d_type == QType::SIG || dr.d_type == QType::TKEY) && dr.d_class != QClass::ANY))) { ------------------ | Branch (386:12): [True: 0, False: 0] | Branch (386:55): [True: 0, False: 0] | Branch (386:102): [True: 0, False: 0] | Branch (386:129): [True: 0, False: 0] | Branch (386:157): [True: 0, False: 0] | Branch (386:184): [True: 0, False: 0] | Branch (386:215): [True: 0, False: 0] | Branch (386:243): [True: 0, False: 0] | Branch (386:270): [True: 0, False: 0] | Branch (386:299): [True: 0, False: 0] ------------------ 387| |// cerr<<"discarding RR, query is "<(dr, pr)); 389| 0| } 390| 11.3k| else { 391| |// cerr<<"parsing RR, query is "<(&ah); 455| | 456| 121k| for(unsigned int n = 0; n < sizeof(dnsrecordheader); ++n) { ------------------ | Branch (456:27): [True: 110k, False: 11.1k] ------------------ 457| 110k| p[n] = d_content.at(d_pos++); 458| 110k| } 459| | 460| 11.1k| ah.d_type = ntohs(ah.d_type); 461| 11.1k| ah.d_class = ntohs(ah.d_class); 462| 11.1k| ah.d_clen = ntohs(ah.d_clen); 463| 11.1k| ah.d_ttl = ntohl(ah.d_ttl); 464| | 465| 11.1k| d_startrecordpos = d_pos; // needed for getBlob later on 466| 11.1k| d_recordlen = ah.d_clen; 467| 11.1k| if (d_pos > d_content.size() || (d_content.size() - d_pos) < (d_recordlen)) { ------------------ | Branch (467:7): [True: 318, False: 10.8k] | Branch (467:35): [True: 63, False: 10.7k] ------------------ 468| 63| throw std::out_of_range("DNS record length (" + std::to_string(d_recordlen) + " starting at " + std::to_string(d_pos) + ") goes beyond the packet's content (" + std::to_string(d_content.size()) + ")"); 469| 63| } 470| 11.1k|} _ZN12PacketReader10copyRecordERNSt3__16vectorIhNS0_9allocatorIhEEEEt: 474| 1.85k|{ 475| 1.85k| if (len == 0) { ------------------ | Branch (475:7): [True: 693, False: 1.16k] ------------------ 476| 693| return; 477| 693| } 478| 1.16k| if ((d_pos + len) > d_content.size()) { ------------------ | Branch (478:7): [True: 0, False: 1.16k] ------------------ 479| 0| throw std::out_of_range("Attempt to copy outside of packet"); 480| 0| } 481| | 482| 1.16k| dest.resize(len); 483| | 484| 3.78M| for (uint16_t n = 0; n < len; ++n) { ------------------ | Branch (484:24): [True: 3.77M, False: 1.16k] ------------------ 485| 3.77M| dest.at(n) = d_content.at(d_pos++); 486| 3.77M| } 487| 1.16k|} _ZN12PacketReader10copyRecordEPht: 490| 105|{ 491| 105| if (d_pos + len > d_content.size()) { ------------------ | Branch (491:7): [True: 0, False: 105] ------------------ 492| 0| throw std::out_of_range("Attempt to copy outside of packet"); 493| 0| } 494| | 495| 105| memcpy(dest, &d_content.at(d_pos), len); 496| 105| d_pos += len; 497| 105|} _ZN12PacketReader18xfrNodeOrLocatorIDER15NodeOrLocatorID: 500| 139|{ 501| 139| if (d_pos + sizeof(ret) > d_content.size()) { ------------------ | Branch (501:7): [True: 6, False: 133] ------------------ 502| 6| throw std::out_of_range("Attempt to read 64 bit value outside of packet"); 503| 6| } 504| 133| memcpy(&ret.content, &d_content.at(d_pos), sizeof(ret.content)); 505| 133| d_pos += sizeof(ret); 506| 133|} _ZN12PacketReader11xfr48BitIntERm: 509| 140|{ 510| 140| ret=0; 511| 140| ret+=static_cast(d_content.at(d_pos++)); 512| 140| ret<<=8; 513| 140| ret+=static_cast(d_content.at(d_pos++)); 514| 140| ret<<=8; 515| 140| ret+=static_cast(d_content.at(d_pos++)); 516| 140| ret<<=8; 517| 140| ret+=static_cast(d_content.at(d_pos++)); 518| 140| ret<<=8; 519| 140| ret+=static_cast(d_content.at(d_pos++)); 520| 140| ret<<=8; 521| 140| ret+=static_cast(d_content.at(d_pos++)); 522| 140|} _ZN12PacketReader11get32BitIntEv: 525| 1.98k|{ 526| 1.98k| uint32_t ret=0; 527| 1.98k| ret+=static_cast(d_content.at(d_pos++)); 528| 1.98k| ret<<=8; 529| 1.98k| ret+=static_cast(d_content.at(d_pos++)); 530| 1.98k| ret<<=8; 531| 1.98k| ret+=static_cast(d_content.at(d_pos++)); 532| 1.98k| ret<<=8; 533| 1.98k| ret+=static_cast(d_content.at(d_pos++)); 534| | 535| 1.98k| return ret; 536| 1.98k|} _ZN12PacketReader11get16BitIntEv: 540| 295k|{ 541| 295k| uint16_t ret=0; 542| 295k| ret+=static_cast(d_content.at(d_pos++)); 543| 295k| ret<<=8; 544| 295k| ret+=static_cast(d_content.at(d_pos++)); 545| | 546| 295k| return ret; 547| 295k|} _ZN12PacketReader10get8BitIntEv: 550| 33.9k|{ 551| 33.9k| return d_content.at(d_pos++); 552| 33.9k|} _ZN12PacketReader7getNameEv: 555| 20.8k|{ 556| 20.8k| unsigned int consumed; 557| 20.8k| try { 558| 20.8k| DNSName dn((const char*) d_content.data(), d_content.size(), d_pos, true /* uncompress */, nullptr /* qtype */, nullptr /* qclass */, &consumed, sizeof(dnsheader)); 559| | 560| 20.8k| d_pos+=consumed; 561| 20.8k| return dn; 562| 20.8k| } 563| 20.8k| catch(const std::range_error& re) { 564| 363| throw std::out_of_range(string("dnsname issue: ")+re.what()); 565| 363| } 566| 20.8k| catch(...) { 567| 0| throw std::out_of_range("dnsname issue"); 568| 0| } 569| 0| throw PDNSException("PacketReader::getName(): name is empty"); 570| 20.8k|} _Z9txtEscapeRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 574| 13.8k|{ 575| 13.8k| string ret; 576| 13.8k| std::array ebuf{}; 577| | 578| 681k| for (char letter : name) { ------------------ | Branch (578:20): [True: 681k, False: 13.8k] ------------------ 579| 681k| const unsigned uch = static_cast(letter); 580| 681k| if (uch >= 127 || uch < 32) { ------------------ | Branch (580:9): [True: 140k, False: 541k] | Branch (580:23): [True: 424k, False: 116k] ------------------ 581| 564k| snprintf(ebuf.data(), ebuf.size(), "\\%03u", uch); 582| 564k| ret += ebuf.data(); 583| 564k| } 584| 116k| else if (letter == '"' || letter == '\\'){ ------------------ | Branch (584:14): [True: 2.38k, False: 114k] | Branch (584:31): [True: 976, False: 113k] ------------------ 585| 3.36k| ret += '\\'; 586| 3.36k| ret += letter; 587| 3.36k| } 588| 113k| else { 589| 113k| ret += letter; 590| 113k| } 591| 681k| } 592| 13.8k| return ret; 593| 13.8k|} _ZN12PacketReader7getTextEbb: 597| 1.19k|{ 598| 1.19k| string ret; 599| 1.19k| ret.reserve(40); 600| 120k| while (d_pos < d_startrecordpos + d_recordlen ) { ------------------ | Branch (600:10): [True: 119k, False: 915] ------------------ 601| 119k| if (!ret.empty()) { ------------------ | Branch (601:9): [True: 118k, False: 721] ------------------ 602| 118k| ret.append(1,' '); 603| 118k| } 604| 119k| uint16_t labellen; 605| 119k| if (lenField) { ------------------ | Branch (605:9): [True: 119k, False: 355] ------------------ 606| 119k| labellen = static_cast(d_content.at(d_pos++)); 607| 119k| } 608| 355| else { 609| 355| labellen = d_recordlen - (d_pos - d_startrecordpos); 610| 355| } 611| | 612| 119k| const uint16_t remaining = (d_startrecordpos + d_recordlen) - d_pos; 613| 119k| if (labellen > remaining) { ------------------ | Branch (613:9): [True: 62, False: 119k] ------------------ 614| 62| throw std::out_of_range("label length in text record exceeds record boundary"); 615| 62| } 616| | 617| 119k| ret.append(1, '"'); 618| 119k| if (labellen) { // no need to do anything for an empty string ------------------ | Branch (618:9): [True: 13.8k, False: 105k] ------------------ 619| 13.8k| string val(&d_content.at(d_pos), &d_content.at(d_pos + labellen - 1) + 1); 620| 13.8k| ret.append(txtEscape(val)); // the end is one beyond the packet 621| 13.8k| } 622| 119k| ret.append(1, '"'); 623| 119k| d_pos += labellen; 624| 119k| if (!multi) { ------------------ | Branch (624:9): [True: 219, False: 119k] ------------------ 625| 219| break; 626| 219| } 627| 119k| } 628| | 629| 1.13k| if (ret.empty() && !lenField) { ------------------ | Branch (629:7): [True: 475, False: 659] | Branch (629:22): [True: 182, False: 293] ------------------ 630| | // all lenField == false cases (CAA and URI at the time of this writing) want that emptiness to be explicit 631| 182| return "\"\""; 632| 182| } 633| 952| return ret; 634| 1.13k|} _ZN12PacketReader15getUnquotedTextEb: 637| 399|{ 638| 399| uint16_t stop_at{}; 639| 399| if (lenField) { ------------------ | Branch (639:7): [True: 399, False: 0] ------------------ 640| 399| stop_at = static_cast(d_content.at(d_pos)) + d_pos + 1; 641| 399| } 642| 0| else { 643| 0| stop_at = d_recordlen; 644| 0| } 645| | 646| | /* think unsigned overflow */ 647| 399| if (stop_at < d_pos) { ------------------ | Branch (647:7): [True: 0, False: 399] ------------------ 648| 0| throw std::out_of_range("getUnquotedText out of record range"); 649| 0| } 650| | 651| | /* Validate against record boundary */ 652| 399| const uint16_t recordEnd = d_startrecordpos + d_recordlen; 653| 399| if (stop_at > recordEnd) { ------------------ | Branch (653:7): [True: 39, False: 360] ------------------ 654| 39| throw std::out_of_range("getUnquotedText: length exceeds record boundary"); 655| 39| } 656| | 657| 360| if (stop_at == d_pos) { ------------------ | Branch (657:7): [True: 0, False: 360] ------------------ 658| 0| return ""; 659| 0| } 660| | 661| 360| d_pos++; 662| 360| string ret(d_content.substr(d_pos, stop_at-d_pos)); 663| 360| d_pos = stop_at; 664| 360| return ret; 665| 360|} _ZN12PacketReader7xfrBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 668| 2.43k|{ 669| 2.43k| try { 670| 2.43k| if(d_recordlen && !(d_pos == (d_startrecordpos + d_recordlen))) { ------------------ | Branch (670:8): [True: 1.64k, False: 788] | Branch (670:23): [True: 1.53k, False: 106] ------------------ 671| 1.53k| if (d_pos > (d_startrecordpos + d_recordlen)) { ------------------ | Branch (671:11): [True: 8, False: 1.53k] ------------------ 672| 8| throw std::out_of_range("xfrBlob out of record range"); 673| 8| } 674| 1.53k| blob.assign(&d_content.at(d_pos), &d_content.at(d_startrecordpos + d_recordlen - 1 ) + 1); 675| 1.53k| } 676| 894| else { 677| 894| blob.clear(); 678| 894| } 679| | 680| 2.42k| d_pos = d_startrecordpos + d_recordlen; 681| 2.42k| } 682| 2.43k| catch(...) 683| 2.43k| { 684| 8| throw std::out_of_range("xfrBlob out of range"); 685| 8| } 686| 2.43k|} _ZN12PacketReader15xfrBlobNoSpacesERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEi: 688| 327|void PacketReader::xfrBlobNoSpaces(string& blob, int length) { 689| 327| xfrBlob(blob, length); 690| 327|} _ZN12PacketReader7xfrBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEi: 693| 37.6k|{ 694| 37.6k| if(length) { ------------------ | Branch (694:6): [True: 37.1k, False: 477] ------------------ 695| 37.1k| if (length < 0) { ------------------ | Branch (695:9): [True: 0, False: 37.1k] ------------------ 696| 0| throw std::out_of_range("xfrBlob out of range (negative length)"); 697| 0| } 698| 37.1k| auto available = (d_startrecordpos + d_recordlen) - d_pos; 699| 37.1k| if (available < length) { ------------------ | Branch (699:9): [True: 173, False: 36.9k] ------------------ 700| 173| throw std::out_of_range("xfrBlob out of range (excessive length)"); 701| 173| } 702| | 703| 36.9k| blob.assign(&d_content.at(d_pos), &d_content.at(d_pos + length - 1 ) + 1 ); 704| | 705| 36.9k| d_pos += length; 706| 36.9k| } 707| 477| else { 708| 477| blob.clear(); 709| 477| } 710| 37.6k|} _ZN12PacketReader18xfrSvcParamKeyValsERNSt3__13setI8SvcParamNS0_4lessIS2_EENS0_9allocatorIS2_EEEE: 712| 1.07k|void PacketReader::xfrSvcParamKeyVals(set &kvs) { 713| 1.07k| int32_t lastKey{-1}; // Keep track of the last key, as ordering should be strict 714| | 715| 2.10k| while (d_pos < (d_startrecordpos + d_recordlen)) { ------------------ | Branch (715:10): [True: 1.37k, False: 731] ------------------ 716| 1.37k| if (d_pos + 2 > (d_startrecordpos + d_recordlen)) { ------------------ | Branch (716:9): [True: 30, False: 1.34k] ------------------ 717| 30| throw std::out_of_range("incomplete key"); 718| 30| } 719| 1.34k| uint16_t keyInt; 720| 1.34k| xfr16BitInt(keyInt); 721| | 722| 1.34k| if (keyInt <= lastKey) { ------------------ | Branch (722:9): [True: 77, False: 1.26k] ------------------ 723| 77| throw std::out_of_range("Found SVCParamKey " + std::to_string(keyInt) + " after SVCParamKey " + std::to_string(lastKey)); 724| 77| } 725| 1.26k| lastKey = keyInt; 726| | 727| 1.26k| auto key = static_cast(keyInt); 728| | 729| 1.26k| uint16_t len; 730| 1.26k| xfr16BitInt(len); 731| | 732| 1.26k| if (d_pos + len > (d_startrecordpos + d_recordlen)) { ------------------ | Branch (732:9): [True: 96, False: 1.17k] ------------------ 733| 96| throw std::out_of_range("record is shorter than SVCB lengthfield implies"); 734| 96| } 735| | 736| 1.17k| switch (key) 737| 1.17k| { 738| 210| case SvcParam::mandatory: { ------------------ | Branch (738:5): [True: 210, False: 962] ------------------ 739| 210| if (len % 2 != 0) { ------------------ | Branch (739:11): [True: 1, False: 209] ------------------ 740| 1| throw std::out_of_range("mandatory SvcParam has invalid length"); 741| 1| } 742| 209| if (len == 0) { ------------------ | Branch (742:11): [True: 4, False: 205] ------------------ 743| 4| throw std::out_of_range("empty 'mandatory' values"); 744| 4| } 745| 205| std::set paramKeys; 746| 205| size_t stop = d_pos + len; 747| 207k| while (d_pos < stop) { ------------------ | Branch (747:14): [True: 207k, False: 205] ------------------ 748| 207k| uint16_t keyval; 749| 207k| xfr16BitInt(keyval); 750| 207k| paramKeys.insert(static_cast(keyval)); 751| 207k| } 752| 205| kvs.insert(SvcParam(key, std::move(paramKeys))); 753| 205| break; 754| 209| } 755| 125| case SvcParam::alpn: { ------------------ | Branch (755:5): [True: 125, False: 1.04k] ------------------ 756| 125| size_t stop = d_pos + len; 757| 125| std::vector alpns; 758| 21.4k| while (d_pos < stop) { ------------------ | Branch (758:14): [True: 21.3k, False: 44] ------------------ 759| 21.3k| string alpn; 760| 21.3k| uint8_t alpnLen = 0; 761| 21.3k| xfr8BitInt(alpnLen); 762| 21.3k| if (alpnLen == 0) { ------------------ | Branch (762:13): [True: 27, False: 21.3k] ------------------ 763| 27| throw std::out_of_range("alpn length of 0"); 764| 27| } 765| 21.3k| if (d_pos + alpnLen > stop) { ------------------ | Branch (765:13): [True: 54, False: 21.2k] ------------------ 766| 54| throw std::out_of_range("alpn length is larger than rest of alpn SVC Param"); 767| 54| } 768| 21.2k| xfrBlob(alpn, alpnLen); 769| 21.2k| alpns.push_back(std::move(alpn)); 770| 21.2k| } 771| 44| kvs.insert(SvcParam(key, std::move(alpns))); 772| 44| break; 773| 125| } 774| 22| case SvcParam::ohttp: ------------------ | Branch (774:5): [True: 22, False: 1.15k] ------------------ 775| 53| case SvcParam::no_default_alpn: { ------------------ | Branch (775:5): [True: 31, False: 1.14k] ------------------ 776| 53| if (len != 0) { ------------------ | Branch (776:11): [True: 4, False: 49] ------------------ 777| 4| throw std::out_of_range("invalid length for " + SvcParam::keyToString(key)); 778| 4| } 779| 49| kvs.insert(SvcParam(key)); 780| 49| break; 781| 53| } 782| 68| case SvcParam::port: { ------------------ | Branch (782:5): [True: 68, False: 1.10k] ------------------ 783| 68| if (len != 2) { ------------------ | Branch (783:11): [True: 4, False: 64] ------------------ 784| 4| throw std::out_of_range("invalid length for port"); 785| 4| } 786| 64| uint16_t port; 787| 64| xfr16BitInt(port); 788| 64| kvs.insert(SvcParam(key, port)); 789| 64| break; 790| 68| } 791| 115| case SvcParam::ipv4hint: ------------------ | Branch (791:5): [True: 115, False: 1.05k] ------------------ 792| 152| case SvcParam::ipv6hint: { ------------------ | Branch (792:5): [True: 37, False: 1.13k] ------------------ 793| 152| size_t addrLen = (key == SvcParam::ipv4hint ? 4 : 16); ------------------ | Branch (793:25): [True: 115, False: 37] ------------------ 794| 152| if (len % addrLen != 0) { ------------------ | Branch (794:11): [True: 5, False: 147] ------------------ 795| 5| throw std::out_of_range("invalid length for " + SvcParam::keyToString(key)); 796| 5| } 797| 147| vector addresses; 798| 147| auto stop = d_pos + len; 799| 15.4k| while (d_pos < stop) ------------------ | Branch (799:14): [True: 15.2k, False: 147] ------------------ 800| 15.2k| { 801| 15.2k| ComboAddress addr; 802| 15.2k| xfrCAWithoutPort(key, addr); 803| 15.2k| addresses.push_back(addr); 804| 15.2k| } 805| | // If there were no addresses, and the input comes from internal 806| | // representation, we can reasonably assume this is the serialization 807| | // of "auto". 808| 147| bool doAuto{d_internal && len == 0}; ------------------ | Branch (808:19): [True: 0, False: 147] | Branch (808:33): [True: 0, False: 0] ------------------ 809| 147| auto param = SvcParam(key, std::move(addresses)); 810| 147| param.setAutoHint(doAuto); 811| 147| kvs.insert(std::move(param)); 812| 147| break; 813| 152| } 814| 34| case SvcParam::ech: { ------------------ | Branch (814:5): [True: 34, False: 1.13k] ------------------ 815| 34| std::string blob; 816| 34| blob.reserve(len); 817| 34| xfrBlobNoSpaces(blob, len); 818| 34| kvs.insert(SvcParam(key, blob)); 819| 34| break; 820| 152| } 821| 135| case SvcParam::tls_supported_groups: { ------------------ | Branch (821:5): [True: 135, False: 1.03k] ------------------ 822| 135| if (len % 2 != 0) { ------------------ | Branch (822:11): [True: 1, False: 134] ------------------ 823| 1| throw std::out_of_range("invalid length for " + SvcParam::keyToString(key)); 824| 1| } 825| 134| vector groups; 826| 134| groups.reserve(len / 2); 827| 134| auto stop = d_pos + len; 828| 67.9k| while (d_pos < stop) ------------------ | Branch (828:14): [True: 67.8k, False: 134] ------------------ 829| 67.8k| { 830| 67.8k| uint16_t group = 0; 831| 67.8k| xfr16BitInt(group); 832| 67.8k| groups.push_back(group); 833| 67.8k| } 834| 134| auto param = SvcParam(key, std::move(groups)); 835| 134| kvs.insert(std::move(param)); 836| 134| break; 837| 135| } 838| 359| default: { ------------------ | Branch (838:5): [True: 359, False: 813] ------------------ 839| 359| std::string blob; 840| 359| blob.reserve(len); 841| 359| xfrBlob(blob, len); 842| 359| kvs.insert(SvcParam(key, blob)); 843| 359| break; 844| 135| } 845| 1.17k| } 846| 1.17k| } 847| 1.07k|} _ZN12PacketReader10xfrHexBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb: 851| 528|{ 852| 528| xfrBlob(blob); 853| 528|} _ZN9DNSRecordC2Ev: 338| 11.3k| d_class(QClass::IN) 339| 11.3k| {} _ZN15MOADNSExceptionC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 61| 2.61k| MOADNSException(const string& str) : runtime_error(str) 62| 2.61k| {} _ZN16DNSRecordContentD2Ev: 228| 10.7k| virtual ~DNSRecordContent() = default; _ZN12PacketReaderC2ERKNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEtb: 72| 4.81k| : d_pos(initialPos), d_startrecordpos(initialPos), d_content(content), d_internal(internalRepresentation) 73| 4.81k| { 74| 4.81k| if(content.size() > std::numeric_limits::max()) ------------------ | Branch (74:8): [True: 0, False: 4.81k] ------------------ 75| 0| throw std::out_of_range("packet too large"); 76| | 77| 4.81k| d_recordlen = (uint16_t) content.size(); 78| 4.81k| not_used = 0; 79| 4.81k| } _ZNK12PacketReader11getPositionEv: 194| 11.3k| { 195| 11.3k| return d_pos; 196| 11.3k| } _ZN9DNSRecord10setContentEONSt3__110shared_ptrIK16DNSRecordContentEE: 394| 8.72k| { 395| 8.72k| d_content = std::move(content); 396| 8.72k| } _ZN12PacketReader11xfr16BitIntERt: 124| 286k| { 125| 286k| val=get16BitInt(); 126| 286k| } _ZN12PacketReader10xfr8BitIntERh: 135| 33.9k| { 136| 33.9k| val=get8BitInt(); 137| 33.9k| } _ZN12PacketReader16xfrCAWithoutPortEhR12ComboAddress: 103| 15.2k| void xfrCAWithoutPort(uint8_t version, ComboAddress &val) { 104| 15.2k| string blob; 105| 15.2k| if (version == 4) xfrBlob(blob, 4); ------------------ | Branch (105:9): [True: 13.5k, False: 1.70k] ------------------ 106| 1.70k| else if (version == 6) xfrBlob(blob, 16); ------------------ | Branch (106:14): [True: 1.70k, False: 0] ------------------ 107| 0| else throw runtime_error("invalid IP protocol"); 108| 15.2k| val = makeComboAddressFromRaw(version, blob); 109| 15.2k| } _ZN20UnknownRecordContentC2ERK9DNSRecordR12PacketReader: 492| 1.85k| : d_dr(dr) 493| 1.85k| { 494| 1.85k| pr.copyRecord(d_record, dr.d_clen); 495| 1.85k| } _ZN12PacketReader11xfr32BitIntERj: 89| 1.98k| { 90| 1.98k| val=get32BitInt(); 91| 1.98k| } _ZN12PacketReader5xfrIPERj: 94| 102| { 95| 102| xfr32BitInt(val); 96| | val=htonl(val); 97| 102| } _ZN12PacketReader6xfrIP6ERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 99| 81| void xfrIP6(std::string &val) { 100| 81| xfrBlob(val, 16); 101| 81| } _ZN12PacketReader7xfrTimeERj: 118| 252| { 119| 252| xfr32BitInt(val); 120| 252| } _ZN12PacketReader7xfrTypeERt: 129| 132| { 130| 132| xfr16BitInt(val); 131| 132| } _ZN12PacketReader7xfrNameER7DNSNameb: 140| 4.74k| { 141| 4.74k| name = getName(); 142| 4.74k| } _ZN12PacketReader7xfrTextERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEbb: 145| 1.19k| { 146| 1.19k| text=getText(multi, lenField); 147| 1.19k| } _ZN12PacketReader15xfrUnquotedTextERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb: 149| 399| void xfrUnquotedText(string &text, bool lenField){ 150| 399| text=getUnquotedText(lenField); 151| 399| } _ZNK12PacketReader3eofEv: 171| 7.54k| { 172| 7.54k| return d_pos >= (d_startrecordpos + d_recordlen); 173| 7.54k| } _ZNK12PacketReader12getRemainingEv: 177| 730| std::string getRemaining() const { 178| 730| return "Remaining data from PacketReader, current position " + std::to_string(d_pos) + " in packet of size " + std::to_string(d_content.size()) + ", end of record expected at " + std::to_string(d_startrecordpos + d_recordlen) + ": " + makeHexDump(std::string(d_content.begin() + d_pos, d_content.begin() + d_startrecordpos + d_recordlen)); 179| 730| }; _ZN12PacketReader16consumeRemainingEv: 188| 1.04k| { 189| 1.04k| d_pos = (d_startrecordpos + d_recordlen); 190| 1.04k| } _ZN16DNSRecordContent13doRecordCheckERK9DNSRecord: 265| 7.47k| void doRecordCheck(const struct DNSRecord&){} _ZN16DNSRecordContent6registEttPFNSt3__110shared_ptrIS_EERK9DNSRecordR12PacketReaderEPFS2_RKNS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEEPKc: 271| 118| { 272| 118| assert(!d_locked.load()); // NOLINT: it's the API ------------------ | Branch (272:5): [True: 118, False: 0] ------------------ 273| 118| if(f) ------------------ | Branch (273:8): [True: 115, False: 3] ------------------ 274| 115| getTypemap()[pair(cl,ty)]=f; 275| 118| if(z) ------------------ | Branch (275:8): [True: 115, False: 3] ------------------ 276| 115| getZmakermap()[pair(cl,ty)]=z; 277| | 278| 118| getT2Namemap().emplace(pair(cl, ty), name); 279| 118| getN2Typemap().emplace(name, pair(cl, ty)); 280| 118| } _ZN16DNSRecordContent4lockEv: 317| 1| { 318| 1| d_locked.store(true); 319| 1| } _ZN12MOADNSParserC2EbPKcj: 532| 4.81k| MOADNSParser(bool query, const char *packet, unsigned int len) : d_tsigPos(0) 533| 4.81k| { 534| 4.81k| init(query, std::string_view(packet, len)); 535| 4.81k| } _ZN14ARecordContent13doRecordCheckERK9DNSRecord: 141| 54|{ 142| 54| if(dr.d_clen!=4) ------------------ | Branch (142:6): [True: 28, False: 26] ------------------ 143| 28| throw MOADNSException("Wrong size for A record ("+std::to_string(dr.d_clen)+")"); 144| 54|} _ZN19DNSKEYRecordContentC2Ev: 463| 96|DNSKEYRecordContent::DNSKEYRecordContent() = default; _ZN18EUI48RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 500| 1|{ 501| 1| regist(1, QType::EUI48, &make, &make, "EUI48"); 502| 1|} _ZN18EUI48RecordContent4makeERK9DNSRecordR12PacketReader: 504| 66|{ 505| 66| if(dr.d_clen!=6) ------------------ | Branch (505:8): [True: 5, False: 61] ------------------ 506| 5| throw MOADNSException("Wrong size for EUI48 record"); 507| | 508| 61| auto ret=std::make_shared(); 509| 61| pr.copyRecord((uint8_t*) &ret->d_eui48, 6); 510| 61| if (!pr.eof()) { ------------------ | Branch (510:9): [True: 0, False: 61] ------------------ 511| 0| throw MOADNSException("When parsing EUI48 trailing data was not parsed: '" + pr.getRemaining() + "'"); 512| 0| } 513| 61| return ret; 514| 61|} _ZN18EUI64RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 547| 1|{ 548| 1| regist(1, QType::EUI64, &make, &make, "EUI64"); 549| 1|} _ZN18EUI64RecordContent4makeERK9DNSRecordR12PacketReader: 551| 62|{ 552| 62| if(dr.d_clen!=8) ------------------ | Branch (552:8): [True: 18, False: 44] ------------------ 553| 18| throw MOADNSException("Wrong size for EUI64 record"); 554| | 555| 44| auto ret=std::make_shared(); 556| 44| pr.copyRecord((uint8_t*) &ret->d_eui64, 8); 557| 44| if (!pr.eof()) { ------------------ | Branch (557:9): [True: 0, False: 44] ------------------ 558| 0| throw MOADNSException("When parsing EUI64 trailing data was not parsed: '" + pr.getRemaining() + "'"); 559| 0| } 560| 44| return ret; 561| 44|} _ZN16APLRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 596| 1|{ 597| 1| regist(1, QType::APL, &make, &make, "APL"); 598| 1|} _ZN16APLRecordContent4makeERK9DNSRecordR12PacketReader: 601| 222|std::shared_ptr APLRecordContent::make(const DNSRecord &dr, PacketReader& pr) { 602| 222| uint8_t temp; 603| 222| APLRDataElement ard; 604| 222| size_t processed = 0; 605| | 606| 222| auto ret=std::make_shared(); 607| | 608| 3.36k| while (processed> 7; 616| 3.22k| ard.d_afdlength = temp & 127; 617| | 618| 3.22k| if (ard.d_afdlength > dr.d_clen - processed - 4) { ------------------ | Branch (618:9): [True: 9, False: 3.21k] ------------------ 619| 9| throw MOADNSException("Malformed APL record, address data extends beyond record length"); 620| 9| } 621| | 622| 3.21k| if (ard.d_family == APL_FAMILY_IPV4) { ------------------ | | 1201| 3.21k|#define APL_FAMILY_IPV4 1 ------------------ | Branch (622:9): [True: 2.01k, False: 1.20k] ------------------ 623| 2.01k| if (ard.d_afdlength > 4) { ------------------ | Branch (623:11): [True: 7, False: 2.00k] ------------------ 624| 7| throw MOADNSException("Invalid IP length for IPv4 APL"); 625| 7| } 626| 2.00k| memset(ard.d_ip.d_ip4, 0, sizeof(ard.d_ip.d_ip4)); 627| 3.47k| for (u_int i=0; i < ard.d_afdlength; i++) ------------------ | Branch (627:23): [True: 1.47k, False: 2.00k] ------------------ 628| 1.47k| pr.xfr8BitInt(ard.d_ip.d_ip4[i]); 629| 2.00k| } else if (ard.d_family == APL_FAMILY_IPV6) { ------------------ | | 1202| 1.20k|#define APL_FAMILY_IPV6 2 ------------------ | Branch (629:16): [True: 1.14k, False: 55] ------------------ 630| 1.14k| if (ard.d_afdlength > 16) { ------------------ | Branch (630:11): [True: 4, False: 1.14k] ------------------ 631| 4| throw MOADNSException("Invalid IP length for IPv6 APL"); 632| 4| } 633| 1.14k| memset(ard.d_ip.d_ip6, 0, sizeof(ard.d_ip.d_ip6)); 634| 2.05k| for (u_int i=0; i < ard.d_afdlength; i++) ------------------ | Branch (634:23): [True: 910, False: 1.14k] ------------------ 635| 910| pr.xfr8BitInt(ard.d_ip.d_ip6[i]); 636| 1.14k| } else { 637| 55| throw MOADNSException("Unknown family for APL record"); 638| 55| } 639| | 640| 3.14k| processed += 4 + ard.d_afdlength; 641| | 642| 3.14k| ret->aplrdata.push_back(ard); 643| 3.14k| } 644| 135| if (!pr.eof()) { ------------------ | Branch (644:7): [True: 0, False: 135] ------------------ 645| 0| throw MOADNSException("When parsing APL trailing data was not parsed: '" + pr.getRemaining() + "'"); 646| 0| } 647| | 648| 135| return ret; 649| 135|} _Z14reportAllTypesv: 1060| 1|{ 1061| 1| ReportIsOnlyCallableByReportAllTypes guard; 1062| 1| reportBasicTypes(guard); 1063| 1| reportOtherTypes(guard); 1064| 1| DNSRecordContent::lock(); 1065| 1|} dnsrecords.cc:_ZL16reportBasicTypesRK36ReportIsOnlyCallableByReportAllTypes: 977| 1|{ 978| 1| ARecordContent::report(guard); 979| 1| AAAARecordContent::report(guard); 980| 1| NSRecordContent::report(guard); 981| 1| CNAMERecordContent::report(guard); 982| 1| MXRecordContent::report(guard); 983| 1| SOARecordContent::report(guard); 984| 1| SRVRecordContent::report(guard); 985| 1| PTRRecordContent::report(guard); 986| 1| DNSRecordContent::regist(QClass::CHAOS, QType::TXT, &TXTRecordContent::make, &TXTRecordContent::make, "TXT"); 987| 1| TXTRecordContent::report(guard); 988| |#ifdef HAVE_LUA_RECORDS 989| | LUARecordContent::report(guard); 990| |#endif 991| 1| DNSRecordContent::regist(QClass::IN, QType::ANY, nullptr, nullptr, "ANY"); 992| 1| DNSRecordContent::regist(QClass::IN, QType::AXFR, nullptr, nullptr, "AXFR"); 993| 1| DNSRecordContent::regist(QClass::IN, QType::IXFR, nullptr, nullptr, "IXFR"); 994| 1|} dnsrecords.cc:_ZL16reportOtherTypesRK36ReportIsOnlyCallableByReportAllTypes: 997| 1|{ 998| 1| MBRecordContent::report(guard); 999| 1| MGRecordContent::report(guard); 1000| 1| MRRecordContent::report(guard); 1001| 1| AFSDBRecordContent::report(guard); 1002| 1| DNAMERecordContent::report(guard); 1003| 1|#if !defined(RECURSOR) 1004| 1| ALIASRecordContent::report(guard); 1005| 1|#endif 1006| 1| SPFRecordContent::report(guard); 1007| 1| NAPTRRecordContent::report(guard); 1008| 1| KXRecordContent::report(guard); 1009| 1| LOCRecordContent::report(guard); 1010| 1| ENTRecordContent::report(guard); 1011| 1| HINFORecordContent::report(guard); 1012| 1| RPRecordContent::report(guard); 1013| 1| KEYRecordContent::report(guard); 1014| 1| DNSKEYRecordContent::report(guard); 1015| 1| DHCIDRecordContent::report(guard); 1016| 1| CDNSKEYRecordContent::report(guard); 1017| 1| RKEYRecordContent::report(guard); 1018| 1| RRSIGRecordContent::report(guard); 1019| 1| DSRecordContent::report(guard); 1020| 1| CDSRecordContent::report(guard); 1021| 1| SSHFPRecordContent::report(guard); 1022| 1| CERTRecordContent::report(guard); 1023| 1| NSECRecordContent::report(guard); 1024| 1| NSEC3RecordContent::report(guard); 1025| 1| NSEC3PARAMRecordContent::report(guard); 1026| 1| TLSARecordContent::report(guard); 1027| 1| SMIMEARecordContent::report(guard); 1028| 1| OPENPGPKEYRecordContent::report(guard); 1029| 1| SVCBRecordContent::report(guard); 1030| 1| HTTPSRecordContent::report(guard); 1031| 1| HHITRecordContent::report(guard); 1032| 1| BRIDRecordContent::report(guard); 1033| 1| DLVRecordContent::report(guard); 1034| 1| DNSRecordContent::regist(QClass::ANY, QType::TSIG, &TSIGRecordContent::make, &TSIGRecordContent::make, "TSIG"); 1035| 1| DNSRecordContent::regist(QClass::ANY, QType::TKEY, &TKEYRecordContent::make, &TKEYRecordContent::make, "TKEY"); 1036| | //TSIGRecordContent::report(guard); 1037| 1| OPTRecordContent::report(guard); 1038| 1| EUI48RecordContent::report(guard); 1039| 1| EUI64RecordContent::report(guard); 1040| 1| MINFORecordContent::report(guard); 1041| 1| URIRecordContent::report(guard); 1042| 1| CAARecordContent::report(guard); 1043| 1| RESINFORecordContent::report(guard); 1044| 1| APLRecordContent::report(guard); 1045| 1| IPSECKEYRecordContent::report(guard); 1046| 1| CSYNCRecordContent::report(guard); 1047| 1| NIDRecordContent::report(guard); 1048| 1| L32RecordContent::report(guard); 1049| 1| L64RecordContent::report(guard); 1050| 1| LPRecordContent::report(guard); 1051| 1| WALLETRecordContent::report(guard); 1052| 1| ZONEMDRecordContent::report(guard); 1053| 1|} _ZN14ARecordContent4makeERK9DNSRecordR12PacketReader: 1291| 54|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 54|{ \ 1293| 54| return std::make_shared(dr, pr); \ 1294| 54|} \ _ZN14ARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 54|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 54|{ \ 1298| 54| doRecordCheck(dr); \ 1299| 54| xfrPacket(pr); \ 1300| 54|} \ _ZN14ARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17AAAARecordContent4makeERK9DNSRecordR12PacketReader: 1291| 65|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 65|{ \ 1293| 65| return std::make_shared(dr, pr); \ 1294| 65|} \ _ZN17AAAARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 65|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 65|{ \ 1298| 65| doRecordCheck(dr); \ 1299| 65| xfrPacket(pr); \ 1300| 65|} \ _ZN17AAAARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15NSRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 134|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 134|{ \ 1293| 134| return std::make_shared(dr, pr); \ 1294| 134|} \ _ZN15NSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 134|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 134|{ \ 1298| 134| doRecordCheck(dr); \ 1299| 134| xfrPacket(pr); \ 1300| 134|} \ _ZN15NSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16PTRRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 89|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 89|{ \ 1293| 89| return std::make_shared(dr, pr); \ 1294| 89|} \ _ZN16PTRRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 89|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 89|{ \ 1298| 89| doRecordCheck(dr); \ 1299| 89| xfrPacket(pr); \ 1300| 89|} \ _ZN16PTRRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18CNAMERecordContent4makeERK9DNSRecordR12PacketReader: 1291| 115|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 115|{ \ 1293| 115| return std::make_shared(dr, pr); \ 1294| 115|} \ _ZN18CNAMERecordContentC2ERK9DNSRecordR12PacketReader: 1296| 115|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 115|{ \ 1298| 115| doRecordCheck(dr); \ 1299| 115| xfrPacket(pr); \ 1300| 115|} \ _ZN18CNAMERecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18ALIASRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 93|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 93|{ \ 1293| 93| return std::make_shared(dr, pr); \ 1294| 93|} \ _ZN18ALIASRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 93|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 93|{ \ 1298| 93| doRecordCheck(dr); \ 1299| 93| xfrPacket(pr); \ 1300| 93|} \ _ZN18ALIASRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18DNAMERecordContent4makeERK9DNSRecordR12PacketReader: 1291| 85|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 85|{ \ 1293| 85| return std::make_shared(dr, pr); \ 1294| 85|} \ _ZN18DNAMERecordContentC2ERK9DNSRecordR12PacketReader: 1296| 85|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 85|{ \ 1298| 85| doRecordCheck(dr); \ 1299| 85| xfrPacket(pr); \ 1300| 85|} \ _ZN18DNAMERecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15MBRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 92|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 92|{ \ 1293| 92| return std::make_shared(dr, pr); \ 1294| 92|} \ _ZN15MBRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 92|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 92|{ \ 1298| 92| doRecordCheck(dr); \ 1299| 92| xfrPacket(pr); \ 1300| 92|} \ _ZN15MBRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15MGRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 126|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 126|{ \ 1293| 126| return std::make_shared(dr, pr); \ 1294| 126|} \ _ZN15MGRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 126|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 126|{ \ 1298| 126| doRecordCheck(dr); \ 1299| 126| xfrPacket(pr); \ 1300| 126|} \ _ZN15MGRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15MRRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 96|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 96|{ \ 1293| 96| return std::make_shared(dr, pr); \ 1294| 96|} \ _ZN15MRRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 96|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 96|{ \ 1298| 96| doRecordCheck(dr); \ 1299| 96| xfrPacket(pr); \ 1300| 96|} \ _ZN15MRRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18MINFORecordContent4makeERK9DNSRecordR12PacketReader: 1291| 235|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 235|{ \ 1293| 235| return std::make_shared(dr, pr); \ 1294| 235|} \ _ZN18MINFORecordContentC2ERK9DNSRecordR12PacketReader: 1296| 235|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 235|{ \ 1298| 235| doRecordCheck(dr); \ 1299| 235| xfrPacket(pr); \ 1300| 235|} \ _ZN18MINFORecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16TXTRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 56|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 56|{ \ 1293| 56| return std::make_shared(dr, pr); \ 1294| 56|} \ _ZN16TXTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 56|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 56|{ \ 1298| 56| doRecordCheck(dr); \ 1299| 56| xfrPacket(pr); \ 1300| 56|} \ _ZN16TXTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16ENTRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 1.04k|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 1.04k|{ \ 1293| 1.04k| return std::make_shared(dr, pr); \ 1294| 1.04k|} \ _ZN16ENTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 1.04k|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 1.04k|{ \ 1298| 1.04k| doRecordCheck(dr); \ 1299| 1.04k| xfrPacket(pr); \ 1300| 1.04k|} \ _ZN16ENTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16SPFRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 54|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 54|{ \ 1293| 54| return std::make_shared(dr, pr); \ 1294| 54|} \ _ZN16SPFRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 54|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 54|{ \ 1298| 54| doRecordCheck(dr); \ 1299| 54| xfrPacket(pr); \ 1300| 54|} \ _ZN16SPFRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18HINFORecordContent4makeERK9DNSRecordR12PacketReader: 1291| 70|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 70|{ \ 1293| 70| return std::make_shared(dr, pr); \ 1294| 70|} \ _ZN18HINFORecordContentC2ERK9DNSRecordR12PacketReader: 1296| 70|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 70|{ \ 1298| 70| doRecordCheck(dr); \ 1299| 70| xfrPacket(pr); \ 1300| 70|} \ _ZN18HINFORecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15RPRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 147|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 147|{ \ 1293| 147| return std::make_shared(dr, pr); \ 1294| 147|} \ _ZN15RPRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 147|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 147|{ \ 1298| 147| doRecordCheck(dr); \ 1299| 147| xfrPacket(pr); \ 1300| 147|} \ _ZN15RPRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16OPTRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 472|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 472|{ \ 1293| 472| return std::make_shared(dr, pr); \ 1294| 472|} \ _ZN16OPTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 472|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 472|{ \ 1298| 472| doRecordCheck(dr); \ 1299| 472| xfrPacket(pr); \ 1300| 472|} \ _ZN16OPTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN19WALLETRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 74|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 74|{ \ 1293| 74| return std::make_shared(dr, pr); \ 1294| 74|} \ _ZN19WALLETRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 74|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 74|{ \ 1298| 74| doRecordCheck(dr); \ 1299| 74| xfrPacket(pr); \ 1300| 74|} \ _ZN19WALLETRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17TSIGRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 140|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 140|{ \ 1293| 140| return std::make_shared(dr, pr); \ 1294| 140|} \ _ZN17TSIGRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 140|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 140|{ \ 1298| 140| doRecordCheck(dr); \ 1299| 140| xfrPacket(pr); \ 1300| 140|} \ _ZN15MXRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 101|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 101|{ \ 1293| 101| return std::make_shared(dr, pr); \ 1294| 101|} \ _ZN15MXRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 101|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 101|{ \ 1298| 101| doRecordCheck(dr); \ 1299| 101| xfrPacket(pr); \ 1300| 101|} \ _ZN15MXRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15KXRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 107|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 107|{ \ 1293| 107| return std::make_shared(dr, pr); \ 1294| 107|} \ _ZN15KXRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 107|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 107|{ \ 1298| 107| doRecordCheck(dr); \ 1299| 107| xfrPacket(pr); \ 1300| 107|} \ _ZN15KXRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN21IPSECKEYRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 152|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 152|{ \ 1293| 152| return std::make_shared(dr, pr); \ 1294| 152|} \ _ZN21IPSECKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 152|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 152|{ \ 1298| 152| doRecordCheck(dr); \ 1299| 152| xfrPacket(pr); \ 1300| 152|} \ _ZN21IPSECKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18DHCIDRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 54|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 54|{ \ 1293| 54| return std::make_shared(dr, pr); \ 1294| 54|} \ _ZN18DHCIDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 54|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 54|{ \ 1298| 54| doRecordCheck(dr); \ 1299| 54| xfrPacket(pr); \ 1300| 54|} \ _ZN18DHCIDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18AFSDBRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 57|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 57|{ \ 1293| 57| return std::make_shared(dr, pr); \ 1294| 57|} \ _ZN18AFSDBRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 57|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 57|{ \ 1298| 57| doRecordCheck(dr); \ 1299| 57| xfrPacket(pr); \ 1300| 57|} \ _ZN18AFSDBRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18NAPTRRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 107|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 107|{ \ 1293| 107| return std::make_shared(dr, pr); \ 1294| 107|} \ _ZN18NAPTRRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 107|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 107|{ \ 1298| 107| doRecordCheck(dr); \ 1299| 107| xfrPacket(pr); \ 1300| 107|} \ _ZN18NAPTRRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16SRVRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 84|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 84|{ \ 1293| 84| return std::make_shared(dr, pr); \ 1294| 84|} \ _ZN16SRVRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 84|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 84|{ \ 1298| 84| doRecordCheck(dr); \ 1299| 84| xfrPacket(pr); \ 1300| 84|} \ _ZN16SRVRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16SOARecordContent4makeERK9DNSRecordR12PacketReader: 1291| 169|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 169|{ \ 1293| 169| return std::make_shared(dr, pr); \ 1294| 169|} \ _ZN16SOARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 169|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 169|{ \ 1298| 169| doRecordCheck(dr); \ 1299| 169| xfrPacket(pr); \ 1300| 169|} \ _ZN16SOARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16KEYRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 53|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 53|{ \ 1293| 53| return std::make_shared(dr, pr); \ 1294| 53|} \ _ZN16KEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 53|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 53|{ \ 1298| 53| doRecordCheck(dr); \ 1299| 53| xfrPacket(pr); \ 1300| 53|} \ _ZN16KEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN19ZONEMDRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 72|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 72|{ \ 1293| 72| return std::make_shared(dr, pr); \ 1294| 72|} \ _ZN19ZONEMDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 72|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 72|{ \ 1298| 72| doRecordCheck(dr); \ 1299| 72| xfrPacket(pr); \ 1300| 72|} \ _ZN19ZONEMDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17CERTRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 76|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 76|{ \ 1293| 76| return std::make_shared(dr, pr); \ 1294| 76|} \ _ZN17CERTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 76|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 76|{ \ 1298| 76| doRecordCheck(dr); \ 1299| 76| xfrPacket(pr); \ 1300| 76|} \ _ZN17CERTRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17TLSARecordContent4makeERK9DNSRecordR12PacketReader: 1291| 52|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 52|{ \ 1293| 52| return std::make_shared(dr, pr); \ 1294| 52|} \ _ZN17TLSARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 52|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 52|{ \ 1298| 52| doRecordCheck(dr); \ 1299| 52| xfrPacket(pr); \ 1300| 52|} \ _ZN17TLSARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN23OPENPGPKEYRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 55|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 55|{ \ 1293| 55| return std::make_shared(dr, pr); \ 1294| 55|} \ _ZN23OPENPGPKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 55|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 55|{ \ 1298| 55| doRecordCheck(dr); \ 1299| 55| xfrPacket(pr); \ 1300| 55|} \ _ZN23OPENPGPKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17SVCBRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 729|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 729|{ \ 1293| 729| return std::make_shared(dr, pr); \ 1294| 729|} \ _ZN17SVCBRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 729|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 729|{ \ 1298| 729| doRecordCheck(dr); \ 1299| 729| xfrPacket(pr); \ 1300| 729|} \ _ZN17SVCBRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18HTTPSRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 530|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 530|{ \ 1293| 530| return std::make_shared(dr, pr); \ 1294| 530|} \ _ZN18HTTPSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 530|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 530|{ \ 1298| 530| doRecordCheck(dr); \ 1299| 530| xfrPacket(pr); \ 1300| 530|} \ _ZN18HTTPSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17HHITRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 54|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 54|{ \ 1293| 54| return std::make_shared(dr, pr); \ 1294| 54|} \ _ZN17HHITRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 54|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 54|{ \ 1298| 54| doRecordCheck(dr); \ 1299| 54| xfrPacket(pr); \ 1300| 54|} \ _ZN17HHITRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17BRIDRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 42|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 42|{ \ 1293| 42| return std::make_shared(dr, pr); \ 1294| 42|} \ _ZN17BRIDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 42|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 42|{ \ 1298| 42| doRecordCheck(dr); \ 1299| 42| xfrPacket(pr); \ 1300| 42|} \ _ZN17BRIDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN19SMIMEARecordContent4makeERK9DNSRecordR12PacketReader: 1291| 61|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 61|{ \ 1293| 61| return std::make_shared(dr, pr); \ 1294| 61|} \ _ZN19SMIMEARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 61|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 61|{ \ 1298| 61| doRecordCheck(dr); \ 1299| 61| xfrPacket(pr); \ 1300| 61|} \ _ZN19SMIMEARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15DSRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 60|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 60|{ \ 1293| 60| return std::make_shared(dr, pr); \ 1294| 60|} \ _ZN15DSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 60|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 60|{ \ 1298| 60| doRecordCheck(dr); \ 1299| 60| xfrPacket(pr); \ 1300| 60|} \ _ZN15DSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16CDSRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 111|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 111|{ \ 1293| 111| return std::make_shared(dr, pr); \ 1294| 111|} \ _ZN16CDSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 111|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 111|{ \ 1298| 111| doRecordCheck(dr); \ 1299| 111| xfrPacket(pr); \ 1300| 111|} \ _ZN16CDSRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16DLVRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 74|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 74|{ \ 1293| 74| return std::make_shared(dr, pr); \ 1294| 74|} \ _ZN16DLVRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 74|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 74|{ \ 1298| 74| doRecordCheck(dr); \ 1299| 74| xfrPacket(pr); \ 1300| 74|} \ _ZN16DLVRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18SSHFPRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 69|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 69|{ \ 1293| 69| return std::make_shared(dr, pr); \ 1294| 69|} \ _ZN18SSHFPRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 69|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 69|{ \ 1298| 69| doRecordCheck(dr); \ 1299| 69| xfrPacket(pr); \ 1300| 69|} \ _ZN18SSHFPRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN18RRSIGRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 132|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 132|{ \ 1293| 132| return std::make_shared(dr, pr); \ 1294| 132|} \ _ZN18RRSIGRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 132|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 132|{ \ 1298| 132| doRecordCheck(dr); \ 1299| 132| xfrPacket(pr); \ 1300| 132|} \ _ZN18RRSIGRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN19DNSKEYRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 76|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 76|{ \ 1293| 76| return std::make_shared(dr, pr); \ 1294| 76|} \ _ZN19DNSKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 76|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 76|{ \ 1298| 76| doRecordCheck(dr); \ 1299| 76| xfrPacket(pr); \ 1300| 76|} \ _ZN19DNSKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN20CDNSKEYRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 49|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 49|{ \ 1293| 49| return std::make_shared(dr, pr); \ 1294| 49|} \ _ZN20CDNSKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 49|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 49|{ \ 1298| 49| doRecordCheck(dr); \ 1299| 49| xfrPacket(pr); \ 1300| 49|} \ _ZN20CDNSKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17RKEYRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 43|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 43|{ \ 1293| 43| return std::make_shared(dr, pr); \ 1294| 43|} \ _ZN17RKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 43|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 43|{ \ 1298| 43| doRecordCheck(dr); \ 1299| 43| xfrPacket(pr); \ 1300| 43|} \ _ZN17RKEYRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16NIDRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 72|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 72|{ \ 1293| 72| return std::make_shared(dr, pr); \ 1294| 72|} \ _ZN16NIDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 72|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 72|{ \ 1298| 72| doRecordCheck(dr); \ 1299| 72| xfrPacket(pr); \ 1300| 72|} \ _ZN16NIDRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16L32RecordContent4makeERK9DNSRecordR12PacketReader: 1291| 67|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 67|{ \ 1293| 67| return std::make_shared(dr, pr); \ 1294| 67|} \ _ZN16L32RecordContentC2ERK9DNSRecordR12PacketReader: 1296| 67|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 67|{ \ 1298| 67| doRecordCheck(dr); \ 1299| 67| xfrPacket(pr); \ 1300| 67|} \ _ZN16L32RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16L64RecordContent4makeERK9DNSRecordR12PacketReader: 1291| 75|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 75|{ \ 1293| 75| return std::make_shared(dr, pr); \ 1294| 75|} \ _ZN16L64RecordContentC2ERK9DNSRecordR12PacketReader: 1296| 75|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 75|{ \ 1298| 75| doRecordCheck(dr); \ 1299| 75| xfrPacket(pr); \ 1300| 75|} \ _ZN16L64RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN15LPRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 97|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 97|{ \ 1293| 97| return std::make_shared(dr, pr); \ 1294| 97|} \ _ZN15LPRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 97|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 97|{ \ 1298| 97| doRecordCheck(dr); \ 1299| 97| xfrPacket(pr); \ 1300| 97|} \ _ZN15LPRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN17TKEYRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 189|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 189|{ \ 1293| 189| return std::make_shared(dr, pr); \ 1294| 189|} \ _ZN17TKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 189|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 189|{ \ 1298| 189| doRecordCheck(dr); \ 1299| 189| xfrPacket(pr); \ 1300| 189|} \ _ZN16URIRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 183|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 183|{ \ 1293| 183| return std::make_shared(dr, pr); \ 1294| 183|} \ _ZN16URIRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 183|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 183|{ \ 1298| 183| doRecordCheck(dr); \ 1299| 183| xfrPacket(pr); \ 1300| 183|} \ _ZN16URIRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN16CAARecordContent4makeERK9DNSRecordR12PacketReader: 1291| 404|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 404|{ \ 1293| 404| return std::make_shared(dr, pr); \ 1294| 404|} \ _ZN16CAARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 404|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 404|{ \ 1298| 404| doRecordCheck(dr); \ 1299| 404| xfrPacket(pr); \ 1300| 404|} \ _ZN16CAARecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN20RESINFORecordContent4makeERK9DNSRecordR12PacketReader: 1291| 39|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 39|{ \ 1293| 39| return std::make_shared(dr, pr); \ 1294| 39|} \ _ZN20RESINFORecordContentC2ERK9DNSRecordR12PacketReader: 1296| 39|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 39|{ \ 1298| 39| doRecordCheck(dr); \ 1299| 39| xfrPacket(pr); \ 1300| 39|} \ _ZN20RESINFORecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 1312| 1|void RNAME##RecordContent::report(const ReportIsOnlyCallableByReportAllTypes& /* unused */) \ 1313| 1|{ \ 1314| 1| regist(1, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1315| 1| regist(254, QType::RNAME, &RNAME##RecordContent::make, &RNAME##RecordContent::make, #RNAME); \ 1316| 1|} \ _ZN14ARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 26|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 26|{ \ 1343| 26| CONV; \ 1344| 26| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 26] ------------------ 1345| 26|} \ _ZN17AAAARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 65|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 65|{ \ 1343| 65| CONV; \ 1344| 65| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 28, False: 37] ------------------ 1345| 65|} \ _ZN15NSRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 134|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 134|{ \ 1343| 134| CONV; \ 1344| 134| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 48, False: 86] ------------------ 1345| 134|} \ _ZN16PTRRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 89|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 89|{ \ 1343| 89| CONV; \ 1344| 89| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 26, False: 63] ------------------ 1345| 89|} \ _ZN18CNAMERecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 115|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 115|{ \ 1343| 115| CONV; \ 1344| 115| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 26, False: 89] ------------------ 1345| 115|} \ _ZN18ALIASRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 93|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 93|{ \ 1343| 93| CONV; \ 1344| 93| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 36, False: 57] ------------------ 1345| 93|} \ _ZN18DNAMERecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 85|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 85|{ \ 1343| 85| CONV; \ 1344| 85| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 60] ------------------ 1345| 85|} \ _ZN15MBRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 92|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 92|{ \ 1343| 92| CONV; \ 1344| 92| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 37, False: 55] ------------------ 1345| 92|} \ _ZN15MGRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 126|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 126|{ \ 1343| 126| CONV; \ 1344| 126| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 30, False: 96] ------------------ 1345| 126|} \ _ZN15MRRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 96|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 96|{ \ 1343| 96| CONV; \ 1344| 96| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 21, False: 75] ------------------ 1345| 96|} \ _ZN18MINFORecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 235|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 235|{ \ 1343| 235| CONV; \ 1344| 235| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 27, False: 208] ------------------ 1345| 235|} \ _ZN16TXTRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 56|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 56|{ \ 1343| 56| CONV; \ 1344| 56| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 56] ------------------ 1345| 56|} \ _ZN16ENTRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 1.04k|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 1.04k|{ \ 1343| 1.04k| CONV; \ 1344| 1.04k| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 1.04k] ------------------ 1345| 1.04k|} \ _ZN16SPFRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 54|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 54|{ \ 1343| 54| CONV; \ 1344| 54| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 54] ------------------ 1345| 54|} \ _ZN18HINFORecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 70|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 70|{ \ 1343| 70| CONV; \ 1344| 70| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 12, False: 58] ------------------ 1345| 70|} \ _ZN15RPRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 147|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 147|{ \ 1343| 147| CONV; \ 1344| 147| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 122] ------------------ 1345| 147|} \ _ZN16OPTRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 472|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 472|{ \ 1343| 472| CONV; \ 1344| 472| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 472] ------------------ 1345| 472|} \ _ZN19WALLETRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 74|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 74|{ \ 1343| 74| CONV; \ 1344| 74| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 74] ------------------ 1345| 74|} \ _ZN17TSIGRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 140|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 140|{ \ 1343| 384| CONV; \ ------------------ | Branch (1343:3): [True: 60, False: 80] | Branch (1343:3): [True: 44, False: 96] ------------------ 1344| 140| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 20, False: 120] ------------------ 1345| 140|} \ _ZN15MXRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 101|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 101|{ \ 1343| 101| CONV; \ 1344| 101| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 28, False: 73] ------------------ 1345| 101|} \ _ZN15KXRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 107|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 107|{ \ 1343| 107| CONV; \ 1344| 107| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 82] ------------------ 1345| 107|} \ _ZN21IPSECKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 152|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 152|{ \ 1343| 152| CONV; \ ------------------ | Branch (1343:3): [True: 5, False: 147] | Branch (1343:3): [True: 32, False: 120] | Branch (1343:3): [True: 16, False: 136] | Branch (1343:3): [True: 13, False: 139] | Branch (1343:3): [True: 82, False: 70] | Branch (1343:3): [True: 2, False: 127] | Branch (1343:3): [True: 12, False: 117] | Branch (1343:3): [True: 41, False: 88] | Branch (1343:3): [True: 74, False: 55] ------------------ 1344| 127| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 102] ------------------ 1345| 127|} \ _ZN18DHCIDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 54|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 54|{ \ 1343| 54| CONV; \ 1344| 54| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 54] ------------------ 1345| 54|} \ _ZN18AFSDBRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 57|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 57|{ \ 1343| 57| CONV; \ 1344| 57| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 3, False: 54] ------------------ 1345| 57|} \ _ZN18NAPTRRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 107|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 107|{ \ 1343| 107| CONV; \ 1344| 107| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 29, False: 78] ------------------ 1345| 107|} \ _ZN16SRVRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 84|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 84|{ \ 1343| 84| CONV; \ 1344| 84| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 59] ------------------ 1345| 84|} \ _ZN16SOARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 169|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 169|{ \ 1343| 169| CONV; \ 1344| 169| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 7, False: 162] ------------------ 1345| 169|} \ _ZN16KEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 53|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 53|{ \ 1343| 53| CONV; \ 1344| 53| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 53] ------------------ 1345| 53|} \ _ZN19ZONEMDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 72|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 72|{ \ 1343| 72| CONV; \ 1344| 72| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 72] ------------------ 1345| 72|} \ _ZN17CERTRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 76|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 76|{ \ 1343| 78| CONV; \ ------------------ | Branch (1343:3): [True: 2, False: 74] ------------------ 1344| 74| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 74] ------------------ 1345| 74|} \ _ZN17TLSARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 52|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 52|{ \ 1343| 52| CONV; \ 1344| 52| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 52] ------------------ 1345| 52|} \ _ZN23OPENPGPKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 55|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 55|{ \ 1343| 55| CONV; \ 1344| 55| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 55] ------------------ 1345| 55|} \ _ZN17SVCBRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 729|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 729|{ \ 1343| 1.35k| CONV; \ ------------------ | Branch (1343:3): [True: 625, False: 104] ------------------ 1344| 729| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 22, False: 707] ------------------ 1345| 729|} \ _ZN18HTTPSRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 530|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 530|{ \ 1343| 975| CONV; \ ------------------ | Branch (1343:3): [True: 445, False: 85] ------------------ 1344| 530| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 23, False: 507] ------------------ 1345| 530|} \ _ZN17HHITRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 54|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 54|{ \ 1343| 54| CONV; \ 1344| 54| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 54] ------------------ 1345| 54|} \ _ZN17BRIDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 42|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 42|{ \ 1343| 42| CONV; \ 1344| 42| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 42] ------------------ 1345| 42|} \ _ZN19SMIMEARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 61|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 61|{ \ 1343| 61| CONV; \ 1344| 61| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 61] ------------------ 1345| 61|} \ _ZN15DSRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 60|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 60|{ \ 1343| 60| CONV; \ 1344| 60| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 60] ------------------ 1345| 60|} \ _ZN16CDSRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 111|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 111|{ \ 1343| 111| CONV; \ 1344| 111| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 111] ------------------ 1345| 111|} \ _ZN16DLVRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 74|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 74|{ \ 1343| 74| CONV; \ 1344| 74| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 74] ------------------ 1345| 74|} \ _ZN18SSHFPRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 69|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 69|{ \ 1343| 69| CONV; \ 1344| 69| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 69] ------------------ 1345| 69|} \ _ZN18RRSIGRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 132|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 132|{ \ 1343| 132| CONV; \ 1344| 132| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 132] ------------------ 1345| 132|} \ _ZN19DNSKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 76|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 76|{ \ 1343| 76| CONV; \ 1344| 76| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 76] ------------------ 1345| 76|} \ _ZN20CDNSKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 49|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 49|{ \ 1343| 49| CONV; \ 1344| 49| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 49] ------------------ 1345| 49|} \ _ZN17RKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 43|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 43|{ \ 1343| 43| CONV; \ 1344| 43| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 43] ------------------ 1345| 43|} \ _ZN16NIDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 72|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 72|{ \ 1343| 72| CONV; \ 1344| 72| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 37, False: 35] ------------------ 1345| 72|} \ _ZN16L32RecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 67|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 67|{ \ 1343| 67| CONV; \ 1344| 67| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 28, False: 39] ------------------ 1345| 67|} \ _ZN16L64RecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 75|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 75|{ \ 1343| 75| CONV; \ 1344| 75| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 29, False: 46] ------------------ 1345| 75|} \ _ZN15LPRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 97|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 97|{ \ 1343| 97| CONV; \ 1344| 97| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 35, False: 62] ------------------ 1345| 97|} \ _ZN18EUI48RecordContentC2Ev: 1166| 61| EUI48RecordContent() = default; _ZN18EUI64RecordContentC2Ev: 1185| 44| EUI64RecordContent() = default; _ZN16APLRecordContentC2Ev: 1216| 222| APLRecordContent() = default; _ZN17TKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 189|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 189|{ \ 1343| 567| CONV; \ ------------------ | Branch (1343:3): [True: 102, False: 87] | Branch (1343:3): [True: 87, False: 102] ------------------ 1344| 189| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 28, False: 161] ------------------ 1345| 189|} \ _ZN16URIRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 183|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 183|{ \ 1343| 183| CONV; \ 1344| 183| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 183] ------------------ 1345| 183|} \ _ZN16CAARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 404|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 404|{ \ 1343| 404| CONV; \ 1344| 404| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 404] ------------------ 1345| 404|} \ _ZN20RESINFORecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 39|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 39|{ \ 1343| 39| CONV; \ 1344| 39| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 39] ------------------ 1345| 39|} \ _ZN10NSECBitmapC2Ev: 820| 870| NSECBitmap(): d_bitset(nullptr) 821| 870| { 822| 870| } _ZN10NSECBitmap3setEt: 851| 111k| { 852| 111k| if (!d_bitset) { ------------------ | Branch (852:9): [True: 100k, False: 11.6k] ------------------ 853| 100k| if (d_set.size() >= 200) { ------------------ | Branch (853:11): [True: 130, False: 100k] ------------------ 854| 130| migrateToBitSet(); 855| 130| } 856| 100k| } 857| 111k| if (d_bitset) { ------------------ | Branch (857:9): [True: 11.7k, False: 100k] ------------------ 858| 11.7k| d_bitset->set(type); 859| 11.7k| } 860| 100k| else { 861| 100k| d_set.insert(type); 862| 100k| } 863| 111k| } _ZN10NSECBitmap15migrateToBitSetEv: 891| 130| { 892| 130| d_bitset = std::make_unique>(); 893| 26.0k| for (const auto& type : d_set) { ------------------ | Branch (893:27): [True: 26.0k, False: 130] ------------------ 894| 26.0k| d_bitset->set(type); 895| 26.0k| } 896| 130| d_set.clear(); 897| 130| } _ZN17NSECRecordContentC2Ev: 911| 597| NSECRecordContent() = default; _ZN18NSEC3RecordContentC2Ev: 952| 175| NSEC3RecordContent() = default; _ZN23NSEC3PARAMRecordContentC2Ev: 1035| 71| NSEC3PARAMRecordContent() = default; _ZN18CSYNCRecordContentC2Ev: 1002| 98| CSYNCRecordContent() = default; _ZN16LOCRecordContentC2Ev: 1063| 81| LOCRecordContent() = default; _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEEC2ERS4_RK7DNSNametth: 43| 4.87k| d_qname(qname), d_content(content) 44| 4.87k|{ 45| 4.87k| d_content.clear(); 46| 4.87k| dnsheader dnsheader; 47| | 48| 4.87k| memset(&dnsheader, 0, sizeof(dnsheader)); 49| 4.87k| dnsheader.id=0; 50| 4.87k| dnsheader.qdcount=htons(1); 51| 4.87k| dnsheader.opcode=opcode; 52| | 53| 4.87k| const uint8_t* ptr=(const uint8_t*)&dnsheader; 54| 4.87k| d_content.reserve(sizeof(dnsheader) + qname.wirelength() + sizeof(qtype) + sizeof(qclass)); 55| 4.87k| d_content.resize(sizeof(dnsheader)); 56| 4.87k| uint8_t* dptr=(&*d_content.begin()); 57| | 58| 4.87k| memcpy(dptr, ptr, sizeof(dnsheader)); 59| 4.87k| d_namepositions.reserve(16); 60| 4.87k| xfrName(qname, false); 61| 4.87k| xfr16BitInt(qtype); 62| 4.87k| xfr16BitInt(qclass); 63| | 64| 4.87k| if (d_content.size() > std::numeric_limits::max()) { ------------------ | Branch (64:7): [True: 0, False: 4.87k] ------------------ 65| 0| throw std::range_error("Trying to build a packet larger than " + std::to_string(std::numeric_limits::max()) + " bytes"); 66| 0| } 67| 4.87k| d_truncatemarker = d_content.size(); 68| 4.87k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE11startRecordERK7DNSNametjtN17DNSResourceRecord5PlaceEb: 77| 13.0k|{ 78| 13.0k| d_compress = compress; 79| 13.0k| commit(); 80| 13.0k| if (d_content.size() > std::numeric_limits::max()) { ------------------ | Branch (80:7): [True: 0, False: 13.0k] ------------------ 81| 0| throw std::range_error("Trying to build a packet larger than " + std::to_string(std::numeric_limits::max()) + " bytes"); 82| 0| } 83| 13.0k| d_rollbackmarker = d_content.size(); 84| | 85| 13.0k| if (compress && !name.isRoot() && d_qname==name) { // don't do the whole label compression thing if we *know* we can get away with "see question" - except when compressing the root ------------------ | Branch (85:7): [True: 12.0k, False: 1.02k] | Branch (85:19): [True: 6.93k, False: 5.09k] | Branch (85:37): [True: 0, False: 6.93k] ------------------ 86| 0| static const std::array marker{0xc0, 0x0c}; 87| 0| d_content.insert(d_content.end(), reinterpret_cast(marker.begin()), reinterpret_cast(marker.end())); 88| 0| } 89| 13.0k| else { 90| 13.0k| xfrName(name, compress); 91| 13.0k| } 92| 13.0k| xfr16BitInt(qtype); 93| 13.0k| xfr16BitInt(qclass); 94| 13.0k| xfr32BitInt(ttl); 95| 13.0k| xfr16BitInt(0); // this will be the record size 96| 13.0k| d_recordplace = place; 97| | 98| 13.0k| d_sor = d_content.size(); // this will remind us where to stuff the record size 99| 13.0k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE6addOptEtttRKNS1_INS0_4pairItNS0_12basic_stringIcNS0_11char_traitsIcEENS2_IcEEEEEENS2_ISC_EEEEh: 102| 1.02k|{ 103| 1.02k| uint32_t ttl=0; 104| | 105| 1.02k| EDNS0Record stuff; 106| | 107| 1.02k| stuff.version = version; 108| 1.02k| stuff.extFlags = htons(ednsFlags); 109| | 110| | /* RFC 6891 section 4 on the Extended RCode wire format 111| | * EXTENDED-RCODE 112| | * Forms the upper 8 bits of extended 12-bit RCODE (together with the 113| | * 4 bits defined in [RFC1035]. Note that EXTENDED-RCODE value 0 114| | * indicates that an unextended RCODE is in use (values 0 through 15). 115| | */ 116| | // XXX Should be check for extRCode > 1<<12 ? 117| 1.02k| stuff.extRCode = extRCode>>4; 118| 1.02k| if (extRCode != 0) { // As this trumps the existing RCODE ------------------ | Branch (118:7): [True: 0, False: 1.02k] ------------------ 119| 0| getHeader()->rcode = extRCode; 120| 0| } 121| | 122| 1.02k| static_assert(sizeof(EDNS0Record) == sizeof(ttl), "sizeof(EDNS0Record) must match sizeof(ttl)"); 123| 1.02k| memcpy(&ttl, &stuff, sizeof(stuff)); 124| | 125| 1.02k| ttl=ntohl(ttl); // will be reversed later on 126| | 127| 1.02k| startRecord(g_rootdnsname, QType::OPT, ttl, udpsize, DNSResourceRecord::ADDITIONAL, false); 128| 33.6k| for(auto const &option : options) { ------------------ | Branch (128:26): [True: 33.6k, False: 1.02k] ------------------ 129| 33.6k| xfr16BitInt(option.first); 130| 33.6k| xfr16BitInt(option.second.length()); 131| 33.6k| xfrBlob(option.second); 132| 33.6k| } 133| 1.02k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE6commitEv: 572| 17.9k|{ 573| 17.9k| if (d_sor == 0) { ------------------ | Branch (573:7): [True: 4.87k, False: 13.0k] ------------------ 574| 4.87k| return; 575| 4.87k| } 576| | 577| 13.0k| if (d_sor < 2 || d_sor > d_content.size()) { ------------------ | Branch (577:7): [True: 0, False: 13.0k] | Branch (577:20): [True: 0, False: 13.0k] ------------------ 578| 0| throw std::range_error("Invalid start of record when trying to build a packet: " + std::to_string(d_sor) + " / " + std::to_string(d_content.size())); 579| 0| } 580| | 581| 13.0k| if (d_content.size() > std::numeric_limits::max()) { ------------------ | Branch (581:7): [True: 56, False: 12.9k] ------------------ 582| 56| throw std::range_error("Trying to build a packet larger than " + std::to_string(std::numeric_limits::max()) + " bytes"); 583| 56| } 584| | 585| 12.9k| uint16_t rlen = d_content.size() - d_sor; 586| 12.9k| d_content.at(d_sor-2) = rlen >> 8; 587| 12.9k| d_content.at(d_sor-1) = rlen & 0xff; 588| 12.9k| d_sor = 0; 589| 12.9k| auto* dh = reinterpret_cast( &*d_content.begin()); 590| 12.9k| switch(d_recordplace) { ------------------ | Branch (590:10): [True: 12.9k, False: 0] ------------------ 591| 0| case DNSResourceRecord::QUESTION: ------------------ | Branch (591:3): [True: 0, False: 12.9k] ------------------ 592| 0| dh->qdcount = htons(ntohs(dh->qdcount) + 1); 593| 0| break; 594| 12.0k| case DNSResourceRecord::ANSWER: ------------------ | Branch (594:3): [True: 12.0k, False: 971] ------------------ 595| 12.0k| dh->ancount = htons(ntohs(dh->ancount) + 1); 596| 12.0k| break; 597| 0| case DNSResourceRecord::AUTHORITY: ------------------ | Branch (597:3): [True: 0, False: 12.9k] ------------------ 598| 0| dh->nscount = htons(ntohs(dh->nscount) + 1); 599| 0| break; 600| 971| case DNSResourceRecord::ADDITIONAL: ------------------ | Branch (600:3): [True: 971, False: 12.0k] ------------------ 601| 971| dh->arcount = htons(ntohs(dh->arcount) + 1); 602| 971| break; 603| 12.9k| } 604| | 605| 12.9k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE11xfr32BitIntEm: 155| 13.0k|{ 156| 13.0k| if (val > std::numeric_limits::max()) { ------------------ | Branch (156:7): [True: 0, False: 13.0k] ------------------ 157| 0| throw runtime_error("Value too large to fit in 32 bits"); 158| 0| } 159| 13.0k| uint32_t rval=htonl(static_cast(val)); 160| 13.0k| uint8_t* ptr=reinterpret_cast(&rval); 161| 13.0k| d_content.insert(d_content.end(), ptr, ptr+4); 162| 13.0k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE11xfr16BitIntEm: 165| 116k|{ 166| 116k| if (val > std::numeric_limits::max()) { ------------------ | Branch (166:7): [True: 0, False: 116k] ------------------ 167| 0| throw runtime_error("Value too large to fit in 16 bits"); 168| 0| } 169| 116k| uint16_t rval=htons(static_cast(val)); 170| 116k| uint8_t* ptr=reinterpret_cast(&rval); 171| 116k| d_content.insert(d_content.end(), ptr, ptr+2); 172| 116k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE7xfrNameERK7DNSNameb: 395| 17.9k|{ 396| 17.9k| if(l_verbose) ------------------ | Branch (396:6): [Folded, False: 17.9k] ------------------ 397| 0| cout<<"Wants to write "<> 8)); 428| 3.43k| d_content.push_back((char)(offset & 0xff)); 429| 3.43k| } 430| 3.49k| else { 431| 3.49k| unsigned int pos=d_content.size(); 432| 3.49k| if(l_verbose) ------------------ | Branch (432:8): [Folded, False: 3.49k] ------------------ 433| 0| cout<<"Found nothing, we are at pos "< lc; 441| 3.49k| if(d_lowerCase) ------------------ | Branch (441:8): [True: 0, False: 3.49k] ------------------ 442| 0| lc = make_unique(name.makeLowerCase()); 443| | 444| 3.49k| const DNSName::string_t& raw = (lc ? *lc : name).getStorage(); ------------------ | Branch (444:37): [True: 0, False: 3.49k] ------------------ 445| 3.49k| if(l_verbose) ------------------ | Branch (445:8): [Folded, False: 3.49k] ------------------ 446| 0| cout<<"Writing out the whole thing "<(blob.c_str()); 454| 45.7k| d_content.insert(d_content.end(), ptr, ptr+blob.size()); 455| 45.7k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE10lookupNameERK7DNSNamePt: 229| 6.93k|{ 230| | // iterate over the written labels, see if we find a match 231| 6.93k| const auto& raw = name.getStorage(); 232| | 233| | /* name might be a.root-servers.net, we need to be able to benefit from finding: 234| | b.root-servers.net, or even: 235| | b\xc0\x0c 236| | */ 237| 6.93k| unsigned int bestpos=0; 238| 6.93k| *matchLen = 0; 239| | 240| | // positions of each label in the name we are trying to compress 241| 6.93k| boost::container::static_vector positionsInName; 242| | // positions of labels in the packet we are building 243| 6.93k| boost::container::static_vector positionsInPacket; 244| | 245| 6.93k| try { 246| 25.2k| for(auto riter= raw.cbegin(); riter < raw.cend(); ) { ------------------ | Branch (246:35): [True: 25.2k, False: 0] ------------------ 247| 25.2k| if (*riter == 0) { ------------------ | Branch (247:11): [True: 6.93k, False: 18.3k] ------------------ 248| 6.93k| break; 249| 6.93k| } 250| 18.3k| positionsInName.push_back(riter - raw.cbegin()); 251| 18.3k| riter += *riter + 1; 252| 18.3k| } 253| 6.93k| } 254| 6.93k| catch (const std::bad_alloc& ba) { 255| 0| if (l_verbose) { ------------------ | Branch (255:9): [Folded, False: 0] ------------------ 256| 0| cout << "Domain " << name << " too large to compress" << endl; 257| 0| } 258| 0| return 0; 259| 0| } 260| | 261| 6.93k| if (l_verbose) { ------------------ | Branch (261:7): [Folded, False: 6.93k] ------------------ 262| 0| cout<<"Input vector for lookup "<(d_content.data()), d_content.size(), positionInPacket, true); // only for debugging 287| 0| cout<<"Looking at '"< 0;) { ------------------ | Branch (294:63): [True: 23.2k, False: 0] | Branch (294:63): [True: 23.2k, False: 0] | Branch (294:90): [True: 23.2k, False: 0] ------------------ 295| 23.2k| uint8_t labelLength = *iter; 296| 23.2k| const uint16_t currentPos = (iter - d_content.cbegin()); 297| 23.2k| if (l_verbose) { ------------------ | Branch (297:13): [Folded, False: 23.2k] ------------------ 298| 0| cout << "Found label length: " << std::to_string(labelLength) << " at " << currentPos << endl; 299| 0| } 300| 23.2k| if (labelLength & 0xc0) { ------------------ | Branch (300:13): [True: 2.45k, False: 20.7k] ------------------ 301| 2.45k| uint16_t npos = 0x100*(labelLength & (~0xc0)) + *++iter; 302| | // check against going forward 303| 2.45k| if (npos >= currentPos || npos < sizeof(dnsheader)) { ------------------ | Branch (303:15): [True: 0, False: 2.45k] | Branch (303:37): [True: 0, False: 2.45k] ------------------ 304| | /* something is not right */ 305| 0| break; 306| 0| } 307| | 308| | // jump to the target of the pointer 309| 2.45k| iter = d_content.begin() + npos; 310| 2.45k| if (l_verbose) { ------------------ | Branch (310:15): [Folded, False: 2.45k] ------------------ 311| 0| cout << "Is compressed label to newpos " << npos << ", going there" << endl; 312| 0| } 313| | 314| 2.45k| if (pointerQuota >= 1) { ------------------ | Branch (314:15): [True: 2.45k, False: 0] ------------------ 315| 2.45k| pointerQuota--; 316| 2.45k| continue; 317| 2.45k| } 318| | 319| | // out of pointer quota, let's stop there 320| 0| break; 321| 2.45k| } 322| | 323| 20.7k| if (labelLength == 0) { ------------------ | Branch (323:13): [True: 5.54k, False: 15.2k] ------------------ 324| 5.54k| break; 325| 5.54k| } 326| | 327| 15.2k| if (currentPos >= maxCompressionOffset) { ------------------ | Branch (327:13): [True: 27, False: 15.2k] ------------------ 328| 27| break; // compression pointers cannot point here 329| 27| } 330| | 331| 15.2k| positionsInPacket.push_back(currentPos); 332| | // jump to the next label 333| 15.2k| iter += labelLength + 1; 334| 15.2k| } 335| 5.56k| } 336| 5.56k| catch (const std::bad_alloc& ba) { 337| 0| if (l_verbose) { ------------------ | Branch (337:11): [Folded, False: 0] ------------------ 338| 0| cout << "Domain " << name << " too large to compress" << endl; 339| 0| } 340| 0| continue; 341| 0| } 342| | 343| 5.56k| if (l_verbose) { ------------------ | Branch (343:9): [Folded, False: 5.56k] ------------------ 344| 0| cout<<"Packet vector: "< len) { ------------------ | Branch (169:7): [True: 3.69k, False: 1.19k] ------------------ 170| 3.69k| return EINVAL; 171| 3.69k| } 172| | 173| 27.7k| while (len >= (pos + EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE) && rdLen >= (rdPos + EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE)) { ------------------ | Branch (173:10): [True: 27.7k, False: 79] | Branch (173:76): [True: 27.3k, False: 321] ------------------ 174| 27.3k| const uint16_t optionCode = (((unsigned char)optRR[pos]) * 256) + ((unsigned char)optRR[pos + 1]); 175| 27.3k| pos += EDNS_OPTION_CODE_SIZE; 176| 27.3k| rdPos += EDNS_OPTION_CODE_SIZE; 177| 27.3k| const uint16_t optionLen = (((unsigned char)optRR[pos]) * 256) + ((unsigned char)optRR[pos + 1]); 178| 27.3k| pos += EDNS_OPTION_LENGTH_SIZE; 179| 27.3k| rdPos += EDNS_OPTION_LENGTH_SIZE; 180| 27.3k| if (optionLen > (rdLen - rdPos) || optionLen > (len - pos)) { ------------------ | Branch (180:9): [True: 798, False: 26.5k] | Branch (180:40): [True: 0, False: 26.5k] ------------------ 181| 798| return EINVAL; 182| 798| } 183| 26.5k| EDNSOptionViewValue value; 184| 26.5k| value.content = optRR + pos; 185| 26.5k| value.size = optionLen; 186| 26.5k| options[optionCode].values.push_back(value); 187| | 188| | /* skip this option */ 189| 26.5k| pos += optionLen; 190| 26.5k| rdPos += optionLen; 191| 26.5k| } 192| | 193| 400| return 0; 194| 1.19k|} _Z25getEDNSOptionsFromContentRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_6vectorINS_4pairItS5_EENS3_ISA_EEEE: 197| 4.89k|{ 198| 4.89k| size_t pos = 0; 199| 4.89k| const size_t contentLength = content.size(); 200| | 201| 41.6k| while (pos < contentLength && (contentLength - pos) >= (EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE)) { ------------------ | Branch (201:10): [True: 41.4k, False: 183] | Branch (201:33): [True: 41.2k, False: 187] ------------------ 202| 41.2k| uint16_t code = (static_cast(content.at(pos)) * 256) + static_cast(content.at(pos + 1)); 203| 41.2k| pos += EDNS_OPTION_CODE_SIZE; 204| 41.2k| uint16_t len = (static_cast(content.at(pos)) * 256) + static_cast(content.at(pos + 1)); 205| 41.2k| pos += EDNS_OPTION_LENGTH_SIZE; 206| | 207| 41.2k| if (pos > contentLength || len > (contentLength - pos)) { ------------------ | Branch (207:9): [True: 0, False: 41.2k] | Branch (207:32): [True: 4.52k, False: 36.7k] ------------------ 208| 4.52k| return false; 209| 4.52k| } 210| | 211| 36.7k| options.emplace_back(code, std::string(&content.at(pos), len)); 212| 36.7k| pos += len; 213| 36.7k| } 214| | 215| 370| return true; 216| 4.89k|} LLVMFuzzerTestOneInput: 46| 4.89k|{ 47| 4.89k| static bool initialized = false; 48| | 49| 4.89k| if (!initialized) { ------------------ | Branch (49:7): [True: 1, False: 4.89k] ------------------ 50| 1| init(); 51| 1| initialized = true; 52| 1| } 53| | 54| 4.89k| if (size > std::numeric_limits::max()) { ------------------ | Branch (54:7): [True: 2, False: 4.89k] ------------------ 55| 2| return 0; 56| 2| } 57| | 58| | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 59| 4.89k| const char* chars = reinterpret_cast(data); 60| | 61| 4.89k| try { 62| | // 1) Feed the raw, untrusted bytes straight to the EDNS OPT option parsers: 63| | // the option TLV decoder in ednsoptions.cc is otherwise unreached. 64| 4.89k| EDNSOptionViewMap viewOptions; 65| 4.89k| (void)getEDNSOptions(chars, size, viewOptions); 66| | 67| 4.89k| std::vector> options; 68| 4.89k| (void)getEDNSOptionsFromContent(std::string(chars, size), options); 69| | 70| | // 2) Drive DNSPacketWriter with attacker-controlled structures (several 71| | // records, attacker rdata, name compression, EDNS OPT writing), the 72| | // full-packet writer paths that the parse/record fuzzers never reach. 73| 4.89k| size_t pos = 0; 74| | // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) 75| 4.89k| const auto getU8 = [&]() -> uint8_t { return pos < size ? data[pos++] : 0; }; 76| 4.89k| const auto getU16 = [&]() -> uint16_t { 77| 4.89k| const uint16_t highV = getU8(); 78| 4.89k| return static_cast((highV << 8) | getU8()); 79| 4.89k| }; 80| | 81| 4.89k| const uint16_t qtype = getU16(); 82| 4.89k| const DNSName qname("."); 83| 4.89k| std::vector packet; 84| 4.89k| DNSPacketWriter writer(packet, qname, qtype); 85| | 86| 4.89k| static const std::array suffixes{".", "example.com.", "a.example.com.", "powerdns.com."}; 87| | 88| 4.89k| const unsigned int records = getU8() % 8U; 89| 16.9k| for (unsigned int i = 0; i < records && pos < size; ++i) { ------------------ | Branch (89:30): [True: 15.7k, False: 1.18k] | Branch (89:45): [True: 12.0k, False: 3.70k] ------------------ 90| | // A valid name sharing one of a few suffixes (so the name-compression 91| | // paths fire) with an attacker-controlled first label. 92| 12.0k| const uint8_t labelLen = getU8() % 32U; 93| 12.0k| std::string label; 94| 47.6k| for (uint8_t j = 0; j < labelLen && pos < size; ++j) { ------------------ | Branch (94:27): [True: 35.9k, False: 11.7k] | Branch (94:43): [True: 35.6k, False: 327] ------------------ 95| 35.6k| label.push_back(static_cast('a' + (getU8() % 26))); 96| 35.6k| } 97| 12.0k| const std::string suffix = suffixes.at(getU8() % suffixes.size()); 98| 12.0k| DNSName name{}; 99| 12.0k| try { 100| 12.0k| if (label.empty()) { ------------------ | Branch (100:13): [True: 8.90k, False: 3.12k] ------------------ 101| 8.90k| name = DNSName(suffix); 102| 8.90k| } 103| 3.12k| else { 104| 3.12k| label.append("."); 105| 3.12k| label.append(suffix); 106| 3.12k| name = DNSName(label); 107| 3.12k| } 108| 12.0k| } 109| 12.0k| catch (...) { 110| 808| name = qname; 111| 808| } 112| | 113| 12.0k| const uint16_t rtype = getU16(); 114| 12.0k| const uint16_t rdlen = getU16(); 115| 12.0k| std::string rdata; 116| 13.9M| for (uint16_t j = 0; j < rdlen && pos < size; ++j) { ------------------ | Branch (116:28): [True: 13.9M, False: 9.04k] | Branch (116:41): [True: 13.9M, False: 2.98k] ------------------ 117| 13.9M| rdata.push_back(static_cast(getU8())); 118| 13.9M| } 119| | 120| 12.0k| writer.startRecord(name, rtype); 121| 12.0k| writer.xfrBlob(rdata); 122| 12.0k| } 123| | 124| | // EDNS OPT writing fed with the attacker-parsed option vector. 125| 4.89k| if (!options.empty()) { ------------------ | Branch (125:9): [True: 1.02k, False: 3.86k] ------------------ 126| 1.02k| DNSPacketWriter::optvect_t optvect; 127| 33.9k| for (const auto& option : options) { ------------------ | Branch (127:31): [True: 33.9k, False: 1.02k] ------------------ 128| 33.9k| optvect.emplace_back(option.first, option.second); 129| 33.9k| } 130| 1.02k| writer.addOpt(1232, 0, 0, optvect); 131| 1.02k| } 132| 4.89k| writer.commit(); 133| | 134| | // Re-parse the writer's own output. 135| 4.89k| if (!packet.empty()) { ------------------ | Branch (135:9): [True: 4.81k, False: 73] ------------------ 136| | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 137| 4.81k| MOADNSParser reparse(false, reinterpret_cast(packet.data()), packet.size()); 138| 4.81k| } 139| 4.89k| } 140| | // NOLINTNEXTLINE(bugprone-empty-catch) 141| 4.89k| catch (const std::exception& e) { 142| 2.68k| } 143| | // NOLINTNEXTLINE(bugprone-empty-catch) 144| 4.89k| catch (const PDNSException& e) { 145| 0| } 146| | 147| 4.89k| return 0; 148| 4.89k|} fuzz_dnspacketroundtrip.cc:_ZL4initv: 39| 1|{ 40| 1| reportAllTypes(); 41| 1|} fuzz_dnspacketroundtrip.cc:_ZZ22LLVMFuzzerTestOneInputENK3$_1clEv: 76| 28.9k| const auto getU16 = [&]() -> uint16_t { 77| 28.9k| const uint16_t highV = getU8(); 78| 28.9k| return static_cast((highV << 8) | getU8()); 79| 28.9k| }; fuzz_dnspacketroundtrip.cc:_ZZ22LLVMFuzzerTestOneInputENK3$_0clEv: 75| 14.0M| const auto getU8 = [&]() -> uint8_t { return pos < size ? data[pos++] : 0; }; ------------------ | Branch (75:50): [True: 14.0M, False: 5.21k] ------------------ _ZN12ComboAddressC2Ev: 212| 30.5k| { 213| | sin4.sin_family = AF_INET; 214| 30.5k| sin4.sin_addr.s_addr = 0; 215| 30.5k| sin4.sin_port = 0; 216| 30.5k| sin6.sin6_scope_id = 0; 217| 30.5k| sin6.sin6_flowinfo = 0; 218| 30.5k| } _ZNK12ComboAddress6isIPv6Ev: 263| 1.70k| { 264| | return sin4.sin_family == AF_INET6; 265| 1.70k| } _ZNK12ComboAddress6isIPv4Ev: 267| 13.5k| { 268| | return sin4.sin_family == AF_INET; 269| 13.5k| } _Z23makeComboAddressFromRawhPKcm: 659| 15.2k|{ 660| 15.2k| ComboAddress address; 661| | 662| 15.2k| if (version == 4) { ------------------ | Branch (662:7): [True: 13.5k, False: 1.70k] ------------------ 663| 13.5k| address.sin4.sin_family = AF_INET; 664| 13.5k| if (len != sizeof(address.sin4.sin_addr)) { ------------------ | Branch (664:9): [True: 0, False: 13.5k] ------------------ 665| 0| throw NetmaskException("invalid raw address length"); 666| 0| } 667| 13.5k| memcpy(&address.sin4.sin_addr, raw, sizeof(address.sin4.sin_addr)); 668| 13.5k| } 669| 1.70k| else if (version == 6) { ------------------ | Branch (669:12): [True: 1.70k, False: 0] ------------------ 670| 1.70k| address.sin6.sin6_family = AF_INET6; 671| 1.70k| if (len != sizeof(address.sin6.sin6_addr)) { ------------------ | Branch (671:9): [True: 0, False: 1.70k] ------------------ 672| 0| throw NetmaskException("invalid raw address length"); 673| 0| } 674| 1.70k| memcpy(&address.sin6.sin6_addr, raw, sizeof(address.sin6.sin6_addr)); 675| 1.70k| } 676| 0| else { 677| 0| throw NetmaskException("invalid address family"); 678| 0| } 679| | 680| 15.2k| return address; 681| 15.2k|} _Z23makeComboAddressFromRawhRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 684| 15.2k|{ 685| 15.2k| return makeComboAddressFromRaw(version, str.c_str(), str.size()); 686| 15.2k|} _Z11makeHexDumpRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEES7_: 551| 730|{ 552| 730| std::array tmp{}; 553| 730| string ret; 554| 730| ret.reserve(static_cast(str.size() * (2 + sep.size()))); 555| | 556| 3.16M| for (char index : str) { ------------------ | Branch (556:19): [True: 3.16M, False: 730] ------------------ 557| 3.16M| snprintf(tmp.data(), tmp.size(), "%02x", static_cast(index)); 558| 3.16M| ret += tmp.data(); 559| 3.16M| ret += sep; 560| 3.16M| } 561| 730| return ret; 562| 730|} _ZN10NSECBitmap10fromPacketER12PacketReader: 99| 803|{ 100| 803| string bitmap; 101| 803| pr.xfrBlob(bitmap); 102| | 103| | // 00 06 20 00 00 00 00 03 -> NS RRSIG NSEC ( 2, 46, 47 ) counts from left 104| 803| if(bitmap.empty()) { ------------------ | Branch (104:6): [True: 270, False: 533] ------------------ 105| 270| return; 106| 270| } 107| | 108| 533| if(bitmap.size() < 2) { ------------------ | Branch (108:6): [True: 6, False: 527] ------------------ 109| 6| throw MOADNSException("NSEC record with impossibly small bitmap"); 110| 6| } 111| | 112| 42.9k| for(unsigned int n = 0; n+1 < bitmap.size();) { ------------------ | Branch (112:27): [True: 42.6k, False: 337] ------------------ 113| 42.6k| uint8_t window=static_cast(bitmap[n++]); 114| 42.6k| uint8_t blen=static_cast(bitmap[n++]); 115| | 116| | // end if zero padding and ensure packet length 117| 42.6k| if (window == 0 && blen == 0) { ------------------ | Branch (117:9): [True: 2.25k, False: 40.3k] | Branch (117:24): [True: 103, False: 2.14k] ------------------ 118| 103| break; 119| 103| } 120| | 121| 42.5k| if (blen > 32) { ------------------ | Branch (121:9): [True: 59, False: 42.4k] ------------------ 122| 59| throw MOADNSException("NSEC record with invalid bitmap length"); 123| 59| } 124| | 125| 42.4k| if (n + blen > bitmap.size()) { ------------------ | Branch (125:9): [True: 28, False: 42.4k] ------------------ 126| 28| throw MOADNSException("NSEC record with bitmap length > packet length"); 127| 28| } 128| | 129| 107k| for(unsigned int k=0; k < blen; k++) { ------------------ | Branch (129:27): [True: 65.2k, False: 42.4k] ------------------ 130| 65.2k| uint8_t val=bitmap[n++]; 131| 587k| for(int bit = 0; bit < 8 ; ++bit , val>>=1) { ------------------ | Branch (131:24): [True: 521k, False: 65.2k] ------------------ 132| 521k| if(val & 1) { ------------------ | Branch (132:12): [True: 111k, False: 410k] ------------------ 133| 111k| set((7-bit) + 8*(k) + 256*window); 134| 111k| } 135| 521k| } 136| 65.2k| } 137| 42.4k| } 138| 527|} _ZN17NSECRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 168| 1|{ 169| 1| regist(1, 47, &make, &make, "NSEC"); 170| 1|} _ZN17NSECRecordContent4makeERK9DNSRecordR12PacketReader: 196| 597|{ 197| 597| auto ret=std::make_shared(); 198| 597| pr.xfrName(ret->d_next); 199| | 200| 597| ret->d_bitmap.fromPacket(pr); 201| 597| if (!pr.eof()) { ------------------ | Branch (201:7): [True: 0, False: 597] ------------------ 202| 0| throw MOADNSException("When parsing NSEC trailing data was not parsed: '" + pr.getRemaining() + "'"); 203| 0| } 204| | 205| 597| return ret; 206| 597|} _ZN18NSEC3RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 220| 1|{ 221| 1| regist(1, 50, &make, &make, "NSEC3"); 222| 1|} _ZN18NSEC3RecordContent4makeERK9DNSRecordR12PacketReader: 261| 175|{ 262| 175| auto ret=std::make_shared(); 263| 175| pr.xfr8BitInt(ret->d_algorithm); 264| 175| pr.xfr8BitInt(ret->d_flags); 265| 175| pr.xfr16BitInt(ret->d_iterations); 266| 175| uint8_t len; 267| 175| pr.xfr8BitInt(len); 268| 175| pr.xfrBlob(ret->d_salt, len); 269| | 270| 175| pr.xfr8BitInt(len); 271| 175| pr.xfrBlob(ret->d_nexthash, len); 272| | 273| 175| ret->d_bitmap.fromPacket(pr); 274| 175| if (!pr.eof()) { ------------------ | Branch (274:7): [True: 0, False: 175] ------------------ 275| 0| throw MOADNSException("When parsing NSEC3 trailing data was not parsed: '" + pr.getRemaining() + "'"); 276| 0| } 277| 175| return ret; 278| 175|} _ZN23NSEC3PARAMRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 296| 1|{ 297| 1| regist(1, 51, &make, &make, "NSEC3PARAM"); 298| 1| regist(254, 51, &make, &make, "NSEC3PARAM"); 299| 1|} _ZN23NSEC3PARAMRecordContent4makeERK9DNSRecordR12PacketReader: 326| 71|{ 327| 71| auto ret=std::make_shared(); 328| 71| pr.xfr8BitInt(ret->d_algorithm); 329| 71| pr.xfr8BitInt(ret->d_flags); 330| 71| pr.xfr16BitInt(ret->d_iterations); 331| 71| uint8_t len; 332| 71| pr.xfr8BitInt(len); 333| 71| pr.xfrHexBlob(ret->d_salt, len); 334| 71| return ret; 335| 71|} _ZN18CSYNCRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 353| 1|{ 354| 1| regist(1, 62, &make, &make, "CSYNC"); 355| 1|} _ZN18CSYNCRecordContent4makeERK9DNSRecordR12PacketReader: 384| 98|{ 385| 98| auto ret=std::make_shared(); 386| 98| pr.xfr32BitInt(ret->d_serial); 387| 98| pr.xfr16BitInt(ret->d_flags); 388| | 389| 98| ret->d_bitmap.fromPacket(pr); 390| 98| if (!pr.eof()) { ------------------ | Branch (390:7): [True: 0, False: 98] ------------------ 391| 0| throw MOADNSException("When parsing CSYNC trailing data was not parsed: '" + pr.getRemaining() + "'"); 392| 0| } 393| 98| return ret; 394| 98|} qtype.cc:_ZL12swapElementsRKNSt3__13mapIKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEtNS_4lessIS7_EENS4_INS_4pairIS7_tEEEEEE: 103| 2|{ 104| 2| std::map ret; 105| | 106| 138| for (const auto& name : names) { ------------------ | Branch (106:25): [True: 138, False: 2] ------------------ 107| 138| ret.emplace(name.second, name.first); 108| 138| } 109| 2| return ret; 110| 2|} _ZNK6QClasscvtEv: 201| 28.3k| { 202| 28.3k| return qclass; 203| 28.3k| } _ZN16LOCRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 202| 1|{ 203| 1| regist(1, QType::LOC, &make, &make, "LOC"); 204| 1| regist(254, QType::LOC, &make, &make, "LOC"); 205| 1|} _ZN16LOCRecordContent4makeERK9DNSRecordR12PacketReader: 226| 81|{ 227| 81| auto ret=std::make_shared(); 228| 81| pr.xfr8BitInt(ret->d_version); 229| 81| pr.xfr8BitInt(ret->d_size); 230| 81| pr.xfr8BitInt(ret->d_horizpre); 231| 81| pr.xfr8BitInt(ret->d_vertpre); 232| | 233| 81| pr.xfr32BitInt(ret->d_latitude); 234| 81| pr.xfr32BitInt(ret->d_longitude); 235| 81| pr.xfr32BitInt(ret->d_altitude); 236| 81| if (!pr.eof()) { ------------------ | Branch (236:7): [True: 25, False: 56] ------------------ 237| 25| throw MOADNSException("When parsing LOC trailing data was not parsed: '" + pr.getRemaining() + "'"); 238| 25| } 239| | 240| 56| return ret; 241| 81|} _ZN7StatBagC2Ev: 40| 2|{ 41| 2| d_doRings=false; 42| 2| d_allowRedeclare=false; 43| 2|} _ZN8SvcParam11keyToStringERKNS_11SvcParamKeyE: 64| 10|{ 65| 10| auto ret = std::find_if(SvcParams.begin(), SvcParams.end(), [&](const std::pair& e) { return e.second == k; }); 66| 10| if (ret != SvcParams.end()) { ------------------ | Branch (66:7): [True: 10, False: 0] ------------------ 67| 10| return ret->first; 68| 10| } 69| 0| return "key" + std::to_string(k); 70| 10|} _ZN8SvcParamC2ERKNS_11SvcParamKeyE: 73| 49|{ 74| 49| d_key = key; 75| 49| if (d_key != SvcParamKey::no_default_alpn && d_key != SvcParamKey::ohttp) { ------------------ | Branch (75:7): [True: 19, False: 30] | Branch (75:48): [True: 0, False: 19] ------------------ 76| 0| throw std::invalid_argument("can not create non-empty SvcParam for key '" + keyToString(key) + "'"); 77| 0| } 78| 49|} _ZN8SvcParamC2ERKNS_11SvcParamKeyERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 81| 393|{ 82| 393| d_key = key; 83| 393| if (d_key != SvcParamKey::ech && d_key != SvcParamKey::dohpath && d_key < 10) { ------------------ | Branch (83:7): [True: 359, False: 34] | Branch (83:36): [True: 347, False: 12] | Branch (83:69): [True: 0, False: 347] ------------------ 84| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string value"); 85| 0| } 86| 393| if (d_key == SvcParamKey::ech) { ------------------ | Branch (86:7): [True: 34, False: 359] ------------------ 87| 34| std::string d; 88| | // TODO check Base64 decode 89| 34| d_ech = value; 90| 34| return; 91| 34| } 92| 359| d_value = value; 93| 359|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 96| 44|{ 97| 44| d_key = key; 98| 44| if (d_key != SvcParamKey::alpn) { ------------------ | Branch (98:7): [True: 0, False: 44] ------------------ 99| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string-set value"); 100| 0| } 101| 44| if (d_key == SvcParamKey::alpn) { ------------------ | Branch (101:7): [True: 44, False: 0] ------------------ 102| 44| d_alpn = std::move(value); 103| 44| } 104| 44|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__13setIS0_NS3_4lessIS0_EENS3_9allocatorIS0_EEEE: 120| 205|{ 121| 205| d_key = key; 122| 205| if (d_key != SvcParamKey::mandatory) { ------------------ | Branch (122:7): [True: 0, False: 205] ------------------ 123| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a SvcParamKey-set value"); 124| 0| } 125| 205| d_mandatory = std::move(value); 126| 205|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorI12ComboAddressNS3_9allocatorIS5_EEEE: 129| 147|{ 130| 147| d_key = key; 131| 147| if (d_key != SvcParamKey::ipv6hint && d_key != SvcParamKey::ipv4hint) { ------------------ | Branch (131:7): [True: 113, False: 34] | Branch (131:41): [True: 0, False: 113] ------------------ 132| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with an IP address value"); 133| 0| } 134| 15.2k| for (auto const& addr : value) { ------------------ | Branch (134:25): [True: 15.2k, False: 147] ------------------ 135| 15.2k| if (d_key == SvcParam::ipv6hint && !addr.isIPv6()) { ------------------ | Branch (135:9): [True: 1.70k, False: 13.5k] | Branch (135:40): [True: 0, False: 1.70k] ------------------ 136| 0| throw std::invalid_argument("non-IPv6 address ('" + addr.toString() + "') passed for " + keyToString(key)); 137| 0| } 138| 15.2k| if (d_key == SvcParam::ipv4hint && !addr.isIPv4()) { ------------------ | Branch (138:9): [True: 13.5k, False: 1.70k] | Branch (138:40): [True: 0, False: 13.5k] ------------------ 139| 0| throw std::invalid_argument("non-IPv4 address ('" + addr.toString() + "') passed for " + keyToString(key)); 140| 0| } 141| 15.2k| } 142| 147| d_ipHints = std::move(value); 143| 147|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorItNS3_9allocatorItEEEE: 146| 134| d_key(key) 147| 134|{ 148| 134| if (d_key != SvcParamKey::tls_supported_groups) { ------------------ | Branch (148:7): [True: 0, False: 134] ------------------ 149| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a uint16 value-vector"); 150| 0| } 151| 134| d_tls_supported_groups = std::move(value); 152| 134|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEt: 155| 64|{ 156| 64| d_key = key; 157| 64| if (d_key != SvcParamKey::port) { ------------------ | Branch (157:7): [True: 0, False: 64] ------------------ 158| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a port value"); 159| 0| } 160| 64| d_port = value; 161| 64|} _ZNK8SvcParamltERKS_: 165| 1.24k|{ 166| 1.24k| return this->d_key < other.getKey(); 167| 1.24k|} svc-records.cc:_ZZN8SvcParam11keyToStringERKNS_11SvcParamKeyEENK3$_0clERKNSt3__14pairINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEES0_EE: 65| 64| auto ret = std::find_if(SvcParams.begin(), SvcParams.end(), [&](const std::pair& e) { return e.second == k; }); _ZNK8SvcParam6getKeyEv: 97| 1.24k| { 98| 1.24k| return d_key; 99| 1.24k| } _ZN8SvcParam11setAutoHintEb: 110| 147| void setAutoHint(const bool value) { d_autohint = value; }; _ZN4pdns5views16UnsignedCharViewC2EPKcm: 33| 25.0k| view(data_, size_) 34| 25.0k| { 35| 25.0k| } _ZNK4pdns5views16UnsignedCharView2atEm: 44| 84.5k| { 45| 84.5k| return reinterpret_cast(view.at(pos)); 46| 84.5k| } _ZNK4pdns5views16UnsignedCharView4sizeEv: 60| 44.6k| { 61| 44.6k| return view.size(); 62| 44.6k| }