_ZN7DNSName19throwSafeRangeErrorERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEPKcm: 61| 706|{ 62| 706| std::string dots; 63| 706| if (length > s_maxDNSNameLength) { ------------------ | Branch (63:7): [True: 0, False: 706] ------------------ 64| 0| length = s_maxDNSNameLength; 65| 0| dots = "..."; 66| 0| } 67| 706| std::string label; 68| 706| DNSName::appendEscapedLabel(label, buf, length); 69| 706| throw std::range_error(msg + label + dots); 70| 706|} _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.26k, False: 7.67k] | Branch (77:37): [True: 9.26k, False: 2] ------------------ 78| 9.26k| d_storage.assign(1, '\0'); 79| 9.26k| } else { 80| 7.67k| if(!std::memchr(p, '\\', length)) { ------------------ | Branch (80:8): [True: 7.67k, False: 0] ------------------ 81| 7.67k| unsigned char lenpos=0; 82| 7.67k| unsigned char labellen=0; 83| 7.67k| const char* const pbegin=p, *pend=p+length; 84| | 85| 7.67k| d_storage.reserve(length+1); 86| 27.5k| for(auto iter = pbegin; iter != pend; ) { ------------------ | Branch (86:31): [True: 19.8k, False: 7.67k] ------------------ 87| 19.8k| lenpos = d_storage.size(); 88| 19.8k| if(*iter=='.') ------------------ | Branch (88:12): [True: 706, False: 19.1k] ------------------ 89| 706| throwSafeRangeError("Found . in wrong position in DNSName: ", p, length); 90| 19.8k| d_storage.append(1, '\0'); 91| 19.8k| labellen=0; 92| 19.8k| auto begiter=iter; 93| 127k| for(; iter != pend && *iter!='.'; ++iter) { ------------------ | Branch (93:15): [True: 127k, False: 732] | Branch (93:31): [True: 108k, False: 19.1k] ------------------ 94| 108k| labellen++; 95| 108k| } 96| 19.8k| d_storage.append(begiter,iter); 97| 19.8k| if(iter != pend) ------------------ | Branch (97:12): [True: 19.1k, False: 732] ------------------ 98| 19.1k| ++iter; 99| 19.8k| if(labellen > s_maxDNSLabelLength) { ------------------ | Branch (99:12): [True: 0, False: 19.8k] ------------------ 100| 0| throwSafeRangeError("label too long to append: ", p, length); 101| 0| } 102| | 103| 19.8k| 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: 19.8k] ------------------ 104| 0| throwSafeRangeError("name too long to append: ", p, length); 105| | 106| 19.8k| d_storage[lenpos]=labellen; 107| 19.8k| } 108| 7.67k| d_storage.append(1, '\0'); 109| 7.67k| } 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.67k| } 117| 16.9k|} _ZN7DNSNameC2EPKcmmbPtS2_Pjt: 120| 20.9k|{ 121| 20.9k| if (offset >= len) ------------------ | Branch (121:7): [True: 144, False: 20.8k] ------------------ 122| 144| throw std::range_error("Trying to read past the end of the buffer ("+std::to_string(offset)+ " >= "+std::to_string(len)+")"); 123| | 124| 20.8k| if(!uncompress) { ------------------ | Branch (124:6): [True: 0, False: 20.8k] ------------------ 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.8k| packetParser(pos, len, offset, uncompress, qtype, qclass, consumed, 0, minOffset); 131| 20.8k|} _ZN7DNSName23parsePacketUncompressedERKN4pdns5views16UnsignedCharViewEmb: 145| 25.3k|{ 146| 25.3k| const size_t initialPos = pos; 147| 25.3k| auto existingSize = d_storage.size(); 148| 25.3k| const size_t neededSizeForFinalLabel = /* final empty label length */ (existingSize == 0 ? 1U : 0U); ------------------ | Branch (148:74): [True: 22.4k, False: 2.90k] ------------------ 149| 25.3k| size_t totalLength = 0; 150| 25.3k| unsigned char labellen = 0; 151| | 152| 45.8k| do { 153| 45.8k| labellen = view.at(pos); 154| 45.8k| ++pos; 155| | 156| 45.8k| if (labellen == 0) { ------------------ | Branch (156:9): [True: 20.6k, False: 25.2k] ------------------ 157| 20.6k| --pos; 158| 20.6k| break; 159| 20.6k| } 160| | 161| 25.2k| if (labellen >= 0xc0) { ------------------ | Branch (161:9): [True: 4.56k, False: 20.6k] ------------------ 162| 4.56k| if (!uncompress) { ------------------ | Branch (162:11): [True: 0, False: 4.56k] ------------------ 163| 0| throw std::range_error("Found compressed label, instructed not to follow"); 164| 0| } 165| 4.56k| --pos; 166| 4.56k| break; 167| 4.56k| } 168| | 169| 20.6k| if ((labellen & 0xc0) != 0) { ------------------ | Branch (169:9): [True: 51, False: 20.5k] ------------------ 170| 51| throw std::range_error("Found an invalid label length in qname (only one of the first two bits is set)"); 171| 51| } 172| 20.5k| 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.5k| if ((existingSize + totalLength + labellen + 1U + neededSizeForFinalLabel) > s_maxDNSNameLength) { ------------------ | Branch (175:9): [True: 5, False: 20.5k] ------------------ 176| 5| throw std::range_error("name too long to append"); 177| 5| } 178| 20.5k| if (pos + labellen >= view.size()) { ------------------ | Branch (178:9): [True: 75, False: 20.5k] ------------------ 179| 75| throw std::range_error("Found an invalid label length in qname"); 180| 75| } 181| 20.5k| pos += labellen; 182| 20.5k| totalLength += 1U + labellen; 183| 20.5k| } 184| 25.3k| while (pos < view.size()); ------------------ | Branch (184:10): [True: 20.5k, False: 0] ------------------ 185| | 186| 25.2k| if (totalLength != 0) { ------------------ | Branch (186:7): [True: 10.5k, False: 14.6k] ------------------ 187| 10.5k| if (existingSize > 0) { ------------------ | Branch (187:9): [True: 2.87k, False: 7.64k] ------------------ 188| | // remove the last label count, we are about to override it */ 189| 2.87k| --existingSize; 190| 2.87k| } 191| 10.5k| if ((existingSize + totalLength + 1U) > s_maxDNSNameLength) { ------------------ | Branch (191:9): [True: 0, False: 10.5k] ------------------ 192| 0| throw std::range_error("name too long to append"); 193| 0| } 194| 10.5k| d_storage.reserve(existingSize + totalLength + 1); 195| 10.5k| d_storage.resize(existingSize + totalLength); 196| 10.5k| memcpy(&d_storage.at(existingSize), &view.at(initialPos), totalLength); 197| 10.5k| d_storage.append(1, static_cast(0)); 198| 10.5k| } 199| 25.2k| return pos; 200| 25.2k|} _ZN7DNSName12packetParserEPKcmmbPtS2_Pjit: 204| 25.3k|{ 205| 25.3k| if (offset >= len) { ------------------ | Branch (205:7): [True: 0, False: 25.3k] ------------------ 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.3k| if (offset < static_cast(minOffset)) { ------------------ | Branch (209:7): [True: 0, False: 25.3k] ------------------ 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.3k| unsigned char labellen{0}; 213| | 214| 25.3k| pdns::views::UnsignedCharView view(qpos, len); 215| 25.3k| auto pos = parsePacketUncompressed(view, offset, uncompress); 216| | 217| 25.3k| labellen = view.at(pos); 218| 25.3k| pos++; 219| 25.3k| if (labellen != 0 && pos < view.size()) { ------------------ | Branch (219:7): [True: 4.56k, False: 20.7k] | Branch (219:24): [True: 4.53k, False: 35] ------------------ 220| 4.53k| if (labellen < 0xc0) { ------------------ | Branch (220:9): [True: 0, False: 4.53k] ------------------ 221| 0| throw std::range_error("Invalid label byte during decompression ("+std::to_string(labellen)+")"); 222| 0| } 223| | 224| 4.53k| if (!uncompress) { ------------------ | Branch (224:9): [True: 0, False: 4.53k] ------------------ 225| 0| throw std::range_error("Found compressed label, instructed not to follow"); 226| 0| } 227| | 228| 4.53k| labellen &= (~0xc0); 229| 4.53k| size_t newpos = (labellen << 8) + view.at(pos); 230| | 231| 4.53k| if (newpos >= offset) { ------------------ | Branch (231:9): [True: 44, False: 4.48k] ------------------ 232| 44| throw std::range_error("Found a forward reference during label decompression"); 233| 44| } 234| | 235| 4.48k| if (newpos < minOffset) { ------------------ | Branch (235:9): [True: 2, False: 4.48k] ------------------ 236| 2| throw std::range_error("Invalid label position during decompression ("+std::to_string(newpos)+ " < "+std::to_string(minOffset)+")"); 237| 2| } 238| | 239| 4.48k| if (++depth > 100) { ------------------ | Branch (239:9): [True: 0, False: 4.48k] ------------------ 240| 0| throw std::range_error("Abort label decompression after 100 redirects"); 241| 0| } 242| | 243| 4.48k| packetParser(qpos, len, newpos, true, nullptr, nullptr, nullptr, depth, minOffset); 244| | 245| 4.48k| pos++; 246| 4.48k| } 247| | 248| 25.2k| if (d_storage.empty()) { ------------------ | Branch (248:7): [True: 13.0k, False: 12.2k] ------------------ 249| 13.0k| d_storage.append(1, static_cast(0)); // we just parsed the root 250| 13.0k| } 251| | 252| 25.2k| if (consumed != nullptr) { ------------------ | Branch (252:7): [True: 20.6k, False: 4.61k] ------------------ 253| 20.6k| *consumed = pos - offset; 254| 20.6k| } 255| | 256| 25.2k| if (qtype != nullptr) { ------------------ | Branch (256:7): [True: 0, False: 25.2k] ------------------ 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| 25.2k| pos += 2; 264| 25.2k| if (qclass != nullptr) { ------------------ | Branch (264:7): [True: 0, False: 25.2k] ------------------ 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| 25.2k|} _ZNK7DNSName11toLogStringEv: 312| 27|{ 313| 27| if (empty()) { ------------------ | Branch (313:7): [True: 0, False: 27] ------------------ 314| 0| return "(empty)"; 315| 0| } 316| | 317| 27| return toStringRootDot(); 318| 27|} _ZNK7DNSName10wirelengthEv: 341| 4.89k|size_t DNSName::wirelength() const { 342| 4.89k| return d_storage.length(); 343| 4.89k|} _ZN7DNSName18appendEscapedLabelERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEPKcm: 697| 706|{ 698| 706| size_t pos = 0; 699| | 700| 10.4k| while (pos < len) { ------------------ | Branch (700:10): [True: 9.71k, False: 706] ------------------ 701| 9.71k| auto p = static_cast(orig[pos]); 702| 9.71k| if (p=='.') { ------------------ | Branch (702:9): [True: 1.41k, False: 8.29k] ------------------ 703| 1.41k| appendTo+="\\."; 704| 1.41k| } 705| 8.29k| else if (p=='\\') { ------------------ | Branch (705:14): [True: 0, False: 8.29k] ------------------ 706| 0| appendTo+="\\\\"; 707| 0| } 708| 8.29k| else if (p > 0x20 && p < 0x7f) { ------------------ | Branch (708:14): [True: 8.29k, False: 0] | Branch (708:26): [True: 8.29k, False: 0] ------------------ 709| 8.29k| appendTo.append(1, static_cast(p)); 710| 8.29k| } 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| 9.71k| ++pos; 721| 9.71k| } 722| 706|} _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.5k|{ 135| 20.5k| if (length == 0) { ------------------ | Branch (135:7): [True: 0, False: 20.5k] ------------------ 136| 0| throw std::range_error("no such thing as an empty label to append"); 137| 0| } 138| 20.5k| if (length > DNSName::s_maxDNSLabelLength) { ------------------ | Branch (138:7): [True: 0, False: 20.5k] ------------------ 139| 0| throw std::range_error("label too long to append"); 140| 0| } 141| 20.5k|} _Z11dns_tolowerh: 58| 1.10k|{ 59| 1.10k| return dns_tolower_table[chr]; 60| 1.10k|} _Z39pdns_ilexicographical_compare_three_wayNSt3__117basic_string_viewIcNS_11char_traitsIcEEEES3_: 64| 10.7k|{ 65| 10.7k| const unsigned char *aPtr = (const unsigned char*)a.data(), *bPtr = (const unsigned char*)b.data(); 66| 10.7k| const unsigned char *aEptr = aPtr + a.length(), *bEptr = bPtr + b.length(); 67| 54.5k| while(aPtr != aEptr && bPtr != bEptr) { ------------------ | Branch (67:9): [True: 44.3k, False: 10.1k] | Branch (67:26): [True: 44.3k, False: 0] ------------------ 68| 44.3k| if (*aPtr != *bPtr) { ------------------ | Branch (68:9): [True: 551, False: 43.8k] ------------------ 69| 551| if (int rc = dns_tolower(*aPtr) - dns_tolower(*bPtr); rc != 0) { ------------------ | Branch (69:61): [True: 551, False: 0] ------------------ 70| 551| return rc; 71| 551| } 72| 551| } 73| 43.8k| aPtr++; 74| 43.8k| bPtr++; 75| 43.8k| } 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.1k| if (aPtr == aEptr) { ------------------ | Branch (79:7): [True: 10.1k, False: 0] ------------------ 80| 10.1k| if (bPtr != bEptr) { ------------------ | Branch (80:9): [True: 0, False: 10.1k] ------------------ 81| 0| return -1; // a < b 82| 0| } 83| 10.1k| } 84| 0| else { 85| 0| return 1; // a > b 86| 0| } 87| 10.1k| return 0; // a == b 88| 10.1k|} _ZN7DNSNameaSERKS_: 149| 706| { 150| 706| if (this != &rhs) { ------------------ | Branch (150:9): [True: 706, False: 0] ------------------ 151| 706| d_storage = rhs.d_storage; 152| 706| } 153| 706| return *this; 154| 706| } _ZN7DNSNameaSEOS_: 156| 31.5k| { 157| 31.5k| if (this != &rhs) { ------------------ | Branch (157:9): [True: 31.5k, False: 0] ------------------ 158| 31.5k| d_storage = std::move(rhs.d_storage); 159| 31.5k| } 160| 31.5k| return *this; 161| 31.5k| } _ZNK7DNSName15toStringRootDotEv: 178| 27| std::string toStringRootDot() const { if(isRoot()) return "."; else return toString(".", false); } ------------------ | Branch (178:44): [True: 27, 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.0k, False: 13.8k] | Branch (209:55): [True: 16.0k, 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.77k| DNSName(const DNSName& a) = default; _ZN7DNSNameC2Ev: 146| 33.2k| DNSName() = default; //!< Constructs an *empty* DNSName, NOT the root! _ZN7DNSNameC2EOS_: 163| 8.85k| DNSName(DNSName&& a) = default; _ZN16DNSRecordContent4makeERK9DNSRecordR12PacketReadert: 259| 10.7k|{ 260| | // For opcode UPDATE and where the DNSRecord is an answer record, we don't care about content, because this is 261| | // not used within the prerequisite section of RFC2136, so - we can simply use unknownrecordcontent. 262| | // For section 3.2.3, we do need content so we need to get it properly. But only for the correct QClasses. 263| 10.7k| if (oc == Opcode::Update && dr.d_place == DNSResourceRecord::ANSWER && dr.d_class != 1) ------------------ | Branch (263:7): [True: 0, False: 10.7k] | Branch (263:31): [True: 0, False: 0] | Branch (263:74): [True: 0, False: 0] ------------------ 264| 0| return std::make_shared(dr, pr); 265| | 266| 10.7k| uint16_t searchclass = (dr.d_type == QType::OPT) ? 1 : dr.d_class; // class is invalid for OPT ------------------ | Branch (266:26): [True: 501, False: 10.2k] ------------------ 267| | 268| 10.7k| auto i = getTypemap().find(pair(searchclass, dr.d_type)); 269| 10.7k| if(i==getTypemap().end() || !i->second) { ------------------ | Branch (269:6): [True: 1.87k, False: 8.91k] | Branch (269:6): [True: 1.87k, False: 8.91k] | Branch (269:31): [True: 0, False: 8.91k] ------------------ 270| 1.87k| return std::make_shared(dr, pr); 271| 1.87k| } 272| | 273| 8.91k| return i->second(dr, pr); 274| 10.7k|} _ZN16DNSRecordContent10getTypemapEv: 284| 21.6k|{ 285| 21.6k| static DNSRecordContent::typemap_t typemap; 286| 21.6k| return typemap; 287| 21.6k|} _ZN16DNSRecordContent12getN2TypemapEv: 290| 118|{ 291| 118| static DNSRecordContent::n2typemap_t n2typemap; 292| 118| return n2typemap; 293| 118|} _ZN16DNSRecordContent12getT2NamemapEv: 296| 118|{ 297| 118| static DNSRecordContent::t2namemap_t t2namemap; 298| 118| return t2namemap; 299| 118|} _ZN16DNSRecordContent12getZmakermapEv: 302| 115|{ 303| 115| static DNSRecordContent::zmakermap_t zmakermap; 304| 115| return zmakermap; 305| 115|} _ZN12MOADNSParser4initEbRKNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 336| 4.85k|{ 337| 4.85k| if (packet.size() < sizeof(dnsheader)) ------------------ | Branch (337:7): [True: 0, False: 4.85k] ------------------ 338| 0| throw MOADNSException("Packet shorter than minimal header"); 339| | 340| 4.85k| memcpy(&d_header, packet.data(), sizeof(dnsheader)); 341| | 342| 4.85k| if(d_header.opcode != Opcode::Query && d_header.opcode != Opcode::Notify && d_header.opcode != Opcode::Update) ------------------ | Branch (342:6): [True: 0, False: 4.85k] | Branch (342:42): [True: 0, False: 0] | Branch (342:79): [True: 0, False: 0] ------------------ 343| 0| throw MOADNSException("Can't parse non-query packet with opcode="+ std::to_string(d_header.opcode)); 344| | 345| 4.85k| d_header.qdcount=ntohs(d_header.qdcount); 346| 4.85k| d_header.ancount=ntohs(d_header.ancount); 347| 4.85k| d_header.nscount=ntohs(d_header.nscount); 348| 4.85k| d_header.arcount=ntohs(d_header.arcount); 349| | 350| 4.85k| if (query && (d_header.qdcount > 1)) ------------------ | Branch (350:7): [True: 0, False: 4.85k] | Branch (350:16): [True: 0, False: 0] ------------------ 351| 0| throw MOADNSException("Query with QD > 1 ("+std::to_string(d_header.qdcount)+")"); 352| | 353| 4.85k| unsigned int n=0; 354| | 355| 4.85k| PacketReader pr(packet); 356| 4.85k| bool validPacket=false; 357| 4.85k| try { 358| 4.85k| d_qtype = d_qclass = 0; // sometimes replies come in with no question, don't present garbage then 359| | 360| 9.70k| for(n=0;n < d_header.qdcount; ++n) { ------------------ | Branch (360:13): [True: 4.85k, False: 4.85k] ------------------ 361| 4.85k| d_qname=pr.getName(); 362| 4.85k| d_qtype=pr.get16BitInt(); 363| 4.85k| d_qclass=pr.get16BitInt(); 364| 4.85k| } 365| | 366| 4.85k| struct dnsrecordheader ah; 367| 4.85k| vector record; 368| 4.85k| bool seenTSIG = false; 369| 4.85k| validPacket=true; 370| 4.85k| unsigned int supposedRecordCount = d_header.ancount + d_header.nscount + d_header.arcount; 371| | // No need to reserve more memory for more records than the request can 372| | // contain. We could try to be smarter and actually count the records 373| | // by doing getDnsrecordheader and skip the payload in a loop, but all 374| | // we really want here is to avoid reserving too much memory in case of 375| | // maliciously high record counts. 376| 4.85k| auto reserveRecordCount = std::min(1 + (packet.size() - sizeof(dnsheader)) / sizeof(dnsrecordheader), static_cast(supposedRecordCount)); 377| 4.85k| d_answers.reserve(reserveRecordCount); 378| 16.2k| for (n = 0; n < supposedRecordCount; ++n) { ------------------ | Branch (378:17): [True: 11.4k, False: 4.82k] ------------------ 379| 11.4k| DNSRecord dr; 380| | 381| 11.4k| if(n < d_header.ancount) ------------------ | Branch (381:10): [True: 10.8k, False: 533] ------------------ 382| 10.8k| dr.d_place=DNSResourceRecord::ANSWER; 383| 533| else if(n < d_header.ancount + d_header.nscount) ------------------ | Branch (383:15): [True: 0, False: 533] ------------------ 384| 0| dr.d_place=DNSResourceRecord::AUTHORITY; 385| 533| else 386| 533| dr.d_place=DNSResourceRecord::ADDITIONAL; 387| | 388| 11.4k| unsigned int recordStartPos=pr.getPosition(); 389| | 390| 11.4k| DNSName name=pr.getName(); 391| | 392| 11.4k| pr.getDnsrecordheader(ah); 393| 11.4k| dr.d_ttl=ah.d_ttl; 394| 11.4k| dr.d_type=ah.d_type; 395| 11.4k| dr.d_class=ah.d_class; 396| | 397| 11.4k| dr.d_name = std::move(name); 398| 11.4k| dr.d_clen = ah.d_clen; 399| | 400| 11.4k| if (query && ------------------ | Branch (400:11): [True: 0, False: 11.4k] ------------------ 401| 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 (401:13): [True: 0, False: 0] | Branch (401:39): [True: 0, False: 0] | Branch (401:85): [True: 0, False: 0] ------------------ 402| 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 (402:12): [True: 0, False: 0] | Branch (402:55): [True: 0, False: 0] | Branch (402:102): [True: 0, False: 0] | Branch (402:129): [True: 0, False: 0] | Branch (402:157): [True: 0, False: 0] | Branch (402:184): [True: 0, False: 0] | Branch (402:215): [True: 0, False: 0] | Branch (402:243): [True: 0, False: 0] | Branch (402:270): [True: 0, False: 0] | Branch (402:299): [True: 0, False: 0] ------------------ 403| |// cerr<<"discarding RR, query is "<(dr, pr)); 405| 0| } 406| 11.4k| else { 407| |// cerr<<"parsing RR, query is "<(&ah); 471| | 472| 122k| for(unsigned int n = 0; n < sizeof(dnsrecordheader); ++n) { ------------------ | Branch (472:27): [True: 111k, False: 11.2k] ------------------ 473| 111k| p[n] = d_content.at(d_pos++); 474| 111k| } 475| | 476| 11.2k| ah.d_type = ntohs(ah.d_type); 477| 11.2k| ah.d_class = ntohs(ah.d_class); 478| 11.2k| ah.d_clen = ntohs(ah.d_clen); 479| 11.2k| ah.d_ttl = ntohl(ah.d_ttl); 480| | 481| 11.2k| d_startrecordpos = d_pos; // needed for getBlob later on 482| 11.2k| d_recordlen = ah.d_clen; 483| 11.2k| if (d_pos > d_content.size() || (d_content.size() - d_pos) < (d_recordlen)) { ------------------ | Branch (483:7): [True: 378, False: 10.8k] | Branch (483:35): [True: 75, False: 10.7k] ------------------ 484| 75| 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()) + ")"); 485| 75| } 486| 11.2k|} _ZN12PacketReader10copyRecordERNSt3__16vectorIhNS0_9allocatorIhEEEEt: 490| 1.87k|{ 491| 1.87k| if (len == 0) { ------------------ | Branch (491:7): [True: 720, False: 1.15k] ------------------ 492| 720| return; 493| 720| } 494| 1.15k| if ((d_pos + len) > d_content.size()) { ------------------ | Branch (494:7): [True: 0, False: 1.15k] ------------------ 495| 0| throw std::out_of_range("Attempt to copy outside of packet"); 496| 0| } 497| | 498| 1.15k| dest.resize(len); 499| | 500| 3.65M| for (uint16_t n = 0; n < len; ++n) { ------------------ | Branch (500:24): [True: 3.65M, False: 1.15k] ------------------ 501| 3.65M| dest.at(n) = d_content.at(d_pos++); 502| 3.65M| } 503| 1.15k|} _ZN12PacketReader10copyRecordEPht: 506| 103|{ 507| 103| if (d_pos + len > d_content.size()) { ------------------ | Branch (507:7): [True: 0, False: 103] ------------------ 508| 0| throw std::out_of_range("Attempt to copy outside of packet"); 509| 0| } 510| | 511| 103| memcpy(dest, &d_content.at(d_pos), len); 512| 103| d_pos += len; 513| 103|} _ZN12PacketReader18xfrNodeOrLocatorIDER15NodeOrLocatorID: 516| 144|{ 517| 144| if (d_pos + sizeof(ret) > d_content.size()) { ------------------ | Branch (517:7): [True: 4, False: 140] ------------------ 518| 4| throw std::out_of_range("Attempt to read 64 bit value outside of packet"); 519| 4| } 520| 140| memcpy(&ret.content, &d_content.at(d_pos), sizeof(ret.content)); 521| 140| d_pos += sizeof(ret); 522| 140|} _ZN12PacketReader11xfr48BitIntERm: 525| 153|{ 526| 153| ret=0; 527| 153| ret+=static_cast(d_content.at(d_pos++)); 528| 153| ret<<=8; 529| 153| ret+=static_cast(d_content.at(d_pos++)); 530| 153| ret<<=8; 531| 153| ret+=static_cast(d_content.at(d_pos++)); 532| 153| ret<<=8; 533| 153| ret+=static_cast(d_content.at(d_pos++)); 534| 153| ret<<=8; 535| 153| ret+=static_cast(d_content.at(d_pos++)); 536| 153| ret<<=8; 537| 153| ret+=static_cast(d_content.at(d_pos++)); 538| 153|} _ZN12PacketReader11get32BitIntEv: 541| 2.12k|{ 542| 2.12k| uint32_t ret=0; 543| 2.12k| ret+=static_cast(d_content.at(d_pos++)); 544| 2.12k| ret<<=8; 545| 2.12k| ret+=static_cast(d_content.at(d_pos++)); 546| 2.12k| ret<<=8; 547| 2.12k| ret+=static_cast(d_content.at(d_pos++)); 548| 2.12k| ret<<=8; 549| 2.12k| ret+=static_cast(d_content.at(d_pos++)); 550| | 551| 2.12k| return ret; 552| 2.12k|} _ZN12PacketReader11get16BitIntEv: 556| 290k|{ 557| 290k| uint16_t ret=0; 558| 290k| ret+=static_cast(d_content.at(d_pos++)); 559| 290k| ret<<=8; 560| 290k| ret+=static_cast(d_content.at(d_pos++)); 561| | 562| 290k| return ret; 563| 290k|} _ZN12PacketReader10get8BitIntEv: 566| 34.9k|{ 567| 34.9k| return d_content.at(d_pos++); 568| 34.9k|} _ZN12PacketReader7getNameEv: 571| 20.9k|{ 572| 20.9k| unsigned int consumed; 573| 20.9k| try { 574| 20.9k| uint16_t minOffset = d_standalone ? 0 : sizeof(dnsheader); ------------------ | Branch (574:26): [True: 0, False: 20.9k] ------------------ 575| 20.9k| bool uncompress = !d_standalone; 576| 20.9k| DNSName name((const char*) d_content.data(), d_content.size(), d_pos, uncompress, nullptr /* qtype */, nullptr /* qclass */, &consumed, minOffset); 577| | 578| 20.9k| d_pos+=consumed; 579| 20.9k| return name; 580| 20.9k| } 581| 20.9k| catch(const std::range_error& re) { 582| 321| throw std::out_of_range(string("dnsname issue: ")+re.what()); 583| 321| } 584| 20.9k| catch(...) { 585| 0| throw std::out_of_range("dnsname issue"); 586| 0| } 587| 0| throw PDNSException("PacketReader::getName(): name is empty"); 588| 20.9k|} _Z9txtEscapeRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 592| 16.0k|{ 593| 16.0k| string ret; 594| 16.0k| std::array ebuf{}; 595| | 596| 760k| for (char letter : name) { ------------------ | Branch (596:20): [True: 760k, False: 16.0k] ------------------ 597| 760k| const unsigned uch = static_cast(letter); 598| 760k| if (uch >= 127 || uch < 32) { ------------------ | Branch (598:9): [True: 137k, False: 622k] | Branch (598:23): [True: 490k, False: 131k] ------------------ 599| 628k| snprintf(ebuf.data(), ebuf.size(), "\\%03u", uch); 600| 628k| ret += ebuf.data(); 601| 628k| } 602| 131k| else if (letter == '"' || letter == '\\'){ ------------------ | Branch (602:14): [True: 1.75k, False: 129k] | Branch (602:31): [True: 977, False: 128k] ------------------ 603| 2.73k| ret += '\\'; 604| 2.73k| ret += letter; 605| 2.73k| } 606| 128k| else { 607| 128k| ret += letter; 608| 128k| } 609| 760k| } 610| 16.0k| return ret; 611| 16.0k|} _ZN12PacketReader7getTextEbb: 615| 1.21k|{ 616| 1.21k| string ret; 617| 1.21k| ret.reserve(40); 618| 135k| while (d_pos < d_startrecordpos + d_recordlen ) { ------------------ | Branch (618:10): [True: 134k, False: 964] ------------------ 619| 134k| if (!ret.empty()) { ------------------ | Branch (619:9): [True: 133k, False: 741] ------------------ 620| 133k| ret.append(1,' '); 621| 133k| } 622| 134k| uint16_t labellen; 623| 134k| if (lenField) { ------------------ | Branch (623:9): [True: 134k, False: 387] ------------------ 624| 134k| labellen = static_cast(d_content.at(d_pos++)); 625| 134k| } 626| 387| else { 627| 387| labellen = d_recordlen - (d_pos - d_startrecordpos); 628| 387| } 629| | 630| 134k| const uint16_t remaining = (d_startrecordpos + d_recordlen) - d_pos; 631| 134k| if (labellen > remaining) { ------------------ | Branch (631:9): [True: 58, False: 134k] ------------------ 632| 58| throw std::out_of_range("label length in text record exceeds record boundary"); 633| 58| } 634| | 635| 134k| ret.append(1, '"'); 636| 134k| if (labellen) { // no need to do anything for an empty string ------------------ | Branch (636:9): [True: 16.0k, False: 118k] ------------------ 637| 16.0k| string val(&d_content.at(d_pos), &d_content.at(d_pos + labellen - 1) + 1); 638| 16.0k| ret.append(txtEscape(val)); // the end is one beyond the packet 639| 16.0k| } 640| 134k| ret.append(1, '"'); 641| 134k| d_pos += labellen; 642| 134k| if (!multi) { ------------------ | Branch (642:9): [True: 195, False: 134k] ------------------ 643| 195| break; 644| 195| } 645| 134k| } 646| | 647| 1.15k| if (ret.empty() && !lenField) { ------------------ | Branch (647:7): [True: 476, False: 683] | Branch (647:22): [True: 187, False: 289] ------------------ 648| | // all lenField == false cases (CAA and URI at the time of this writing) want that emptiness to be explicit 649| 187| return "\"\""; 650| 187| } 651| 972| return ret; 652| 1.15k|} _ZN12PacketReader15getUnquotedTextEb: 655| 447|{ 656| 447| uint16_t stop_at{}; 657| 447| if (lenField) { ------------------ | Branch (657:7): [True: 447, False: 0] ------------------ 658| 447| stop_at = static_cast(d_content.at(d_pos)) + d_pos + 1; 659| 447| } 660| 0| else { 661| 0| stop_at = d_recordlen; 662| 0| } 663| | 664| | /* think unsigned overflow */ 665| 447| if (stop_at < d_pos) { ------------------ | Branch (665:7): [True: 1, False: 446] ------------------ 666| 1| throw std::out_of_range("getUnquotedText out of record range"); 667| 1| } 668| | 669| | /* Validate against record boundary */ 670| 446| const uint16_t recordEnd = d_startrecordpos + d_recordlen; 671| 446| if (stop_at > recordEnd) { ------------------ | Branch (671:7): [True: 44, False: 402] ------------------ 672| 44| throw std::out_of_range("getUnquotedText: length exceeds record boundary"); 673| 44| } 674| | 675| 402| if (stop_at == d_pos) { ------------------ | Branch (675:7): [True: 0, False: 402] ------------------ 676| 0| return ""; 677| 0| } 678| | 679| 402| d_pos++; 680| 402| string ret(d_content.substr(d_pos, stop_at-d_pos)); 681| 402| d_pos = stop_at; 682| 402| return ret; 683| 402|} _ZN12PacketReader7xfrBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 686| 2.51k|{ 687| 2.51k| try { 688| 2.51k| if(d_recordlen && !(d_pos == (d_startrecordpos + d_recordlen))) { ------------------ | Branch (688:8): [True: 1.65k, False: 855] | Branch (688:23): [True: 1.54k, False: 111] ------------------ 689| 1.54k| if (d_pos > (d_startrecordpos + d_recordlen)) { ------------------ | Branch (689:11): [True: 12, False: 1.53k] ------------------ 690| 12| throw std::out_of_range("xfrBlob out of record range"); 691| 12| } 692| 1.53k| blob.assign(&d_content.at(d_pos), &d_content.at(d_startrecordpos + d_recordlen - 1 ) + 1); 693| 1.53k| } 694| 966| else { 695| 966| blob.clear(); 696| 966| } 697| | 698| 2.49k| d_pos = d_startrecordpos + d_recordlen; 699| 2.49k| } 700| 2.51k| catch(...) 701| 2.51k| { 702| 12| throw std::out_of_range("xfrBlob out of range"); 703| 12| } 704| 2.51k|} _ZN12PacketReader15xfrBlobNoSpacesERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEi: 706| 328|void PacketReader::xfrBlobNoSpaces(string& blob, int length) { 707| 328| xfrBlob(blob, length); 708| 328|} _ZN12PacketReader7xfrBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEi: 711| 36.9k|{ 712| 36.9k| if(length) { ------------------ | Branch (712:6): [True: 36.5k, False: 427] ------------------ 713| 36.5k| if (length < 0) { ------------------ | Branch (713:9): [True: 0, False: 36.5k] ------------------ 714| 0| throw std::out_of_range("xfrBlob out of range (negative length)"); 715| 0| } 716| 36.5k| auto available = (d_startrecordpos + d_recordlen) - d_pos; 717| 36.5k| if (available < length) { ------------------ | Branch (717:9): [True: 174, False: 36.3k] ------------------ 718| 174| throw std::out_of_range("xfrBlob out of range (excessive length)"); 719| 174| } 720| | 721| 36.3k| blob.assign(&d_content.at(d_pos), &d_content.at(d_pos + length - 1 ) + 1 ); 722| | 723| 36.3k| d_pos += length; 724| 36.3k| } 725| 427| else { 726| 427| blob.clear(); 727| 427| } 728| 36.9k|} _ZN12PacketReader18xfrSvcParamKeyValsERNSt3__13setI8SvcParamNS0_4lessIS2_EENS0_9allocatorIS2_EEEE: 730| 1.01k|void PacketReader::xfrSvcParamKeyVals(set &kvs) { 731| 1.01k| int32_t lastKey{-1}; // Keep track of the last key, as ordering should be strict 732| | 733| 1.99k| while (d_pos < (d_startrecordpos + d_recordlen)) { ------------------ | Branch (733:10): [True: 1.28k, False: 714] ------------------ 734| 1.28k| if (d_pos + 2 > (d_startrecordpos + d_recordlen)) { ------------------ | Branch (734:9): [True: 17, False: 1.26k] ------------------ 735| 17| throw std::out_of_range("incomplete key"); 736| 17| } 737| 1.26k| uint16_t keyInt; 738| 1.26k| xfr16BitInt(keyInt); 739| | 740| 1.26k| if (keyInt <= lastKey) { ------------------ | Branch (740:9): [True: 69, False: 1.19k] ------------------ 741| 69| throw std::out_of_range("Found SVCParamKey " + std::to_string(keyInt) + " after SVCParamKey " + std::to_string(lastKey)); 742| 69| } 743| 1.19k| lastKey = keyInt; 744| | 745| 1.19k| auto key = static_cast(keyInt); 746| | 747| 1.19k| uint16_t len; 748| 1.19k| xfr16BitInt(len); 749| | 750| 1.19k| if (d_pos + len > (d_startrecordpos + d_recordlen)) { ------------------ | Branch (750:9): [True: 101, False: 1.09k] ------------------ 751| 101| throw std::out_of_range("record is shorter than SVCB lengthfield implies"); 752| 101| } 753| | 754| 1.09k| switch (key) 755| 1.09k| { 756| 207| case SvcParam::mandatory: { ------------------ | Branch (756:5): [True: 207, False: 889] ------------------ 757| 207| if (len % 2 != 0) { ------------------ | Branch (757:11): [True: 1, False: 206] ------------------ 758| 1| throw std::out_of_range("mandatory SvcParam has invalid length"); 759| 1| } 760| 206| if (len == 0) { ------------------ | Branch (760:11): [True: 4, False: 202] ------------------ 761| 4| throw std::out_of_range("empty 'mandatory' values"); 762| 4| } 763| 202| std::set paramKeys; 764| 202| size_t stop = d_pos + len; 765| 203k| while (d_pos < stop) { ------------------ | Branch (765:14): [True: 203k, False: 202] ------------------ 766| 203k| uint16_t keyval; 767| 203k| xfr16BitInt(keyval); 768| 203k| paramKeys.insert(static_cast(keyval)); 769| 203k| } 770| 202| kvs.insert(SvcParam(key, std::move(paramKeys))); 771| 202| break; 772| 206| } 773| 113| case SvcParam::alpn: { ------------------ | Branch (773:5): [True: 113, False: 983] ------------------ 774| 113| size_t stop = d_pos + len; 775| 113| std::vector alpns; 776| 22.1k| while (d_pos < stop) { ------------------ | Branch (776:14): [True: 22.0k, False: 49] ------------------ 777| 22.0k| string alpn; 778| 22.0k| uint8_t alpnLen = 0; 779| 22.0k| xfr8BitInt(alpnLen); 780| 22.0k| if (alpnLen == 0) { ------------------ | Branch (780:13): [True: 15, False: 22.0k] ------------------ 781| 15| throw std::out_of_range("alpn length of 0"); 782| 15| } 783| 22.0k| if (d_pos + alpnLen > stop) { ------------------ | Branch (783:13): [True: 49, False: 22.0k] ------------------ 784| 49| throw std::out_of_range("alpn length is larger than rest of alpn SVC Param"); 785| 49| } 786| 22.0k| xfrBlob(alpn, alpnLen); 787| 22.0k| alpns.push_back(std::move(alpn)); 788| 22.0k| } 789| 49| kvs.insert(SvcParam(key, std::move(alpns))); 790| 49| break; 791| 113| } 792| 22| case SvcParam::ohttp: ------------------ | Branch (792:5): [True: 22, False: 1.07k] ------------------ 793| 50| case SvcParam::no_default_alpn: { ------------------ | Branch (793:5): [True: 28, False: 1.06k] ------------------ 794| 50| if (len != 0) { ------------------ | Branch (794:11): [True: 3, False: 47] ------------------ 795| 3| throw std::out_of_range("invalid length for " + SvcParam::keyToString(key)); 796| 3| } 797| 47| kvs.insert(SvcParam(key)); 798| 47| break; 799| 50| } 800| 61| case SvcParam::port: { ------------------ | Branch (800:5): [True: 61, False: 1.03k] ------------------ 801| 61| if (len != 2) { ------------------ | Branch (801:11): [True: 2, False: 59] ------------------ 802| 2| throw std::out_of_range("invalid length for port"); 803| 2| } 804| 59| uint16_t port; 805| 59| xfr16BitInt(port); 806| 59| kvs.insert(SvcParam(key, port)); 807| 59| break; 808| 61| } 809| 104| case SvcParam::ipv4hint: ------------------ | Branch (809:5): [True: 104, False: 992] ------------------ 810| 138| case SvcParam::ipv6hint: { ------------------ | Branch (810:5): [True: 34, False: 1.06k] ------------------ 811| 138| size_t addrLen = (key == SvcParam::ipv4hint ? 4 : 16); ------------------ | Branch (811:25): [True: 104, False: 34] ------------------ 812| 138| if (len % addrLen != 0) { ------------------ | Branch (812:11): [True: 3, False: 135] ------------------ 813| 3| throw std::out_of_range("invalid length for " + SvcParam::keyToString(key)); 814| 3| } 815| 135| vector addresses; 816| 135| auto stop = d_pos + len; 817| 14.1k| while (d_pos < stop) ------------------ | Branch (817:14): [True: 13.9k, False: 135] ------------------ 818| 13.9k| { 819| 13.9k| ComboAddress addr; 820| 13.9k| xfrCAWithoutPort(key, addr); 821| 13.9k| addresses.push_back(addr); 822| 13.9k| } 823| | // If there were no addresses, and the input comes from internal 824| | // representation, we can reasonably assume this is the serialization 825| | // of "auto". 826| 135| bool doAuto{d_internal && len == 0}; ------------------ | Branch (826:19): [True: 0, False: 135] | Branch (826:33): [True: 0, False: 0] ------------------ 827| 135| auto param = SvcParam(key, std::move(addresses)); 828| 135| param.setAutoHint(doAuto); 829| 135| kvs.insert(std::move(param)); 830| 135| break; 831| 138| } 832| 34| case SvcParam::ech: { ------------------ | Branch (832:5): [True: 34, False: 1.06k] ------------------ 833| 34| std::string blob; 834| 34| blob.reserve(len); 835| 34| xfrBlobNoSpaces(blob, len); 836| 34| kvs.insert(SvcParam(key, blob)); 837| 34| break; 838| 138| } 839| 128| case SvcParam::tls_supported_groups: { ------------------ | Branch (839:5): [True: 128, False: 968] ------------------ 840| 128| if (len % 2 != 0) { ------------------ | Branch (840:11): [True: 1, False: 127] ------------------ 841| 1| throw std::out_of_range("invalid length for " + SvcParam::keyToString(key)); 842| 1| } 843| 127| vector groups; 844| 127| groups.reserve(len / 2); 845| 127| auto stop = d_pos + len; 846| 67.0k| while (d_pos < stop) ------------------ | Branch (846:14): [True: 66.9k, False: 127] ------------------ 847| 66.9k| { 848| 66.9k| uint16_t group = 0; 849| 66.9k| xfr16BitInt(group); 850| 66.9k| groups.push_back(group); 851| 66.9k| } 852| 127| auto param = SvcParam(key, std::move(groups)); 853| 127| kvs.insert(std::move(param)); 854| 127| break; 855| 128| } 856| 334| default: { ------------------ | Branch (856:5): [True: 334, False: 762] ------------------ 857| 334| std::string blob; 858| 334| blob.reserve(len); 859| 334| xfrBlob(blob, len); 860| 334| kvs.insert(SvcParam(key, blob)); 861| 334| break; 862| 128| } 863| 1.09k| } 864| 1.09k| } 865| 1.01k|} _ZN12PacketReader10xfrHexBlobERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb: 869| 519|{ 870| 519| xfrBlob(blob); 871| 519|} _ZN9DNSRecordC2Ev: 337| 11.4k| d_class(QClass::IN) 338| 11.4k| {} _ZN15MOADNSExceptionC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 61| 2.56k| MOADNSException(const string& str) : runtime_error(str) 62| 2.56k| {} _ZN16DNSRecordContentD2Ev: 227| 10.7k| virtual ~DNSRecordContent() = default; _ZN12PacketReaderC2ERKNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEtbb: 72| 4.85k| : d_pos(initialPos), d_startrecordpos(initialPos), d_internal(internalRepresentation), d_standalone(standalone), d_content(content) 73| 4.85k| { 74| 4.85k| if(content.size() > std::numeric_limits::max()) ------------------ | Branch (74:8): [True: 0, False: 4.85k] ------------------ 75| 0| throw std::out_of_range("packet too large"); 76| | 77| 4.85k| d_recordlen = (uint16_t) content.size(); 78| 4.85k| } _ZNK12PacketReader11getPositionEv: 193| 11.4k| { 194| 11.4k| return d_pos; 195| 11.4k| } _ZN9DNSRecord10setContentEONSt3__110shared_ptrIK16DNSRecordContentEE: 393| 8.88k| { 394| 8.88k| d_content = std::move(content); 395| 8.88k| } _ZN12PacketReader11xfr16BitIntERt: 123| 280k| { 124| 280k| val=get16BitInt(); 125| 280k| } _ZN12PacketReader10xfr8BitIntERh: 134| 34.9k| { 135| 34.9k| val=get8BitInt(); 136| 34.9k| } _ZN12PacketReader16xfrCAWithoutPortEhR12ComboAddress: 102| 13.9k| void xfrCAWithoutPort(uint8_t version, ComboAddress &val) { 103| 13.9k| string blob; 104| 13.9k| if (version == 4) xfrBlob(blob, 4); ------------------ | Branch (104:9): [True: 11.5k, False: 2.40k] ------------------ 105| 2.40k| else if (version == 6) xfrBlob(blob, 16); ------------------ | Branch (105:14): [True: 2.40k, False: 0] ------------------ 106| 0| else throw runtime_error("invalid IP protocol"); 107| 13.9k| val = makeComboAddressFromRaw(version, blob); 108| 13.9k| } _ZN20UnknownRecordContentC2ERK9DNSRecordR12PacketReader: 491| 1.87k| : d_dr(dr) 492| 1.87k| { 493| 1.87k| pr.copyRecord(d_record, dr.d_clen); 494| 1.87k| } _ZN12PacketReader11xfr32BitIntERj: 88| 2.12k| { 89| 2.12k| val=get32BitInt(); 90| 2.12k| } _ZN12PacketReader5xfrIPERj: 93| 97| { 94| 97| xfr32BitInt(val); 95| | val=htonl(val); 96| 97| } _ZN12PacketReader6xfrIP6ERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 98| 74| void xfrIP6(std::string &val) { 99| 74| xfrBlob(val, 16); 100| 74| } _ZN12PacketReader7xfrTimeERj: 117| 282| { 118| 282| xfr32BitInt(val); 119| 282| } _ZN12PacketReader7xfrTypeERt: 128| 147| { 129| 147| xfr16BitInt(val); 130| 147| } _ZN12PacketReader7xfrNameER7DNSNameb: 139| 4.73k| { 140| 4.73k| name = getName(); 141| 4.73k| } _ZN12PacketReader7xfrTextERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEbb: 144| 1.21k| { 145| 1.21k| text=getText(multi, lenField); 146| 1.21k| } _ZN12PacketReader15xfrUnquotedTextERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb: 148| 447| void xfrUnquotedText(string &text, bool lenField){ 149| 447| text=getUnquotedText(lenField); 150| 447| } _ZNK12PacketReader3eofEv: 170| 7.61k| { 171| 7.61k| return d_pos >= (d_startrecordpos + d_recordlen); 172| 7.61k| } _ZNK12PacketReader12getRemainingEv: 176| 692| std::string getRemaining() const { 177| 692| 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)); 178| 692| }; _ZN12PacketReader16consumeRemainingEv: 187| 1.01k| { 188| 1.01k| d_pos = (d_startrecordpos + d_recordlen); 189| 1.01k| } _ZN16DNSRecordContent13doRecordCheckERK9DNSRecord: 264| 7.43k| void doRecordCheck(const struct DNSRecord&){} _ZN16DNSRecordContent6registEttPFNSt3__110shared_ptrIS_EERK9DNSRecordR12PacketReaderEPFS2_RKNS0_12basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEEPKc: 270| 118| { 271| 118| assert(!d_locked.load()); // NOLINT: it's the API ------------------ | Branch (271:5): [True: 118, False: 0] ------------------ 272| 118| if(f) ------------------ | Branch (272:8): [True: 115, False: 3] ------------------ 273| 115| getTypemap()[pair(cl,ty)]=f; 274| 118| if(z) ------------------ | Branch (274:8): [True: 115, False: 3] ------------------ 275| 115| getZmakermap()[pair(cl,ty)]=z; 276| | 277| 118| getT2Namemap().emplace(pair(cl, ty), name); 278| 118| getN2Typemap().emplace(name, pair(cl, ty)); 279| 118| } _ZN16DNSRecordContent4lockEv: 316| 1| { 317| 1| d_locked.store(true); 318| 1| } _ZN12MOADNSParserC2EbPKcj: 531| 4.85k| MOADNSParser(bool query, const char *packet, unsigned int len) : d_tsigPos(0) 532| 4.85k| { 533| 4.85k| init(query, std::string_view(packet, len)); 534| 4.85k| } _ZN14ARecordContent13doRecordCheckERK9DNSRecord: 141| 52|{ 142| 52| if(dr.d_clen!=4) ------------------ | Branch (142:6): [True: 30, False: 22] ------------------ 143| 30| throw MOADNSException("Wrong size for A record ("+std::to_string(dr.d_clen)+")"); 144| 52|} _ZN19DNSKEYRecordContentC2Ev: 463| 95|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: 6, False: 60] ------------------ 506| 6| throw MOADNSException("Wrong size for EUI48 record"); 507| | 508| 60| auto ret=std::make_shared(); 509| 60| pr.copyRecord((uint8_t*) &ret->d_eui48, 6); 510| 60| if (!pr.eof()) { ------------------ | Branch (510:9): [True: 0, False: 60] ------------------ 511| 0| throw MOADNSException("When parsing EUI48 trailing data was not parsed: '" + pr.getRemaining() + "'"); 512| 0| } 513| 60| return ret; 514| 60|} _ZN18EUI64RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 547| 1|{ 548| 1| regist(1, QType::EUI64, &make, &make, "EUI64"); 549| 1|} _ZN18EUI64RecordContent4makeERK9DNSRecordR12PacketReader: 551| 59|{ 552| 59| if(dr.d_clen!=8) ------------------ | Branch (552:8): [True: 16, False: 43] ------------------ 553| 16| throw MOADNSException("Wrong size for EUI64 record"); 554| | 555| 43| auto ret=std::make_shared(); 556| 43| pr.copyRecord((uint8_t*) &ret->d_eui64, 8); 557| 43| if (!pr.eof()) { ------------------ | Branch (557:9): [True: 0, False: 43] ------------------ 558| 0| throw MOADNSException("When parsing EUI64 trailing data was not parsed: '" + pr.getRemaining() + "'"); 559| 0| } 560| 43| return ret; 561| 43|} _ZN16APLRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 596| 1|{ 597| 1| regist(1, QType::APL, &make, &make, "APL"); 598| 1|} _ZN16APLRecordContent4makeERK9DNSRecordR12PacketReader: 601| 225|std::shared_ptr APLRecordContent::make(const DNSRecord &dr, PacketReader& pr) { 602| 225| uint8_t temp; 603| 225| APLRDataElement ard; 604| 225| size_t processed = 0; 605| | 606| 225| auto ret=std::make_shared(); 607| | 608| 3.42k| while (processed> 7; 616| 3.27k| ard.d_afdlength = temp & 127; 617| | 618| 3.27k| if (ard.d_afdlength > dr.d_clen - processed - 4) { ------------------ | Branch (618:9): [True: 11, False: 3.26k] ------------------ 619| 11| throw MOADNSException("Malformed APL record, address data extends beyond record length"); 620| 11| } 621| | 622| 3.26k| if (ard.d_family == APL_FAMILY_IPV4) { ------------------ | | 1201| 3.26k|#define APL_FAMILY_IPV4 1 ------------------ | Branch (622:9): [True: 1.94k, False: 1.32k] ------------------ 623| 1.94k| if (ard.d_afdlength > 4) { ------------------ | Branch (623:11): [True: 9, False: 1.93k] ------------------ 624| 9| throw MOADNSException("Invalid IP length for IPv4 APL"); 625| 9| } 626| 1.93k| memset(ard.d_ip.d_ip4, 0, sizeof(ard.d_ip.d_ip4)); 627| 3.61k| for (u_int i=0; i < ard.d_afdlength; i++) ------------------ | Branch (627:23): [True: 1.68k, False: 1.93k] ------------------ 628| 1.68k| pr.xfr8BitInt(ard.d_ip.d_ip4[i]); 629| 1.93k| } else if (ard.d_family == APL_FAMILY_IPV6) { ------------------ | | 1202| 1.32k|#define APL_FAMILY_IPV6 2 ------------------ | Branch (629:16): [True: 1.26k, False: 55] ------------------ 630| 1.26k| if (ard.d_afdlength > 16) { ------------------ | Branch (630:11): [True: 4, False: 1.26k] ------------------ 631| 4| throw MOADNSException("Invalid IP length for IPv6 APL"); 632| 4| } 633| 1.26k| memset(ard.d_ip.d_ip6, 0, sizeof(ard.d_ip.d_ip6)); 634| 2.08k| for (u_int i=0; i < ard.d_afdlength; i++) ------------------ | Branch (634:23): [True: 820, False: 1.26k] ------------------ 635| 820| pr.xfr8BitInt(ard.d_ip.d_ip6[i]); 636| 1.26k| } else { 637| 55| throw MOADNSException("Unknown family for APL record"); 638| 55| } 639| | 640| 3.19k| processed += 4 + ard.d_afdlength; 641| | 642| 3.19k| ret->aplrdata.push_back(ard); 643| 3.19k| } 644| 133| if (!pr.eof()) { ------------------ | Branch (644:7): [True: 0, False: 133] ------------------ 645| 0| throw MOADNSException("When parsing APL trailing data was not parsed: '" + pr.getRemaining() + "'"); 646| 0| } 647| | 648| 133| return ret; 649| 133|} _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| 52|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 52|{ \ 1293| 52| return std::make_shared(dr, pr); \ 1294| 52|} \ _ZN14ARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 52|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 52|{ \ 1298| 52| doRecordCheck(dr); \ 1299| 52| xfrPacket(pr); \ 1300| 52|} \ _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| 63|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 63|{ \ 1293| 63| return std::make_shared(dr, pr); \ 1294| 63|} \ _ZN17AAAARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 63|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 63|{ \ 1298| 63| doRecordCheck(dr); \ 1299| 63| xfrPacket(pr); \ 1300| 63|} \ _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| 146|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 146|{ \ 1293| 146| return std::make_shared(dr, pr); \ 1294| 146|} \ _ZN15NSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 146|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 146|{ \ 1298| 146| doRecordCheck(dr); \ 1299| 146| xfrPacket(pr); \ 1300| 146|} \ _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| 67|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 67|{ \ 1293| 67| return std::make_shared(dr, pr); \ 1294| 67|} \ _ZN16PTRRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 67|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 67|{ \ 1298| 67| doRecordCheck(dr); \ 1299| 67| xfrPacket(pr); \ 1300| 67|} \ _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| 118|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 118|{ \ 1293| 118| return std::make_shared(dr, pr); \ 1294| 118|} \ _ZN18CNAMERecordContentC2ERK9DNSRecordR12PacketReader: 1296| 118|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 118|{ \ 1298| 118| doRecordCheck(dr); \ 1299| 118| xfrPacket(pr); \ 1300| 118|} \ _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| 80|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 80|{ \ 1293| 80| return std::make_shared(dr, pr); \ 1294| 80|} \ _ZN18ALIASRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 80|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 80|{ \ 1298| 80| doRecordCheck(dr); \ 1299| 80| xfrPacket(pr); \ 1300| 80|} \ _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| 100|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 100|{ \ 1293| 100| return std::make_shared(dr, pr); \ 1294| 100|} \ _ZN18DNAMERecordContentC2ERK9DNSRecordR12PacketReader: 1296| 100|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 100|{ \ 1298| 100| doRecordCheck(dr); \ 1299| 100| xfrPacket(pr); \ 1300| 100|} \ _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| 110|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 110|{ \ 1293| 110| return std::make_shared(dr, pr); \ 1294| 110|} \ _ZN15MBRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 110|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 110|{ \ 1298| 110| doRecordCheck(dr); \ 1299| 110| xfrPacket(pr); \ 1300| 110|} \ _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| 128|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 128|{ \ 1293| 128| return std::make_shared(dr, pr); \ 1294| 128|} \ _ZN15MGRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 128|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 128|{ \ 1298| 128| doRecordCheck(dr); \ 1299| 128| xfrPacket(pr); \ 1300| 128|} \ _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| 89|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 89|{ \ 1293| 89| return std::make_shared(dr, pr); \ 1294| 89|} \ _ZN15MRRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 89|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 89|{ \ 1298| 89| doRecordCheck(dr); \ 1299| 89| xfrPacket(pr); \ 1300| 89|} \ _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| 233|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 233|{ \ 1293| 233| return std::make_shared(dr, pr); \ 1294| 233|} \ _ZN18MINFORecordContentC2ERK9DNSRecordR12PacketReader: 1296| 233|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 233|{ \ 1298| 233| doRecordCheck(dr); \ 1299| 233| xfrPacket(pr); \ 1300| 233|} \ _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| 60|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 60|{ \ 1293| 60| return std::make_shared(dr, pr); \ 1294| 60|} \ _ZN16TXTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 60|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 60|{ \ 1298| 60| doRecordCheck(dr); \ 1299| 60| xfrPacket(pr); \ 1300| 60|} \ _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.01k|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 1.01k|{ \ 1293| 1.01k| return std::make_shared(dr, pr); \ 1294| 1.01k|} \ _ZN16ENTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 1.01k|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 1.01k|{ \ 1298| 1.01k| doRecordCheck(dr); \ 1299| 1.01k| xfrPacket(pr); \ 1300| 1.01k|} \ _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| 61|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 61|{ \ 1293| 61| return std::make_shared(dr, pr); \ 1294| 61|} \ _ZN18HINFORecordContentC2ERK9DNSRecordR12PacketReader: 1296| 61|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 61|{ \ 1298| 61| doRecordCheck(dr); \ 1299| 61| xfrPacket(pr); \ 1300| 61|} \ _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| 131|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 131|{ \ 1293| 131| return std::make_shared(dr, pr); \ 1294| 131|} \ _ZN15RPRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 131|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 131|{ \ 1298| 131| doRecordCheck(dr); \ 1299| 131| xfrPacket(pr); \ 1300| 131|} \ _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| 501|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 501|{ \ 1293| 501| return std::make_shared(dr, pr); \ 1294| 501|} \ _ZN16OPTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 501|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 501|{ \ 1298| 501| doRecordCheck(dr); \ 1299| 501| xfrPacket(pr); \ 1300| 501|} \ _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| 75|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 75|{ \ 1293| 75| return std::make_shared(dr, pr); \ 1294| 75|} \ _ZN19WALLETRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 75|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 75|{ \ 1298| 75| doRecordCheck(dr); \ 1299| 75| xfrPacket(pr); \ 1300| 75|} \ _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| 154|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 154|{ \ 1293| 154| return std::make_shared(dr, pr); \ 1294| 154|} \ _ZN17TSIGRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 154|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 154|{ \ 1298| 154| doRecordCheck(dr); \ 1299| 154| xfrPacket(pr); \ 1300| 154|} \ _ZN15MXRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 100|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 100|{ \ 1293| 100| return std::make_shared(dr, pr); \ 1294| 100|} \ _ZN15MXRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 100|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 100|{ \ 1298| 100| doRecordCheck(dr); \ 1299| 100| xfrPacket(pr); \ 1300| 100|} \ _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| 91|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 91|{ \ 1293| 91| return std::make_shared(dr, pr); \ 1294| 91|} \ _ZN15KXRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 91|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 91|{ \ 1298| 91| doRecordCheck(dr); \ 1299| 91| xfrPacket(pr); \ 1300| 91|} \ _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| 160|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 160|{ \ 1293| 160| return std::make_shared(dr, pr); \ 1294| 160|} \ _ZN21IPSECKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 160|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 160|{ \ 1298| 160| doRecordCheck(dr); \ 1299| 160| xfrPacket(pr); \ 1300| 160|} \ _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| 71|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 71|{ \ 1293| 71| return std::make_shared(dr, pr); \ 1294| 71|} \ _ZN18DHCIDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 71|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 71|{ \ 1298| 71| doRecordCheck(dr); \ 1299| 71| xfrPacket(pr); \ 1300| 71|} \ _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| 74|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 74|{ \ 1293| 74| return std::make_shared(dr, pr); \ 1294| 74|} \ _ZN18AFSDBRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 74|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 74|{ \ 1298| 74| doRecordCheck(dr); \ 1299| 74| xfrPacket(pr); \ 1300| 74|} \ _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| 103|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 103|{ \ 1293| 103| return std::make_shared(dr, pr); \ 1294| 103|} \ _ZN18NAPTRRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 103|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 103|{ \ 1298| 103| doRecordCheck(dr); \ 1299| 103| xfrPacket(pr); \ 1300| 103|} \ _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| 82|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 82|{ \ 1293| 82| return std::make_shared(dr, pr); \ 1294| 82|} \ _ZN16SRVRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 82|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 82|{ \ 1298| 82| doRecordCheck(dr); \ 1299| 82| xfrPacket(pr); \ 1300| 82|} \ _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| 185|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 185|{ \ 1293| 185| return std::make_shared(dr, pr); \ 1294| 185|} \ _ZN16SOARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 185|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 185|{ \ 1298| 185| doRecordCheck(dr); \ 1299| 185| xfrPacket(pr); \ 1300| 185|} \ _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| 51|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 51|{ \ 1293| 51| return std::make_shared(dr, pr); \ 1294| 51|} \ _ZN16KEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 51|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 51|{ \ 1298| 51| doRecordCheck(dr); \ 1299| 51| xfrPacket(pr); \ 1300| 51|} \ _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| 78|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 78|{ \ 1293| 78| return std::make_shared(dr, pr); \ 1294| 78|} \ _ZN19ZONEMDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 78|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 78|{ \ 1298| 78| doRecordCheck(dr); \ 1299| 78| xfrPacket(pr); \ 1300| 78|} \ _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| 66|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 66|{ \ 1293| 66| return std::make_shared(dr, pr); \ 1294| 66|} \ _ZN17CERTRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 66|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 66|{ \ 1298| 66| doRecordCheck(dr); \ 1299| 66| xfrPacket(pr); \ 1300| 66|} \ _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| 44|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 44|{ \ 1293| 44| return std::make_shared(dr, pr); \ 1294| 44|} \ _ZN17TLSARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 44|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 44|{ \ 1298| 44| doRecordCheck(dr); \ 1299| 44| xfrPacket(pr); \ 1300| 44|} \ _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| 50|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 50|{ \ 1293| 50| return std::make_shared(dr, pr); \ 1294| 50|} \ _ZN23OPENPGPKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 50|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 50|{ \ 1298| 50| doRecordCheck(dr); \ 1299| 50| xfrPacket(pr); \ 1300| 50|} \ _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| 697|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 697|{ \ 1293| 697| return std::make_shared(dr, pr); \ 1294| 697|} \ _ZN17SVCBRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 697|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 697|{ \ 1298| 697| doRecordCheck(dr); \ 1299| 697| xfrPacket(pr); \ 1300| 697|} \ _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| 484|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 484|{ \ 1293| 484| return std::make_shared(dr, pr); \ 1294| 484|} \ _ZN18HTTPSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 484|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 484|{ \ 1298| 484| doRecordCheck(dr); \ 1299| 484| xfrPacket(pr); \ 1300| 484|} \ _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| 47|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 47|{ \ 1293| 47| return std::make_shared(dr, pr); \ 1294| 47|} \ _ZN17HHITRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 47|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 47|{ \ 1298| 47| doRecordCheck(dr); \ 1299| 47| xfrPacket(pr); \ 1300| 47|} \ _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| 48|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 48|{ \ 1293| 48| return std::make_shared(dr, pr); \ 1294| 48|} \ _ZN17BRIDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 48|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 48|{ \ 1298| 48| doRecordCheck(dr); \ 1299| 48| xfrPacket(pr); \ 1300| 48|} \ _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| 57|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 57|{ \ 1293| 57| return std::make_shared(dr, pr); \ 1294| 57|} \ _ZN19SMIMEARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 57|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 57|{ \ 1298| 57| doRecordCheck(dr); \ 1299| 57| xfrPacket(pr); \ 1300| 57|} \ _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| 56|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 56|{ \ 1293| 56| return std::make_shared(dr, pr); \ 1294| 56|} \ _ZN15DSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 56|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 56|{ \ 1298| 56| doRecordCheck(dr); \ 1299| 56| xfrPacket(pr); \ 1300| 56|} \ _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| 92|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 92|{ \ 1293| 92| return std::make_shared(dr, pr); \ 1294| 92|} \ _ZN16CDSRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 92|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 92|{ \ 1298| 92| doRecordCheck(dr); \ 1299| 92| xfrPacket(pr); \ 1300| 92|} \ _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| 64|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 64|{ \ 1293| 64| return std::make_shared(dr, pr); \ 1294| 64|} \ _ZN16DLVRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 64|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 64|{ \ 1298| 64| doRecordCheck(dr); \ 1299| 64| xfrPacket(pr); \ 1300| 64|} \ _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| 80|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 80|{ \ 1293| 80| return std::make_shared(dr, pr); \ 1294| 80|} \ _ZN18SSHFPRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 80|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 80|{ \ 1298| 80| doRecordCheck(dr); \ 1299| 80| xfrPacket(pr); \ 1300| 80|} \ _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| 147|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 147|{ \ 1293| 147| return std::make_shared(dr, pr); \ 1294| 147|} \ _ZN18RRSIGRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 147|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 147|{ \ 1298| 147| doRecordCheck(dr); \ 1299| 147| xfrPacket(pr); \ 1300| 147|} \ _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| 66|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 66|{ \ 1293| 66| return std::make_shared(dr, pr); \ 1294| 66|} \ _ZN19DNSKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 66|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 66|{ \ 1298| 66| doRecordCheck(dr); \ 1299| 66| xfrPacket(pr); \ 1300| 66|} \ _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| 55|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 55|{ \ 1293| 55| return std::make_shared(dr, pr); \ 1294| 55|} \ _ZN20CDNSKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 55|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 55|{ \ 1298| 55| doRecordCheck(dr); \ 1299| 55| xfrPacket(pr); \ 1300| 55|} \ _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| 41|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 41|{ \ 1293| 41| return std::make_shared(dr, pr); \ 1294| 41|} \ _ZN17RKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 41|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 41|{ \ 1298| 41| doRecordCheck(dr); \ 1299| 41| xfrPacket(pr); \ 1300| 41|} \ _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| 80|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 80|{ \ 1293| 80| return std::make_shared(dr, pr); \ 1294| 80|} \ _ZN16NIDRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 80|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 80|{ \ 1298| 80| doRecordCheck(dr); \ 1299| 80| xfrPacket(pr); \ 1300| 80|} \ _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| 66|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 66|{ \ 1293| 66| return std::make_shared(dr, pr); \ 1294| 66|} \ _ZN16L32RecordContentC2ERK9DNSRecordR12PacketReader: 1296| 66|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 66|{ \ 1298| 66| doRecordCheck(dr); \ 1299| 66| xfrPacket(pr); \ 1300| 66|} \ _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| 72|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 72|{ \ 1293| 72| return std::make_shared(dr, pr); \ 1294| 72|} \ _ZN16L64RecordContentC2ERK9DNSRecordR12PacketReader: 1296| 72|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 72|{ \ 1298| 72| doRecordCheck(dr); \ 1299| 72| xfrPacket(pr); \ 1300| 72|} \ _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| 82|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 82|{ \ 1293| 82| return std::make_shared(dr, pr); \ 1294| 82|} \ _ZN15LPRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 82|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 82|{ \ 1298| 82| doRecordCheck(dr); \ 1299| 82| xfrPacket(pr); \ 1300| 82|} \ _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| 185|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 185|{ \ 1293| 185| return std::make_shared(dr, pr); \ 1294| 185|} \ _ZN17TKEYRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 185|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 185|{ \ 1298| 185| doRecordCheck(dr); \ 1299| 185| xfrPacket(pr); \ 1300| 185|} \ _ZN16URIRecordContent4makeERK9DNSRecordR12PacketReader: 1291| 182|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 182|{ \ 1293| 182| return std::make_shared(dr, pr); \ 1294| 182|} \ _ZN16URIRecordContentC2ERK9DNSRecordR12PacketReader: 1296| 182|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 182|{ \ 1298| 182| doRecordCheck(dr); \ 1299| 182| xfrPacket(pr); \ 1300| 182|} \ _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| 451|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 451|{ \ 1293| 451| return std::make_shared(dr, pr); \ 1294| 451|} \ _ZN16CAARecordContentC2ERK9DNSRecordR12PacketReader: 1296| 451|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 451|{ \ 1298| 451| doRecordCheck(dr); \ 1299| 451| xfrPacket(pr); \ 1300| 451|} \ _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| 45|std::shared_ptr RNAME##RecordContent::make(const DNSRecord& dr, PacketReader& pr) \ 1292| 45|{ \ 1293| 45| return std::make_shared(dr, pr); \ 1294| 45|} \ _ZN20RESINFORecordContentC2ERK9DNSRecordR12PacketReader: 1296| 45|RNAME##RecordContent::RNAME##RecordContent(const DNSRecord& dr, PacketReader& pr) \ 1297| 45|{ \ 1298| 45| doRecordCheck(dr); \ 1299| 45| xfrPacket(pr); \ 1300| 45|} \ _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| 22|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 22|{ \ 1343| 22| CONV; \ 1344| 22| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 22] ------------------ 1345| 22|} \ _ZN17AAAARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 63|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 63|{ \ 1343| 63| CONV; \ 1344| 63| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 28, False: 35] ------------------ 1345| 63|} \ _ZN15NSRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 146|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 146|{ \ 1343| 146| CONV; \ 1344| 146| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 46, False: 100] ------------------ 1345| 146|} \ _ZN16PTRRecordContent9xfrPacketI12PacketReaderEEvRT_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: 10, False: 57] ------------------ 1345| 67|} \ _ZN18CNAMERecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 118|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 118|{ \ 1343| 118| CONV; \ 1344| 118| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 26, False: 92] ------------------ 1345| 118|} \ _ZN18ALIASRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 80|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 80|{ \ 1343| 80| CONV; \ 1344| 80| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 30, False: 50] ------------------ 1345| 80|} \ _ZN18DNAMERecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 100|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 100|{ \ 1343| 100| CONV; \ 1344| 100| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 28, False: 72] ------------------ 1345| 100|} \ _ZN15MBRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 110|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 110|{ \ 1343| 110| CONV; \ 1344| 110| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 33, False: 77] ------------------ 1345| 110|} \ _ZN15MGRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 128|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 128|{ \ 1343| 128| CONV; \ 1344| 128| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 103] ------------------ 1345| 128|} \ _ZN15MRRecordContent9xfrPacketI12PacketReaderEEvRT_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: 6, False: 83] ------------------ 1345| 89|} \ _ZN18MINFORecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 233|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 233|{ \ 1343| 233| CONV; \ 1344| 233| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 27, False: 206] ------------------ 1345| 233|} \ _ZN16TXTRecordContent9xfrPacketI12PacketReaderEEvRT_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|} \ _ZN16ENTRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 1.01k|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 1.01k|{ \ 1343| 1.01k| CONV; \ 1344| 1.01k| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 1.01k] ------------------ 1345| 1.01k|} \ _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| 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: 9, False: 52] ------------------ 1345| 61|} \ _ZN15RPRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 131|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 131|{ \ 1343| 131| CONV; \ 1344| 131| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 23, False: 108] ------------------ 1345| 131|} \ _ZN16OPTRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 501|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 501|{ \ 1343| 501| CONV; \ 1344| 501| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 501] ------------------ 1345| 501|} \ _ZN19WALLETRecordContent9xfrPacketI12PacketReaderEEvRT_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: 0, False: 75] ------------------ 1345| 75|} \ _ZN17TSIGRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 154|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 154|{ \ 1343| 420| CONV; \ ------------------ | Branch (1343:3): [True: 67, False: 87] | Branch (1343:3): [True: 45, False: 109] ------------------ 1344| 154| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 28, False: 126] ------------------ 1345| 154|} \ _ZN15MXRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 100|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 100|{ \ 1343| 100| CONV; \ 1344| 100| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 24, False: 76] ------------------ 1345| 100|} \ _ZN15KXRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 91|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 91|{ \ 1343| 91| CONV; \ 1344| 91| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 21, False: 70] ------------------ 1345| 91|} \ _ZN21IPSECKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 160|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 160|{ \ 1343| 160| CONV; \ ------------------ | Branch (1343:3): [True: 6, False: 154] | Branch (1343:3): [True: 32, False: 128] | Branch (1343:3): [True: 11, False: 149] | Branch (1343:3): [True: 13, False: 147] | Branch (1343:3): [True: 93, False: 67] | Branch (1343:3): [True: 2, False: 135] | Branch (1343:3): [True: 17, False: 120] | Branch (1343:3): [True: 48, False: 89] | Branch (1343:3): [True: 70, False: 67] ------------------ 1344| 135| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 23, False: 112] ------------------ 1345| 135|} \ _ZN18DHCIDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 71|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 71|{ \ 1343| 71| CONV; \ 1344| 71| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 71] ------------------ 1345| 71|} \ _ZN18AFSDBRecordContent9xfrPacketI12PacketReaderEEvRT_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: 22, False: 52] ------------------ 1345| 74|} \ _ZN18NAPTRRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 103|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 103|{ \ 1343| 103| CONV; \ 1344| 103| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 30, False: 73] ------------------ 1345| 103|} \ _ZN16SRVRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 82|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 82|{ \ 1343| 82| CONV; \ 1344| 82| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 24, False: 58] ------------------ 1345| 82|} \ _ZN16SOARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 185|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 185|{ \ 1343| 185| CONV; \ 1344| 185| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 160] ------------------ 1345| 185|} \ _ZN16KEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 51|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 51|{ \ 1343| 51| CONV; \ 1344| 51| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 51] ------------------ 1345| 51|} \ _ZN19ZONEMDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 78|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 78|{ \ 1343| 78| CONV; \ 1344| 78| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 78] ------------------ 1345| 78|} \ _ZN17CERTRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 66|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 66|{ \ 1343| 67| CONV; \ ------------------ | Branch (1343:3): [True: 1, False: 65] ------------------ 1344| 65| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 65] ------------------ 1345| 65|} \ _ZN17TLSARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 44|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 44|{ \ 1343| 44| CONV; \ 1344| 44| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 44] ------------------ 1345| 44|} \ _ZN23OPENPGPKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 50|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 50|{ \ 1343| 50| CONV; \ 1344| 50| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 50] ------------------ 1345| 50|} \ _ZN17SVCBRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 697|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 697|{ \ 1343| 1.28k| CONV; \ ------------------ | Branch (1343:3): [True: 588, False: 109] ------------------ 1344| 697| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 18, False: 679] ------------------ 1345| 697|} \ _ZN18HTTPSRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 484|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 484|{ \ 1343| 906| CONV; \ ------------------ | Branch (1343:3): [True: 422, False: 62] ------------------ 1344| 484| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 20, False: 464] ------------------ 1345| 484|} \ _ZN17HHITRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 47|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 47|{ \ 1343| 47| CONV; \ 1344| 47| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 47] ------------------ 1345| 47|} \ _ZN17BRIDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 48|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 48|{ \ 1343| 48| CONV; \ 1344| 48| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 48] ------------------ 1345| 48|} \ _ZN19SMIMEARecordContent9xfrPacketI12PacketReaderEEvRT_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: 0, False: 57] ------------------ 1345| 57|} \ _ZN15DSRecordContent9xfrPacketI12PacketReaderEEvRT_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|} \ _ZN16CDSRecordContent9xfrPacketI12PacketReaderEEvRT_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: 0, False: 92] ------------------ 1345| 92|} \ _ZN16DLVRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 64|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 64|{ \ 1343| 64| CONV; \ 1344| 64| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 64] ------------------ 1345| 64|} \ _ZN18SSHFPRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 80|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 80|{ \ 1343| 80| CONV; \ 1344| 80| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 80] ------------------ 1345| 80|} \ _ZN18RRSIGRecordContent9xfrPacketI12PacketReaderEEvRT_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: 0, False: 147] ------------------ 1345| 147|} \ _ZN19DNSKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 66|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 66|{ \ 1343| 66| CONV; \ 1344| 66| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 66] ------------------ 1345| 66|} \ _ZN20CDNSKEYRecordContent9xfrPacketI12PacketReaderEEvRT_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|} \ _ZN17RKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 41|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 41|{ \ 1343| 41| CONV; \ 1344| 41| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 41] ------------------ 1345| 41|} \ _ZN16NIDRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 80|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 80|{ \ 1343| 80| CONV; \ 1344| 80| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 36, False: 44] ------------------ 1345| 80|} \ _ZN16L32RecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 66|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 66|{ \ 1343| 66| CONV; \ 1344| 66| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 29, False: 37] ------------------ 1345| 66|} \ _ZN16L64RecordContent9xfrPacketI12PacketReaderEEvRT_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: 27, False: 45] ------------------ 1345| 72|} \ _ZN15LPRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 82|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 82|{ \ 1343| 82| CONV; \ 1344| 82| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 20, False: 62] ------------------ 1345| 82|} \ _ZN18EUI48RecordContentC2Ev: 1166| 60| EUI48RecordContent() = default; _ZN18EUI64RecordContentC2Ev: 1185| 43| EUI64RecordContent() = default; _ZN16APLRecordContentC2Ev: 1216| 225| APLRecordContent() = default; _ZN17TKEYRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 185|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 185|{ \ 1343| 552| CONV; \ ------------------ | Branch (1343:3): [True: 98, False: 87] | Branch (1343:3): [True: 84, False: 101] ------------------ 1344| 185| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 25, False: 160] ------------------ 1345| 185|} \ _ZN16URIRecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 182|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 182|{ \ 1343| 182| CONV; \ 1344| 182| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 182] ------------------ 1345| 182|} \ _ZN16CAARecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 451|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 451|{ \ 1343| 451| CONV; \ 1344| 451| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 451] ------------------ 1345| 451|} \ _ZN20RESINFORecordContent9xfrPacketI12PacketReaderEEvRT_b: 1341| 45|void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \ 1342| 45|{ \ 1343| 45| CONV; \ 1344| 45| if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \ ------------------ | Branch (1344:7): [True: 0, False: 45] ------------------ 1345| 45|} \ _ZN10NSECBitmapC2Ev: 820| 905| NSECBitmap(): d_bitset(nullptr) 821| 905| { 822| 905| } _ZN10NSECBitmap3setEt: 851| 81.1k| { 852| 81.1k| if (!d_bitset) { ------------------ | Branch (852:9): [True: 79.0k, False: 2.11k] ------------------ 853| 79.0k| if (d_set.size() >= 200) { ------------------ | Branch (853:11): [True: 140, False: 78.8k] ------------------ 854| 140| migrateToBitSet(); 855| 140| } 856| 79.0k| } 857| 81.1k| if (d_bitset) { ------------------ | Branch (857:9): [True: 2.25k, False: 78.8k] ------------------ 858| 2.25k| d_bitset->set(type); 859| 2.25k| } 860| 78.8k| else { 861| 78.8k| d_set.insert(type); 862| 78.8k| } 863| 81.1k| } _ZN10NSECBitmap15migrateToBitSetEv: 891| 140| { 892| 140| d_bitset = std::make_unique>(); 893| 28.0k| for (const auto& type : d_set) { ------------------ | Branch (893:27): [True: 28.0k, False: 140] ------------------ 894| 28.0k| d_bitset->set(type); 895| 28.0k| } 896| 140| d_set.clear(); 897| 140| } _ZN17NSECRecordContentC2Ev: 911| 640| NSECRecordContent() = default; _ZN18NSEC3RecordContentC2Ev: 952| 163| NSEC3RecordContent() = default; _ZN23NSEC3PARAMRecordContentC2Ev: 1035| 91| NSEC3PARAMRecordContent() = default; _ZN18CSYNCRecordContentC2Ev: 1002| 102| CSYNCRecordContent() = default; _ZN16LOCRecordContentC2Ev: 1063| 82| LOCRecordContent() = default; _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEEC2ERS4_RK7DNSNametth: 43| 4.89k| d_qname(qname), d_content(content) 44| 4.89k|{ 45| 4.89k| d_content.clear(); 46| 4.89k| dnsheader dnsheader; 47| | 48| 4.89k| memset(&dnsheader, 0, sizeof(dnsheader)); 49| 4.89k| dnsheader.id=0; 50| 4.89k| dnsheader.qdcount=htons(1); 51| 4.89k| dnsheader.opcode=opcode; 52| | 53| 4.89k| const uint8_t* ptr=(const uint8_t*)&dnsheader; 54| 4.89k| d_content.reserve(sizeof(dnsheader) + qname.wirelength() + sizeof(qtype) + sizeof(qclass)); 55| 4.89k| d_content.resize(sizeof(dnsheader)); 56| 4.89k| uint8_t* dptr=(&*d_content.begin()); 57| | 58| 4.89k| memcpy(dptr, ptr, sizeof(dnsheader)); 59| 4.89k| d_namepositions.reserve(16); 60| 4.89k| xfrName(qname, false); 61| 4.89k| xfr16BitInt(qtype); 62| 4.89k| xfr16BitInt(qclass); 63| | 64| 4.89k| if (d_content.size() > std::numeric_limits::max()) { ------------------ | Branch (64:7): [True: 0, False: 4.89k] ------------------ 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.89k| d_truncatemarker = d_content.size(); 68| 4.89k|} _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.04k] | Branch (85:19): [True: 6.93k, False: 5.07k] | 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.03k|{ 103| 1.03k| uint32_t ttl=0; 104| | 105| 1.03k| EDNS0Record stuff; 106| | 107| 1.03k| stuff.version = version; 108| 1.03k| 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.03k| stuff.extRCode = extRCode>>4; 118| 1.03k| if (extRCode != 0) { // As this trumps the existing RCODE ------------------ | Branch (118:7): [True: 0, False: 1.03k] ------------------ 119| 0| getHeader()->rcode = extRCode; 120| 0| } 121| | 122| 1.03k| static_assert(sizeof(EDNS0Record) == sizeof(ttl), "sizeof(EDNS0Record) must match sizeof(ttl)"); 123| 1.03k| memcpy(&ttl, &stuff, sizeof(stuff)); 124| | 125| 1.03k| ttl=ntohl(ttl); // will be reversed later on 126| | 127| 1.03k| startRecord(g_rootdnsname, QType::OPT, ttl, udpsize, DNSResourceRecord::ADDITIONAL, false); 128| 39.9k| for(auto const &option : options) { ------------------ | Branch (128:26): [True: 39.9k, False: 1.03k] ------------------ 129| 39.9k| xfr16BitInt(option.first); 130| 39.9k| xfr16BitInt(option.second.length()); 131| 39.9k| xfrBlob(option.second); 132| 39.9k| } 133| 1.03k|} _ZN22GenericDNSPacketWriterINSt3__16vectorIhNS0_9allocatorIhEEEEE6commitEv: 572| 17.9k|{ 573| 17.9k| if (d_sor == 0) { ------------------ | Branch (573:7): [True: 4.89k, False: 13.0k] ------------------ 574| 4.89k| return; 575| 4.89k| } 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: 40, False: 12.9k] ------------------ 582| 40| throw std::range_error("Trying to build a packet larger than " + std::to_string(std::numeric_limits::max()) + " bytes"); 583| 40| } 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| 11.9k| case DNSResourceRecord::ANSWER: ------------------ | Branch (594:3): [True: 11.9k, False: 1.00k] ------------------ 595| 11.9k| dh->ancount = htons(ntohs(dh->ancount) + 1); 596| 11.9k| 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| 1.00k| case DNSResourceRecord::ADDITIONAL: ------------------ | Branch (600:3): [True: 1.00k, False: 11.9k] ------------------ 601| 1.00k| dh->arcount = htons(ntohs(dh->arcount) + 1); 602| 1.00k| 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| 128k|{ 166| 128k| if (val > std::numeric_limits::max()) { ------------------ | Branch (166:7): [True: 0, False: 128k] ------------------ 167| 0| throw runtime_error("Value too large to fit in 16 bits"); 168| 0| } 169| 128k| uint16_t rval=htons(static_cast(val)); 170| 128k| uint8_t* ptr=reinterpret_cast(&rval); 171| 128k| d_content.insert(d_content.end(), ptr, ptr+2); 172| 128k|} _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.45k| d_content.push_back((char)(offset & 0xff)); 429| 3.45k| } 430| 3.48k| else { 431| 3.48k| unsigned int pos=d_content.size(); 432| 3.48k| if(l_verbose) ------------------ | Branch (432:8): [Folded, False: 3.48k] ------------------ 433| 0| cout<<"Found nothing, we are at pos "< lc; 441| 3.48k| if(d_lowerCase) ------------------ | Branch (441:8): [True: 0, False: 3.48k] ------------------ 442| 0| lc = make_unique(name.makeLowerCase()); 443| | 444| 3.48k| const DNSName::string_t& raw = (lc ? *lc : name).getStorage(); ------------------ | Branch (444:37): [True: 0, False: 3.48k] ------------------ 445| 3.48k| if(l_verbose) ------------------ | Branch (445:8): [Folded, False: 3.48k] ------------------ 446| 0| cout<<"Writing out the whole thing "<(blob.c_str()); 454| 51.9k| d_content.insert(d_content.end(), ptr, ptr+blob.size()); 455| 51.9k|} _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.3k| for(auto riter= raw.cbegin(); riter < raw.cend(); ) { ------------------ | Branch (246:35): [True: 25.3k, False: 0] ------------------ 247| 25.3k| 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.7k, False: 0] | Branch (294:63): [True: 23.7k, False: 0] | Branch (294:90): [True: 23.7k, False: 0] ------------------ 295| 23.7k| uint8_t labelLength = *iter; 296| 23.7k| const uint16_t currentPos = (iter - d_content.cbegin()); 297| 23.7k| if (l_verbose) { ------------------ | Branch (297:13): [Folded, False: 23.7k] ------------------ 298| 0| cout << "Found label length: " << std::to_string(labelLength) << " at " << currentPos << endl; 299| 0| } 300| 23.7k| if (labelLength & 0xc0) { ------------------ | Branch (300:13): [True: 2.56k, False: 21.1k] ------------------ 301| 2.56k| uint16_t npos = 0x100*(labelLength & (~0xc0)) + *++iter; 302| | // check against going forward 303| 2.56k| if (npos >= currentPos || npos < sizeof(dnsheader)) { ------------------ | Branch (303:15): [True: 0, False: 2.56k] | Branch (303:37): [True: 0, False: 2.56k] ------------------ 304| | /* something is not right */ 305| 0| break; 306| 0| } 307| | 308| | // jump to the target of the pointer 309| 2.56k| iter = d_content.begin() + npos; 310| 2.56k| if (l_verbose) { ------------------ | Branch (310:15): [Folded, False: 2.56k] ------------------ 311| 0| cout << "Is compressed label to newpos " << npos << ", going there" << endl; 312| 0| } 313| | 314| 2.56k| if (pointerQuota >= 1) { ------------------ | Branch (314:15): [True: 2.56k, False: 0] ------------------ 315| 2.56k| pointerQuota--; 316| 2.56k| continue; 317| 2.56k| } 318| | 319| | // out of pointer quota, let's stop there 320| 0| break; 321| 2.56k| } 322| | 323| 21.1k| if (labelLength == 0) { ------------------ | Branch (323:13): [True: 5.63k, False: 15.5k] ------------------ 324| 5.63k| break; 325| 5.63k| } 326| | 327| 15.5k| if (currentPos >= maxCompressionOffset) { ------------------ | Branch (327:13): [True: 37, False: 15.4k] ------------------ 328| 37| break; // compression pointers cannot point here 329| 37| } 330| | 331| 15.4k| positionsInPacket.push_back(currentPos); 332| | // jump to the next label 333| 15.4k| iter += labelLength + 1; 334| 15.4k| } 335| 5.67k| } 336| 5.67k| 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.67k| if (l_verbose) { ------------------ | Branch (343:9): [Folded, False: 5.67k] ------------------ 344| 0| cout<<"Packet vector: "< len) { ------------------ | Branch (169:7): [True: 3.75k, False: 1.15k] ------------------ 170| 3.75k| return EINVAL; 171| 3.75k| } 172| | 173| 42.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: 42.7k, False: 89] | Branch (173:76): [True: 42.3k, False: 336] ------------------ 174| 42.3k| const uint16_t optionCode = (((unsigned char)optRR[pos]) * 256) + ((unsigned char)optRR[pos + 1]); 175| 42.3k| pos += EDNS_OPTION_CODE_SIZE; 176| 42.3k| rdPos += EDNS_OPTION_CODE_SIZE; 177| 42.3k| const uint16_t optionLen = (((unsigned char)optRR[pos]) * 256) + ((unsigned char)optRR[pos + 1]); 178| 42.3k| pos += EDNS_OPTION_LENGTH_SIZE; 179| 42.3k| rdPos += EDNS_OPTION_LENGTH_SIZE; 180| 42.3k| if (optionLen > (rdLen - rdPos) || optionLen > (len - pos)) { ------------------ | Branch (180:9): [True: 727, False: 41.6k] | Branch (180:40): [True: 0, False: 41.6k] ------------------ 181| 727| return EINVAL; 182| 727| } 183| 41.6k| EDNSOptionViewValue value; 184| 41.6k| value.content = optRR + pos; 185| 41.6k| value.size = optionLen; 186| 41.6k| options[optionCode].values.push_back(value); 187| | 188| | /* skip this option */ 189| 41.6k| pos += optionLen; 190| 41.6k| rdPos += optionLen; 191| 41.6k| } 192| | 193| 425| return 0; 194| 1.15k|} _Z25getEDNSOptionsFromContentRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS_6vectorINS_4pairItS5_EENS3_ISA_EEEE: 197| 4.90k|{ 198| 4.90k| size_t pos = 0; 199| 4.90k| const size_t contentLength = content.size(); 200| | 201| 47.7k| while (pos < contentLength && (contentLength - pos) >= (EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE)) { ------------------ | Branch (201:10): [True: 47.5k, False: 198] | Branch (201:33): [True: 47.3k, False: 204] ------------------ 202| 47.3k| uint16_t code = (static_cast(content.at(pos)) * 256) + static_cast(content.at(pos + 1)); 203| 47.3k| pos += EDNS_OPTION_CODE_SIZE; 204| 47.3k| uint16_t len = (static_cast(content.at(pos)) * 256) + static_cast(content.at(pos + 1)); 205| 47.3k| pos += EDNS_OPTION_LENGTH_SIZE; 206| | 207| 47.3k| if (pos > contentLength || len > (contentLength - pos)) { ------------------ | Branch (207:9): [True: 0, False: 47.3k] | Branch (207:32): [True: 4.50k, False: 42.8k] ------------------ 208| 4.50k| return false; 209| 4.50k| } 210| | 211| 42.8k| options.emplace_back(code, std::string(&content.at(pos), len)); 212| 42.8k| pos += len; 213| 42.8k| } 214| | 215| 402| return true; 216| 4.90k|} LLVMFuzzerTestOneInput: 46| 4.90k|{ 47| 4.90k| static bool initialized = false; 48| | 49| 4.90k| if (!initialized) { ------------------ | Branch (49:7): [True: 1, False: 4.90k] ------------------ 50| 1| init(); 51| 1| initialized = true; 52| 1| } 53| | 54| 4.90k| if (size > std::numeric_limits::max()) { ------------------ | Branch (54:7): [True: 2, False: 4.90k] ------------------ 55| 2| return 0; 56| 2| } 57| | 58| | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 59| 4.90k| const char* chars = reinterpret_cast(data); 60| | 61| 4.90k| 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.90k| EDNSOptionViewMap viewOptions; 65| 4.90k| (void)getEDNSOptions(chars, size, viewOptions); 66| | 67| 4.90k| std::vector> options; 68| 4.90k| (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.90k| size_t pos = 0; 74| | // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) 75| 4.90k| const auto getU8 = [&]() -> uint8_t { return pos < size ? data[pos++] : 0; }; 76| 4.90k| const auto getU16 = [&]() -> uint16_t { 77| 4.90k| const uint16_t highV = getU8(); 78| 4.90k| return static_cast((highV << 8) | getU8()); 79| 4.90k| }; 80| | 81| 4.90k| const uint16_t qtype = getU16(); 82| 4.90k| const DNSName qname("."); 83| 4.90k| std::vector packet; 84| 4.90k| DNSPacketWriter writer(packet, qname, qtype); 85| | 86| 4.90k| static const std::array suffixes{".", "example.com.", "a.example.com.", "powerdns.com."}; 87| | 88| 4.90k| 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.14k] | Branch (89:45): [True: 12.0k, False: 3.76k] ------------------ 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| 46.0k| for (uint8_t j = 0; j < labelLen && pos < size; ++j) { ------------------ | Branch (94:27): [True: 34.4k, False: 11.6k] | Branch (94:43): [True: 34.0k, False: 352] ------------------ 95| 34.0k| label.push_back(static_cast('a' + (getU8() % 26))); 96| 34.0k| } 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: 9.05k, False: 2.96k] ------------------ 101| 9.05k| name = DNSName(suffix); 102| 9.05k| } 103| 2.96k| else { 104| 2.96k| label.append("."); 105| 2.96k| label.append(suffix); 106| 2.96k| name = DNSName(label); 107| 2.96k| } 108| 12.0k| } 109| 12.0k| catch (...) { 110| 706| name = qname; 111| 706| } 112| | 113| 12.0k| const uint16_t rtype = getU16(); 114| 12.0k| const uint16_t rdlen = getU16(); 115| 12.0k| std::string rdata; 116| 12.6M| for (uint16_t j = 0; j < rdlen && pos < size; ++j) { ------------------ | Branch (116:28): [True: 12.6M, False: 9.08k] | Branch (116:41): [True: 12.6M, False: 2.93k] ------------------ 117| 12.6M| rdata.push_back(static_cast(getU8())); 118| 12.6M| } 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.90k| if (!options.empty()) { ------------------ | Branch (125:9): [True: 1.03k, False: 3.87k] ------------------ 126| 1.03k| DNSPacketWriter::optvect_t optvect; 127| 39.9k| for (const auto& option : options) { ------------------ | Branch (127:31): [True: 39.9k, False: 1.03k] ------------------ 128| 39.9k| optvect.emplace_back(option.first, option.second); 129| 39.9k| } 130| 1.03k| writer.addOpt(1232, 0, 0, optvect); 131| 1.03k| } 132| 4.90k| writer.commit(); 133| | 134| | // Re-parse the writer's own output. 135| 4.90k| if (!packet.empty()) { ------------------ | Branch (135:9): [True: 4.85k, False: 55] ------------------ 136| | // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 137| 4.85k| MOADNSParser reparse(false, reinterpret_cast(packet.data()), packet.size()); 138| 4.85k| } 139| 4.90k| } 140| | // NOLINTNEXTLINE(bugprone-empty-catch) 141| 4.90k| catch (const std::exception& e) { 142| 2.61k| } 143| | // NOLINTNEXTLINE(bugprone-empty-catch) 144| 4.90k| catch (const PDNSException& e) { 145| 0| } 146| | 147| 4.90k| return 0; 148| 4.90k|} 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| 12.7M| const auto getU8 = [&]() -> uint8_t { return pos < size ? data[pos++] : 0; }; ------------------ | Branch (75:50): [True: 12.7M, False: 5.55k] ------------------ _ZN12ComboAddressC2Ev: 212| 27.9k| { 213| | sin4.sin_family = AF_INET; 214| 27.9k| sin4.sin_addr.s_addr = 0; 215| 27.9k| sin4.sin_port = 0; 216| 27.9k| sin6.sin6_scope_id = 0; 217| 27.9k| sin6.sin6_flowinfo = 0; 218| 27.9k| } _ZNK12ComboAddress6isIPv6Ev: 263| 2.40k| { 264| | return sin4.sin_family == AF_INET6; 265| 2.40k| } _ZNK12ComboAddress6isIPv4Ev: 267| 11.5k| { 268| | return sin4.sin_family == AF_INET; 269| 11.5k| } _Z23makeComboAddressFromRawhPKcm: 659| 13.9k|{ 660| 13.9k| ComboAddress address; 661| | 662| 13.9k| if (version == 4) { ------------------ | Branch (662:7): [True: 11.5k, False: 2.40k] ------------------ 663| 11.5k| address.sin4.sin_family = AF_INET; 664| 11.5k| if (len != sizeof(address.sin4.sin_addr)) { ------------------ | Branch (664:9): [True: 0, False: 11.5k] ------------------ 665| 0| throw NetmaskException("invalid raw address length"); 666| 0| } 667| 11.5k| memcpy(&address.sin4.sin_addr, raw, sizeof(address.sin4.sin_addr)); 668| 11.5k| } 669| 2.40k| else if (version == 6) { ------------------ | Branch (669:12): [True: 2.40k, False: 0] ------------------ 670| 2.40k| address.sin6.sin6_family = AF_INET6; 671| 2.40k| if (len != sizeof(address.sin6.sin6_addr)) { ------------------ | Branch (671:9): [True: 0, False: 2.40k] ------------------ 672| 0| throw NetmaskException("invalid raw address length"); 673| 0| } 674| 2.40k| memcpy(&address.sin6.sin6_addr, raw, sizeof(address.sin6.sin6_addr)); 675| 2.40k| } 676| 0| else { 677| 0| throw NetmaskException("invalid address family"); 678| 0| } 679| | 680| 13.9k| return address; 681| 13.9k|} _Z23makeComboAddressFromRawhRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 684| 13.9k|{ 685| 13.9k| return makeComboAddressFromRaw(version, str.c_str(), str.size()); 686| 13.9k|} _Z11makeHexDumpRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEES7_: 551| 692|{ 552| 692| std::array tmp{}; 553| 692| string ret; 554| 692| ret.reserve(static_cast(str.size() * (2 + sep.size()))); 555| | 556| 3.02M| for (char index : str) { ------------------ | Branch (556:19): [True: 3.02M, False: 692] ------------------ 557| 3.02M| snprintf(tmp.data(), tmp.size(), "%02x", static_cast(index)); 558| 3.02M| ret += tmp.data(); 559| 3.02M| ret += sep; 560| 3.02M| } 561| 692| return ret; 562| 692|} _ZN10NSECBitmap10fromPacketER12PacketReader: 99| 841|{ 100| 841| string bitmap; 101| 841| pr.xfrBlob(bitmap); 102| | 103| | // 00 06 20 00 00 00 00 03 -> NS RRSIG NSEC ( 2, 46, 47 ) counts from left 104| 841| if(bitmap.empty()) { ------------------ | Branch (104:6): [True: 310, False: 531] ------------------ 105| 310| return; 106| 310| } 107| | 108| 531| if(bitmap.size() < 2) { ------------------ | Branch (108:6): [True: 6, False: 525] ------------------ 109| 6| throw MOADNSException("NSEC record with impossibly small bitmap"); 110| 6| } 111| | 112| 23.3k| for(unsigned int n = 0; n+1 < bitmap.size();) { ------------------ | Branch (112:27): [True: 23.0k, False: 350] ------------------ 113| 23.0k| uint8_t window=static_cast(bitmap[n++]); 114| 23.0k| uint8_t blen=static_cast(bitmap[n++]); 115| | 116| | // end if zero padding and ensure packet length 117| 23.0k| if (window == 0 && blen == 0) { ------------------ | Branch (117:9): [True: 508, False: 22.5k] | Branch (117:24): [True: 101, False: 407] ------------------ 118| 101| break; 119| 101| } 120| | 121| 22.9k| if (blen > 32) { ------------------ | Branch (121:9): [True: 55, False: 22.8k] ------------------ 122| 55| throw MOADNSException("NSEC record with invalid bitmap length"); 123| 55| } 124| | 125| 22.8k| if (n + blen > bitmap.size()) { ------------------ | Branch (125:9): [True: 19, False: 22.8k] ------------------ 126| 19| throw MOADNSException("NSEC record with bitmap length > packet length"); 127| 19| } 128| | 129| 62.3k| for(unsigned int k=0; k < blen; k++) { ------------------ | Branch (129:27): [True: 39.4k, False: 22.8k] ------------------ 130| 39.4k| uint8_t val=bitmap[n++]; 131| 355k| for(int bit = 0; bit < 8 ; ++bit , val>>=1) { ------------------ | Branch (131:24): [True: 315k, False: 39.4k] ------------------ 132| 315k| if(val & 1) { ------------------ | Branch (132:12): [True: 81.1k, False: 234k] ------------------ 133| 81.1k| set((7-bit) + 8*(k) + 256*window); 134| 81.1k| } 135| 315k| } 136| 39.4k| } 137| 22.8k| } 138| 525|} _ZN17NSECRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 168| 1|{ 169| 1| regist(1, 47, &make, &make, "NSEC"); 170| 1|} _ZN17NSECRecordContent4makeERK9DNSRecordR12PacketReader: 196| 640|{ 197| 640| auto ret=std::make_shared(); 198| 640| pr.xfrName(ret->d_next); 199| | 200| 640| ret->d_bitmap.fromPacket(pr); 201| 640| if (!pr.eof()) { ------------------ | Branch (201:7): [True: 0, False: 640] ------------------ 202| 0| throw MOADNSException("When parsing NSEC trailing data was not parsed: '" + pr.getRemaining() + "'"); 203| 0| } 204| | 205| 640| return ret; 206| 640|} _ZN18NSEC3RecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 220| 1|{ 221| 1| regist(1, 50, &make, &make, "NSEC3"); 222| 1|} _ZN18NSEC3RecordContent4makeERK9DNSRecordR12PacketReader: 261| 163|{ 262| 163| auto ret=std::make_shared(); 263| 163| pr.xfr8BitInt(ret->d_algorithm); 264| 163| pr.xfr8BitInt(ret->d_flags); 265| 163| pr.xfr16BitInt(ret->d_iterations); 266| 163| uint8_t len; 267| 163| pr.xfr8BitInt(len); 268| 163| pr.xfrBlob(ret->d_salt, len); 269| | 270| 163| pr.xfr8BitInt(len); 271| 163| pr.xfrBlob(ret->d_nexthash, len); 272| | 273| 163| ret->d_bitmap.fromPacket(pr); 274| 163| if (!pr.eof()) { ------------------ | Branch (274:7): [True: 0, False: 163] ------------------ 275| 0| throw MOADNSException("When parsing NSEC3 trailing data was not parsed: '" + pr.getRemaining() + "'"); 276| 0| } 277| 163| return ret; 278| 163|} _ZN23NSEC3PARAMRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 296| 1|{ 297| 1| regist(1, 51, &make, &make, "NSEC3PARAM"); 298| 1| regist(254, 51, &make, &make, "NSEC3PARAM"); 299| 1|} _ZN23NSEC3PARAMRecordContent4makeERK9DNSRecordR12PacketReader: 326| 91|{ 327| 91| auto ret=std::make_shared(); 328| 91| pr.xfr8BitInt(ret->d_algorithm); 329| 91| pr.xfr8BitInt(ret->d_flags); 330| 91| pr.xfr16BitInt(ret->d_iterations); 331| 91| uint8_t len; 332| 91| pr.xfr8BitInt(len); 333| 91| pr.xfrHexBlob(ret->d_salt, len); 334| 91| return ret; 335| 91|} _ZN18CSYNCRecordContent6reportERK36ReportIsOnlyCallableByReportAllTypes: 353| 1|{ 354| 1| regist(1, 62, &make, &make, "CSYNC"); 355| 1|} _ZN18CSYNCRecordContent4makeERK9DNSRecordR12PacketReader: 384| 102|{ 385| 102| auto ret=std::make_shared(); 386| 102| pr.xfr32BitInt(ret->d_serial); 387| 102| pr.xfr16BitInt(ret->d_flags); 388| | 389| 102| ret->d_bitmap.fromPacket(pr); 390| 102| if (!pr.eof()) { ------------------ | Branch (390:7): [True: 0, False: 102] ------------------ 391| 0| throw MOADNSException("When parsing CSYNC trailing data was not parsed: '" + pr.getRemaining() + "'"); 392| 0| } 393| 102| return ret; 394| 102|} 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.4k| { 202| 28.4k| return qclass; 203| 28.4k| } _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| 82|{ 227| 82| auto ret=std::make_shared(); 228| 82| pr.xfr8BitInt(ret->d_version); 229| 82| pr.xfr8BitInt(ret->d_size); 230| 82| pr.xfr8BitInt(ret->d_horizpre); 231| 82| pr.xfr8BitInt(ret->d_vertpre); 232| | 233| 82| pr.xfr32BitInt(ret->d_latitude); 234| 82| pr.xfr32BitInt(ret->d_longitude); 235| 82| pr.xfr32BitInt(ret->d_altitude); 236| 82| if (!pr.eof()) { ------------------ | Branch (236:7): [True: 29, False: 53] ------------------ 237| 29| throw MOADNSException("When parsing LOC trailing data was not parsed: '" + pr.getRemaining() + "'"); 238| 29| } 239| | 240| 53| return ret; 241| 82|} _ZN7StatBagC2Ev: 40| 2|{ 41| 2| d_doRings=false; 42| 2| d_allowRedeclare=false; 43| 2|} _ZN8SvcParam11keyToStringERKNS_11SvcParamKeyE: 64| 7|{ 65| 7| auto ret = std::find_if(SvcParams.begin(), SvcParams.end(), [&](const std::pair& e) { return e.second == k; }); 66| 7| if (ret != SvcParams.end()) { ------------------ | Branch (66:7): [True: 7, False: 0] ------------------ 67| 7| return ret->first; 68| 7| } 69| 0| return "key" + std::to_string(k); 70| 7|} _ZN8SvcParamC2ERKNS_11SvcParamKeyE: 73| 47|{ 74| 47| d_key = key; 75| 47| if (d_key != SvcParamKey::no_default_alpn && d_key != SvcParamKey::ohttp) { ------------------ | Branch (75:7): [True: 21, False: 26] | Branch (75:48): [True: 0, False: 21] ------------------ 76| 0| throw std::invalid_argument("can not create non-empty SvcParam for key '" + keyToString(key) + "'"); 77| 0| } 78| 47|} _ZN8SvcParamC2ERKNS_11SvcParamKeyERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 81| 368|{ 82| 368| d_key = key; 83| 368| if (d_key != SvcParamKey::ech && d_key != SvcParamKey::dohpath && d_key < 10) { ------------------ | Branch (83:7): [True: 334, False: 34] | Branch (83:36): [True: 322, False: 12] | Branch (83:69): [True: 0, False: 322] ------------------ 84| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string value"); 85| 0| } 86| 368| if (d_key == SvcParamKey::ech) { ------------------ | Branch (86:7): [True: 34, False: 334] ------------------ 87| 34| std::string d; 88| | // TODO check Base64 decode 89| 34| d_ech = value; 90| 34| return; 91| 34| } 92| 334| d_value = value; 93| 334|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 96| 49|{ 97| 49| d_key = key; 98| 49| if (d_key != SvcParamKey::alpn) { ------------------ | Branch (98:7): [True: 0, False: 49] ------------------ 99| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a string-set value"); 100| 0| } 101| 49| if (d_key == SvcParamKey::alpn) { ------------------ | Branch (101:7): [True: 49, False: 0] ------------------ 102| 49| d_alpn = std::move(value); 103| 49| } 104| 49|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__13setIS0_NS3_4lessIS0_EENS3_9allocatorIS0_EEEE: 120| 202|{ 121| 202| d_key = key; 122| 202| if (d_key != SvcParamKey::mandatory) { ------------------ | Branch (122:7): [True: 0, False: 202] ------------------ 123| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a SvcParamKey-set value"); 124| 0| } 125| 202| d_mandatory = std::move(value); 126| 202|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorI12ComboAddressNS3_9allocatorIS5_EEEE: 129| 135|{ 130| 135| d_key = key; 131| 135| if (d_key != SvcParamKey::ipv6hint && d_key != SvcParamKey::ipv4hint) { ------------------ | Branch (131:7): [True: 102, False: 33] | Branch (131:41): [True: 0, False: 102] ------------------ 132| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with an IP address value"); 133| 0| } 134| 13.9k| for (auto const& addr : value) { ------------------ | Branch (134:25): [True: 13.9k, False: 135] ------------------ 135| 13.9k| if (d_key == SvcParam::ipv6hint && !addr.isIPv6()) { ------------------ | Branch (135:9): [True: 2.40k, False: 11.5k] | Branch (135:40): [True: 0, False: 2.40k] ------------------ 136| 0| throw std::invalid_argument("non-IPv6 address ('" + addr.toString() + "') passed for " + keyToString(key)); 137| 0| } 138| 13.9k| if (d_key == SvcParam::ipv4hint && !addr.isIPv4()) { ------------------ | Branch (138:9): [True: 11.5k, False: 2.40k] | Branch (138:40): [True: 0, False: 11.5k] ------------------ 139| 0| throw std::invalid_argument("non-IPv4 address ('" + addr.toString() + "') passed for " + keyToString(key)); 140| 0| } 141| 13.9k| } 142| 135| d_ipHints = std::move(value); 143| 135|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEONSt3__16vectorItNS3_9allocatorItEEEE: 146| 127| d_key(key) 147| 127|{ 148| 127| if (d_key != SvcParamKey::tls_supported_groups) { ------------------ | Branch (148:7): [True: 0, False: 127] ------------------ 149| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a uint16 value-vector"); 150| 0| } 151| 127| d_tls_supported_groups = std::move(value); 152| 127|} _ZN8SvcParamC2ERKNS_11SvcParamKeyEt: 155| 59|{ 156| 59| d_key = key; 157| 59| if (d_key != SvcParamKey::port) { ------------------ | Branch (157:7): [True: 0, False: 59] ------------------ 158| 0| throw std::invalid_argument("can not create SvcParam for " + keyToString(key) + " with a port value"); 159| 0| } 160| 59| d_port = value; 161| 59|} _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| 45| 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| 135| void setAutoHint(const bool value) { d_autohint = value; }; _ZN4pdns5views16UnsignedCharViewC2EPKcm: 33| 25.3k| view(data_, size_) 34| 25.3k| { 35| 25.3k| } _ZNK4pdns5views16UnsignedCharView2atEm: 44| 86.0k| { 45| 86.0k| return reinterpret_cast(view.at(pos)); 46| 86.0k| } _ZNK4pdns5views16UnsignedCharView4sizeEv: 60| 45.6k| { 61| 45.6k| return view.size(); 62| 45.6k| }