LLVMFuzzerInitialize: 128| 2|LLVMFuzzerInitialize(int *argc ISC_ATTR_UNUSED, char ***argv ISC_ATTR_UNUSED) { 129| 2| isc_result_t result; 130| 2| dns_fixedname_t fixed; 131| 2| dns_name_t *name = dns_fixedname_initname(&fixed); 132| 2| unsigned char secret[16] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 133| 2| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 134| 2| 0xff, 0xff, 0xff, 0xff }; 135| 2| dns_zone_t *zone = NULL; 136| 2| char pathbuf[PATH_MAX]; 137| 2| FILE *fd; 138| | 139| 2| wd = mkdtemp(template); 140| 2| if (wd == NULL) { ------------------ | Branch (140:6): [True: 0, False: 2] ------------------ 141| 0| fprintf(stderr, "mkdtemp failed\n"); 142| 0| return 1; 143| 0| } 144| | 145| 2| snprintf(pathbuf, sizeof(pathbuf), "%s/%s", wd, f1); 146| 2| fd = fopen(pathbuf, "w"); 147| 2| if (fd == NULL) { ------------------ | Branch (147:6): [True: 0, False: 2] ------------------ 148| 0| fprintf(stderr, "fopen(%s) failed\n", pathbuf); 149| 0| return 1; 150| 0| } 151| 2| fputs(c1, fd); 152| 2| fclose(fd); 153| | 154| 2| snprintf(pathbuf, sizeof(pathbuf), "%s/%s", wd, f2); 155| 2| fd = fopen(pathbuf, "w"); 156| 2| if (fd == NULL) { ------------------ | Branch (156:6): [True: 0, False: 2] ------------------ 157| 0| fprintf(stderr, "fopen(%s) failed\n", pathbuf); 158| 0| return 1; 159| 0| } 160| 2| fputs(c2, fd); 161| 2| fclose(fd); 162| | 163| 2| snprintf(pathbuf, sizeof(pathbuf), "%s/%s", wd, f3); 164| 2| fd = fopen(pathbuf, "w"); 165| 2| if (fd == NULL) { ------------------ | Branch (165:6): [True: 0, False: 2] ------------------ 166| 0| fprintf(stderr, "fopen(%s) failed\n", pathbuf); 167| 0| return 1; 168| 0| } 169| 2| fputs(c3, fd); 170| 2| fclose(fd); 171| | 172| 2| isc_mem_create("fuzz", &mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 173| | 174| 2| isc_loopmgr_create(mctx, 1); 175| | 176| 2| dns_view_create(mctx, NULL, dns_rdataclass_in, "view", &view); ------------------ | | 24| 2|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ 177| | 178| 2| dns_tsigkeyring_create(mctx, &ring); 179| 2| dns_tsigkeyring_create(mctx, &emptyring); 180| | 181| 2| result = dns_name_fromstring(name, "tsig-key", dns_rootname, 0, NULL); 182| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (182:6): [True: 0, False: 2] ------------------ 183| 0| fprintf(stderr, "dns_name_fromstring failed: %s\n", 184| 0| isc_result_totext(result)); 185| 0| return 1; 186| 0| } 187| | 188| 2| result = dns_tsigkey_create(name, DST_ALG_HMACSHA256, secret, 189| 2| sizeof(secret), mctx, &tsigkey); 190| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (190:6): [True: 0, False: 2] ------------------ 191| 0| fprintf(stderr, "dns_tsigkey_create failed: %s\n", 192| 0| isc_result_totext(result)); 193| 0| return 1; 194| 0| } 195| 2| result = dns_tsigkeyring_add(ring, tsigkey); 196| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (196:6): [True: 0, False: 2] ------------------ 197| 0| fprintf(stderr, "dns_tsigkeyring_add failed: %s\n", 198| 0| isc_result_totext(result)); 199| 0| return 1; 200| 0| } 201| | 202| 2| result = dns_name_fromstring(name, "sig0key", dns_rootname, 0, NULL); 203| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (203:6): [True: 0, False: 2] ------------------ 204| 0| fprintf(stderr, "dns_name_fromstring failed: %s\n", 205| 0| isc_result_totext(result)); 206| 0| return 1; 207| 0| } 208| | 209| 2| dns_zone_create(&zone, mctx, 0); 210| | 211| 2| dns_zone_setorigin(zone, name); 212| 2| dns_zone_setclass(zone, view->rdclass); 213| 2| dns_zone_settype(zone, dns_zone_primary); 214| 2| dns_zone_setkeydirectory(zone, wd); 215| 2| dns_zone_setfile(zone, pathbuf, NULL, dns_masterformat_text, 216| 2| &dns_master_style_default); 217| | 218| 2| result = dns_zone_load(zone, false); 219| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (219:6): [True: 0, False: 2] ------------------ 220| 0| fprintf(stderr, "dns_zone_load failed: %s\n", 221| 0| isc_result_totext(result)); 222| 0| return 1; 223| 0| } 224| | 225| 2| result = dns_view_addzone(view, zone); 226| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (226:6): [True: 0, False: 2] ------------------ 227| 0| fprintf(stderr, "dns_view_addzone failed: %s\n", 228| 0| isc_result_totext(result)); 229| 0| return 1; 230| 0| } 231| | 232| 2| dns_zone_setview(zone, view); 233| 2| dns_view_freeze(view); 234| | 235| 2| dns_zone_detach(&zone); 236| | 237| 2| return 0; 238| 2|} LLVMFuzzerTestOneInput: 317| 1.60k|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 318| 1.60k| isc_result_t result; 319| 1.60k| dns_message_t *message = NULL; 320| 1.60k| unsigned char query_tsig[23 + 32 + 6] = { 0 }; 321| 1.60k| bool addasig = false; 322| 1.60k| bool addtime = false; 323| 1.60k| bool addtsig = false; 324| 1.60k| bool setquerytsig = false; 325| 1.60k| bool settsigkey = false; 326| 1.60k| bool subtime = false; 327| 1.60k| bool withring = false; 328| 1.60k| bool withview = false; 329| | 330| | /* 331| | * The first 2 octets affect setup. 332| | * Octet 1 determines whether a signature is added and which type 333| | * (addasig, addtsig), whether time should be adjusted (addtime, 334| | * subtime), whether dns_message_setquerytsig and dns_message_settsigkey 335| | * have been called, whether there is a keyring available with the 336| | * TSIG key or a view is defined. 337| | * 338| | * The second octet defines if the message is a response and the 339| | * opcode. 340| | */ 341| 1.60k| if (size > 65535 || size < 2) { ------------------ | Branch (341:6): [True: 6, False: 1.59k] | Branch (341:22): [True: 1, False: 1.59k] ------------------ 342| 7| return 0; 343| 7| } 344| | 345| 1.59k| addasig = (*data & 0x80) != 0; 346| 1.59k| addtime = (*data & 0x40) != 0; 347| 1.59k| addtsig = (*data & 0x20) != 0; 348| 1.59k| setquerytsig = (*data & 0x10) != 0; 349| 1.59k| settsigkey = (*data & 0x08) != 0; 350| 1.59k| subtime = (*data & 0x04) != 0; 351| 1.59k| withring = (*data & 0x02) != 0; 352| 1.59k| withview = (*data & 0x01) != 0; 353| | 354| 1.59k| data++; 355| 1.59k| size--; 356| | 357| 1.59k| if (debug) { ------------------ | Branch (357:6): [True: 0, False: 1.59k] ------------------ 358| 0| fprintf(stderr, 359| 0| "addasig=%u addtime=%u addtsig=%u setquerytsig=%u " 360| 0| "settsigkey=%u subtime=%u withring=%u\nwithview=%u\n", 361| 0| addasig, addtime, addtsig, setquerytsig, settsigkey, 362| 0| subtime, withring, withview); 363| 0| } 364| | 365| 1.59k| result = create_message(&message, data, size, addasig, addtsig); 366| 1.59k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (366:6): [True: 464, False: 1.13k] ------------------ 367| 464| return 0; 368| 464| } 369| | 370| | /* 371| | * Make time calculations consistent. 372| | */ 373| 1.13k| message->fuzzing = 1; 374| 1.13k| message->fuzztime = fuzztime; 375| 1.13k| if (addtime) { ------------------ | Branch (375:6): [True: 412, False: 720] ------------------ 376| 412| message->fuzztime += 1200; 377| 412| } 378| 1.13k| if (subtime) { ------------------ | Branch (378:6): [True: 794, False: 338] ------------------ 379| 794| message->fuzztime -= 1200; 380| 794| } 381| | 382| 1.13k| if ((message->flags & DNS_MESSAGEFLAG_QR) != 0) { ------------------ | Branch (382:6): [True: 334, False: 798] ------------------ 383| 334| if (setquerytsig) { ------------------ | Branch (383:7): [True: 208, False: 126] ------------------ 384| 208| isc_buffer_t b; 385| 208| unsigned char hmacname[] = HMACSHA256; ------------------ | | 87| 208|#define HMACSHA256 "\x0bhmac-sha256" ------------------ 386| 208| unsigned char hmacvalue[32] = { 387| 208| 0x22, 0x4d, 0x58, 0x07, 0x64, 0x8d, 0x14, 0x00, 388| 208| 0x9d, 0x8e, 0xfc, 0x1c, 0xd0, 0x49, 0x55, 0xe9, 389| 208| 0xcc, 0x90, 0x21, 0x87, 0x3b, 0x5f, 0xaf, 0x5c, 390| 208| 0x88, 0x99, 0xdc, 0x27, 0xc8, 0xdf, 0xb3, 0x4b 391| 208| }; 392| | 393| | /* 394| | * Valid TSIG rdata for tsig-key over a plain 395| | * DNS QUERY for ./SOA/IN with no flags set. 396| | */ 397| 208| isc_buffer_init(&b, query_tsig, sizeof(query_tsig)); 398| 208| isc_buffer_putmem(&b, hmacname, sizeof(hmacname)); 399| 208| isc_buffer_putuint16(&b, 0); /* time high */ 400| 208| isc_buffer_putuint32(&b, 0x622abec0); /* time low */ 401| 208| isc_buffer_putuint16(&b, 300); /* Fudge */ 402| 208| isc_buffer_putuint16(&b, 32); /* Mac Length */ 403| | /* Mac */ 404| 208| isc_buffer_putmem(&b, hmacvalue, 32); 405| 208| isc_buffer_putuint16(&b, 7674); /* Original Id */ 406| 208| isc_buffer_putuint16(&b, 0); /* Error */ 407| 208| isc_buffer_putuint16(&b, 0); /* Other len */ 408| | 409| 208| dns_message_setquerytsig(message, &b); 410| 208| } 411| 334| } 412| | 413| 1.13k| if (settsigkey) { ------------------ | Branch (413:6): [True: 289, False: 843] ------------------ 414| 289| result = dns_message_settsigkey(message, tsigkey); 415| 289| if (debug) { ------------------ | Branch (415:7): [True: 0, False: 289] ------------------ 416| 0| fprintf(stderr, "dns_message_settsigkey => %s\n", 417| 0| isc_result_totext(result)); 418| 0| } 419| 289| } 420| | 421| 1.13k| dns_view_setkeyring(view, withring ? ring : emptyring); ------------------ | Branch (421:28): [True: 493, False: 639] ------------------ 422| | 423| 1.13k| result = dns_message_checksig(message, withview ? view : NULL); ------------------ | Branch (423:41): [True: 868, False: 264] ------------------ 424| 1.13k| if (debug) { ------------------ | Branch (424:6): [True: 0, False: 1.13k] ------------------ 425| 0| char textbuf[64]; 426| 0| isc_buffer_t b; 427| | 428| 0| fprintf(stderr, "dns_message_checksig => %s\n", 429| 0| isc_result_totext(result)); 430| 0| isc_buffer_init(&b, textbuf, sizeof(textbuf)); 431| 0| dns_tsigrcode_totext(message->tsigstatus, &b); 432| 0| fprintf(stderr, "tsigstatus=%.*s\n", (int)b.used, textbuf); 433| 0| isc_buffer_init(&b, textbuf, sizeof(textbuf)); 434| 0| dns_tsigrcode_totext(message->sig0status, &b); 435| 0| fprintf(stderr, "sig0status=%.*s\n", (int)b.used, textbuf); 436| 0| } 437| 1.13k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (437:6): [True: 1.05k, False: 80] ------------------ 438| 1.05k| goto cleanup; 439| 1.05k| } 440| | 441| 1.13k|cleanup: 442| 1.13k| if (message != NULL) { ------------------ | Branch (442:6): [True: 1.13k, False: 0] ------------------ 443| 1.13k| dns_message_detach(&message); 444| 1.13k| } 445| | 446| 1.13k| return 0; 447| 1.13k|} dns_message_checksig.c:create_message: 242| 1.59k| bool addasig, bool addtsig) { 243| 1.59k| isc_result_t result; 244| 1.59k| dns_message_t *message = NULL; 245| 1.59k| isc_buffer_t b; 246| 1.59k| static unsigned char buf[65535]; 247| | 248| 1.59k| isc_buffer_init(&b, buf, sizeof(buf)); 249| | 250| | /* Message ID */ 251| 1.59k| isc_buffer_putuint16(&b, 0); 252| | 253| | /* QR, Opcode, other flags = 0, rcode = 0 */ 254| 1.59k| isc_buffer_putuint16(&b, (*data & 0x1f) << 11); 255| | /* Counts */ 256| 1.59k| isc_buffer_putuint16(&b, 1); 257| 1.59k| isc_buffer_putuint16(&b, 0); 258| 1.59k| isc_buffer_putuint16(&b, 0); 259| 1.59k| isc_buffer_putuint16(&b, addasig ? 1 : 0); ------------------ | Branch (259:27): [True: 1.58k, False: 9] ------------------ 260| | 261| | /* Question ./IN/SOA */ 262| 1.59k| isc_buffer_putuint8(&b, 0); 263| 1.59k| isc_buffer_putuint16(&b, 6); 264| 1.59k| isc_buffer_putuint16(&b, 1); 265| | 266| 1.59k| if (addasig) { ------------------ | Branch (266:6): [True: 1.58k, False: 9] ------------------ 267| | /* Signature */ 268| 1.58k| if (addtsig) { ------------------ | Branch (268:7): [True: 932, False: 655] ------------------ 269| 932| const unsigned char keyname[] = "\x08tsig-key"; 270| 932| isc_buffer_putmem(&b, keyname, sizeof(keyname)); 271| 932| isc_buffer_putuint16(&b, dns_rdatatype_tsig); ------------------ | | 190| 932|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ 272| 932| isc_buffer_putuint16(&b, dns_rdataclass_any); ------------------ | | 34| 932|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ 273| 932| } else { 274| 655| isc_buffer_putuint8(&b, 0); /* '.' */ 275| 655| isc_buffer_putuint16(&b, dns_rdatatype_sig); ------------------ | | 138| 655|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ 276| 655| isc_buffer_putuint16(&b, dns_rdataclass_in); ------------------ | | 24| 655|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ 277| 655| } 278| 1.58k| isc_buffer_putuint32(&b, 0); /* ttl */ 279| 1.58k| data++; 280| 1.58k| size--; 281| 1.58k| if (size > isc_buffer_availablelength(&b) - 2) { ------------------ | | 161| 1.58k|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (281:7): [True: 9, False: 1.57k] ------------------ 282| 9| size = isc_buffer_availablelength(&b) - 2; ------------------ | | 161| 9|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 283| 9| } 284| 1.58k| isc_buffer_putuint16(&b, size); 285| 1.58k| isc_buffer_putmem(&b, data, size); 286| 1.58k| } 287| | 288| 1.59k| dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &message); 289| | 290| 1.59k| result = dns_message_parse(message, &b, 0); 291| 1.59k| if (debug) { ------------------ | Branch (291:6): [True: 0, False: 1.59k] ------------------ 292| 0| fprintf(stderr, "dns_message_parse => %s\n", 293| 0| isc_result_totext(result)); 294| 0| } 295| 1.59k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (295:6): [True: 464, False: 1.13k] ------------------ 296| 464| dns_message_detach(&message); 297| 1.13k| } else { 298| 1.13k| if (debug) { ------------------ | Branch (298:7): [True: 0, False: 1.13k] ------------------ 299| 0| char text[200000]; 300| 0| isc_buffer_init(&b, text, sizeof(text)); 301| | 302| 0| result = dns_message_totext( 303| 0| message, &dns_master_style_debug, 0, &b); 304| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (304:8): [True: 0, False: 0] ------------------ 305| 0| fprintf(stderr, "%.*s", (int)b.used, text); 306| 0| } else { 307| | fprintf(stderr, "dns_message_totext => %s\n", 308| 0| isc_result_totext(result)); 309| 0| } 310| 0| } 311| 1.13k| *messagep = message; 312| 1.13k| } 313| 1.59k| return result; 314| 1.59k|} dns_acl_create: 39| 4|dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target) { 40| 4| REQUIRE(target != NULL && *target == NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 41| | 42| 4| dns_acl_t *acl = isc_mem_get(mctx, sizeof(*acl)); ------------------ | | 128| 4|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 43| 4| *acl = (dns_acl_t){ 44| 4| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 4|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 45| 4| .nextincache = ISC_LINK_INITIALIZER, ------------------ | | 30| 4|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4| { \ | | | | 27| 4| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4| } | | ------------------ ------------------ 46| 4| .elements = isc_mem_cget(mctx, n, sizeof(acl->elements[0])), ------------------ | | 130| 4| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 4| ({ \ | | | | 33| 4| typeof(a) _c; \ | | | | 34| 4| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 4| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 4| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 4| _c; \ | | | | 37| 4| }) | | ------------------ | | 131| 4| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 4|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 47| 4| .alloc = n, 48| 4| .ports_and_transports = ISC_LIST_INITIALIZER, ------------------ | | 21| 4| { \ | | 22| 4| .head = NULL, \ | | 23| 4| .tail = NULL, \ | | 24| 4| } ------------------ 49| 4| .magic = DNS_ACL_MAGIC, ------------------ | | 113| 4|#define DNS_ACL_MAGIC ISC_MAGIC('D', 'a', 'c', 'l') | | ------------------ | | | | 31| 4|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 50| 4| }; 51| | 52| 4| isc_mem_attach(mctx, &acl->mctx); 53| 4| dns_iptable_create(acl->mctx, &acl->iptable); 54| | 55| 4| *target = acl; 56| 4|} dns__acl_initialize: 502| 2|dns__acl_initialize(void) { 503| 2| isc_mutex_init(&insecure_prefix_lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 504| 2|} dns_aclenv_create: 632| 2|dns_aclenv_create(isc_mem_t *mctx, dns_aclenv_t **envp) { 633| 2| dns_aclenv_t *env = isc_mem_get(mctx, sizeof(*env)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 634| 2| *env = (dns_aclenv_t){ 635| 2| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 636| 2| .magic = DNS_ACLENV_MAGIC, ------------------ | | 30| 2|#define DNS_ACLENV_MAGIC ISC_MAGIC('a', 'c', 'n', 'v') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 637| 2| }; 638| | 639| 2| isc_mem_attach(mctx, &env->mctx); 640| 2| isc_refcount_init(&env->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 641| | 642| 2| dns_acl_create(mctx, 0, &env->localhost); 643| 2| dns_acl_create(mctx, 0, &env->localnets); 644| | 645| 2| *envp = env; 646| 2|} dns_badcache_new: 83| 2|dns_badcache_new(isc_mem_t *mctx) { 84| 2| dns_badcache_t *bc = isc_mem_get(mctx, sizeof(*bc)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 85| 2| *bc = (dns_badcache_t){ 86| 2| .magic = BADCACHE_MAGIC, ------------------ | | 53| 2|#define BADCACHE_MAGIC ISC_MAGIC('B', 'd', 'C', 'a') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 87| 2| }; 88| | 89| 2| bc->ht = cds_lfht_new(BADCACHE_INIT_SIZE, BADCACHE_MIN_SIZE, 0, ------------------ | | 56| 2|#define BADCACHE_INIT_SIZE (1 << 10) /* Must be power of 2 */ ------------------ bc->ht = cds_lfht_new(BADCACHE_INIT_SIZE, BADCACHE_MIN_SIZE, 0, ------------------ | | 57| 2|#define BADCACHE_MIN_SIZE (1 << 8) /* Must be power of 2 */ ------------------ 90| 2| CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); 91| 2| INSIST(bc->ht != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 92| | 93| 2| isc_mutex_init(&bc->lru_lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 94| 2| CDS_INIT_LIST_HEAD(&bc->lru); 95| | 96| 2| isc_mem_attach(mctx, &bc->mctx); 97| | 98| 2| return bc; 99| 2|} dns_rdatacallbacks_init: 89| 2|dns_rdatacallbacks_init(dns_rdatacallbacks_t *callbacks) { 90| 2| dns_rdatacallbacks_initcommon(callbacks); 91| 2| callbacks->error = isclog_error_callback; 92| 2| callbacks->warn = isclog_warn_callback; 93| 2|} callbacks.c:dns_rdatacallbacks_initcommon: 76| 2|dns_rdatacallbacks_initcommon(dns_rdatacallbacks_t *callbacks) { 77| 2| REQUIRE(callbacks != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 78| | 79| 2| *callbacks = (dns_rdatacallbacks_t){ 80| 2| .magic = DNS_CALLBACK_MAGIC, ------------------ | | 30| 2|#define DNS_CALLBACK_MAGIC ISC_MAGIC('C', 'L', 'L', 'B') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 81| 2| }; 82| 2|} dns__db_initialize: 76| 2|dns__db_initialize(void) { 77| 2| isc_rwlock_init(&implock); 78| | 79| 2| ISC_LIST_INIT(implementations); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 80| | 81| 2| qpimp = (dns_dbimplementation_t){ 82| 2| .name = "qpcache", 83| 2| .create = dns__qpcache_create, 84| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 85| 2| }; 86| | 87| 2| qpzoneimp = (dns_dbimplementation_t){ 88| 2| .name = "qpzone", 89| 2| .create = dns__qpzone_create, 90| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 91| 2| }; 92| | 93| 2| ISC_LIST_APPEND(implementations, &qpimp, link); ------------------ | | 100| 2| do { \ | | 101| 2| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 2| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 2| do { \ | | | | 89| 2| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 2] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 2| } else { \ | | | | 92| 2| (list).head = (elt); \ | | | | 93| 2| } \ | | | | 94| 2| (elt)->link.prev = (list).tail; \ | | | | 95| 2| (elt)->link.next = NULL; \ | | | | 96| 2| (list).tail = (elt); \ | | | | 97| 2| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2] | | | | ------------------ | | ------------------ | | 103| 2| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 2] | | ------------------ ------------------ 94| | ISC_LIST_APPEND(implementations, &qpzoneimp, link); ------------------ | | 100| 2| do { \ | | 101| 2| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 2| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 2| do { \ | | | | 89| 2| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 2, False: 0] | | | | ------------------ | | | | 90| 2| (list).tail->link.next = (elt); \ | | | | 91| 2| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 2| (elt)->link.prev = (list).tail; \ | | | | 95| 2| (elt)->link.next = NULL; \ | | | | 96| 2| (list).tail = (elt); \ | | | | 97| 2| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 2] | | | | ------------------ | | ------------------ | | 103| 2| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 2] | | ------------------ ------------------ 95| 2|} dns_db_create: 122| 2| char *argv[], dns_db_t **dbp) { 123| 2| dns_dbimplementation_t *impinfo = NULL; 124| | 125| | /* 126| | * Create a new database using implementation 'db_type'. 127| | */ 128| | 129| 2| REQUIRE(dbp != NULL && *dbp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 130| 2| REQUIRE(dns_name_isabsolute(origin)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 131| | 132| 2| RWLOCK(&implock, isc_rwlocktype_read); ------------------ | | 30| 2| { \ | | 31| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 2| (t), __FILE__, __LINE__)); \ | | 33| 2| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 2| { \ | | | | 253| 2| switch (type) { \ | | | | 254| 2| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 2, False: 0] | | | | ------------------ | | | | 255| 2| isc_rwlock_rdlock(rwl); \ | | | | 256| 2| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 2] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 2] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 2| } \ | | | | 263| 2| } | | ------------------ | | 34| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 2| (lp), (t), __FILE__, __LINE__)); \ | | 36| 2| } ------------------ 133| 2| impinfo = impfind(db_type); 134| 2| if (impinfo != NULL) { ------------------ | Branch (134:6): [True: 2, False: 0] ------------------ 135| 2| isc_result_t result; 136| 2| result = ((impinfo->create)(mctx, origin, type, rdclass, argc, 137| 2| argv, impinfo->driverarg, dbp)); 138| 2| RWUNLOCK(&implock, isc_rwlocktype_read); ------------------ | | 38| 2| { \ | | 39| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 2| (lp), (t), __FILE__, __LINE__)); \ | | 41| 2| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 2| { \ | | | | 283| 2| switch (type) { \ | | | | 284| 2| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 2, False: 0] | | | | ------------------ | | | | 285| 2| isc_rwlock_rdunlock(rwl); \ | | | | 286| 2| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 2] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 2] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 139| | 140| |#if DNS_DB_TRACE 141| | fprintf(stderr, "dns_db_create:%s:%s:%d:%p->references = 1\n", 142| | __func__, __FILE__, __LINE__ + 1, *dbp); 143| |#endif 144| 2| return result; 145| 2| } 146| | 147| 0| RWUNLOCK(&implock, isc_rwlocktype_read); ------------------ | | 38| 0| { \ | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 0| { \ | | | | 283| 0| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 0] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 0] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 0] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 148| | 149| 0| isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DB, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 150| 0| "unsupported database type '%s'", db_type); 151| | 152| 0| return ISC_R_NOTFOUND; 153| 0|} dns_db_iscache: 167| 209|dns_db_iscache(dns_db_t *db) { 168| | /* 169| | * Does 'db' have cache semantics? 170| | */ 171| | 172| 209| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 173| | 174| 209| if ((db->attributes & DNS_DBATTR_CACHE) != 0) { ------------------ | Branch (174:6): [True: 0, False: 209] ------------------ 175| 0| return true; 176| 0| } 177| | 178| 209| return false; 179| 209|} dns_db_iszone: 182| 4|dns_db_iszone(dns_db_t *db) { 183| | /* 184| | * Does 'db' have zone semantics? 185| | */ 186| | 187| 4| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 188| | 189| 4| if ((db->attributes & (DNS_DBATTR_CACHE | DNS_DBATTR_STUB)) == 0) { ------------------ | Branch (189:6): [True: 4, False: 0] ------------------ 190| 4| return true; 191| 4| } 192| | 193| 0| return false; 194| 4|} dns_db_issecure: 212| 2|dns_db_issecure(dns_db_t *db) { 213| | /* 214| | * Is 'db' secure? 215| | */ 216| | 217| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 218| 2| REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 219| | 220| 2| if (db->methods->issecure != NULL) { ------------------ | Branch (220:6): [True: 2, False: 0] ------------------ 221| 2| return (db->methods->issecure)(db); 222| 2| } 223| 0| return false; 224| 2|} dns_db_ispersistent: 227| 4|dns_db_ispersistent(dns_db_t *db) { 228| | /* 229| | * Is 'db' persistent? 230| | */ 231| | 232| 4| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 233| | 234| 4| if (db->methods->beginload == NULL) { ------------------ | Branch (234:6): [True: 0, False: 4] ------------------ 235| | /* If the database can't be loaded, assume it's persistent */ 236| 0| return true; 237| 0| } 238| | 239| 4| return false; 240| 4|} dns_db_beginload: 265| 2|dns_db_beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 266| | /* 267| | * Begin loading 'db'. 268| | */ 269| | 270| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 271| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 272| | 273| 2| if (db->methods->beginload != NULL) { ------------------ | Branch (273:6): [True: 2, False: 0] ------------------ 274| 2| return (db->methods->beginload)(db, callbacks); 275| 2| } 276| 0| return ISC_R_NOTIMPLEMENTED; 277| 2|} dns_db_endload: 280| 2|dns_db_endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 281| | /* 282| | * Finish loading 'db'. 283| | */ 284| | 285| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 286| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 287| 2| REQUIRE(callbacks->add_private != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 288| | 289| | /* 290| | * When dns_db_endload() is called, we call the onupdate function 291| | * for all registered listeners, regardless of whether the underlying 292| | * database has an 'endload' implementation. 293| | */ 294| 2| call_updatenotify(db); 295| | 296| 2| if (db->methods->endload != NULL) { ------------------ | Branch (296:6): [True: 2, False: 0] ------------------ 297| 2| return (db->methods->endload)(db, callbacks); 298| 2| } 299| | 300| 0| return ISC_R_NOTIMPLEMENTED; 301| 2|} dns_db_currentversion: 395| 6|dns_db_currentversion(dns_db_t *db, dns_dbversion_t **versionp) { 396| | /* 397| | * Open the current version for reading. 398| | */ 399| | 400| 6| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 401| 6| REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 402| 6| REQUIRE(versionp != NULL && *versionp == NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 403| | 404| 6| (db->methods->currentversion)(db, versionp); 405| 6|} dns__db_closeversion: 442| 6| bool commit DNS__DB_FLARG) { 443| | /* 444| | * Close version '*versionp'. 445| | */ 446| | 447| 6| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 448| 6| REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 449| 6| REQUIRE(versionp != NULL && *versionp != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 450| | 451| 6| (db->methods->closeversion)(db, versionp, commit DNS__DB_FLARG_PASS); 452| | 453| 6| if (commit) { ------------------ | Branch (453:6): [True: 0, False: 6] ------------------ 454| 0| call_updatenotify(db); 455| 0| } 456| | 457| 6| ENSURE(*versionp == NULL); ------------------ | | 196| 6|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 6, False: 0] | | | | ------------------ | | | | 49| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 458| 6|} dns__db_findnode: 467| 6| dns_dbnode_t **nodep DNS__DB_FLARG) { 468| | /* 469| | * Find the node with name 'name', passing 'arg' to the database 470| | * implementation. 471| | */ 472| | 473| 6| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 474| 6| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 475| | 476| 6| if (db->methods->findnode != NULL) { ------------------ | Branch (476:6): [True: 6, False: 0] ------------------ 477| 6| return (db->methods->findnode)(db, name, create, methods, 478| 6| clientinfo, 479| 6| nodep DNS__DB_FLARG_PASS); 480| 6| } 481| 0| return ISC_R_NOTIMPLEMENTED; 482| 6|} dns__db_find: 504| 209| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 505| | /* 506| | * Find the best match for 'name' and 'type' in version 'version' 507| | * of 'db', passing in 'arg'. 508| | */ 509| | 510| 209| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 511| 209| REQUIRE(type != dns_rdatatype_rrsig); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 209| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 512| 209| REQUIRE(nodep == NULL || *nodep == NULL); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 209] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 513| 209| REQUIRE(dns_name_hasbuffer(foundname)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 209| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 514| 209| REQUIRE(rdataset == NULL || (DNS_RDATASET_VALID(rdataset) && ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 0, False: 209] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 515| 209| !dns_rdataset_isassociated(rdataset))); 516| 209| REQUIRE(sigrdataset == NULL || ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 209| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 517| 209| (DNS_RDATASET_VALID(sigrdataset) && 518| 209| !dns_rdataset_isassociated(sigrdataset))); 519| | 520| 209| if (db->methods->find != NULL) { ------------------ | Branch (520:6): [True: 209, False: 0] ------------------ 521| 209| return (db->methods->find)(db, name, version, type, options, 522| 209| now, nodep, foundname, methods, 523| 209| clientinfo, rdataset, 524| 209| sigrdataset DNS__DB_FLARG_PASS); 525| 209| } 526| 0| return ISC_R_NOTIMPLEMENTED; 527| 209|} dns__db_detachnode: 543| 140|dns__db_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) { 544| | /* 545| | * Detach *nodep from its node. 546| | */ 547| | 548| 140| REQUIRE(nodep != NULL && *nodep != NULL); ------------------ | | 194| 140|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 280| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 140, False: 0] | | | | | Branch (42:11): [True: 140, False: 0] | | | | ------------------ | | | | 43| 140| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 549| 140| dns_dbnode_t *node = *nodep; 550| 140| REQUIRE(node->methods != NULL && node->methods->detachnode != NULL); ------------------ | | 194| 140|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 280| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 140, False: 0] | | | | | Branch (42:11): [True: 140, False: 0] | | | | ------------------ | | | | 43| 140| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 551| | 552| 140| (node->methods->detachnode)(nodep DNS__DB_FLARG_PASS); 553| | 554| 140| ENSURE(*nodep == NULL); ------------------ | | 196| 140|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 140| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 140, False: 0] | | | | ------------------ | | | | 49| 140| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 555| 140|} dns__db_findrdataset: 598| 14| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 599| 14| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 14, False: 0] | | | | | Branch (42:11): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 600| 14| REQUIRE(node != NULL); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 601| 14| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 14, False: 0] | | | | | Branch (42:11): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 602| 14| REQUIRE(!dns_rdataset_isassociated(rdataset)); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 603| 14| REQUIRE(covers == dns_rdatatype_none || dns_rdatatype_issig(type)); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 14, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 604| 14| REQUIRE(type != dns_rdatatype_any); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 605| 14| REQUIRE(sigrdataset == NULL || ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 606| 14| (DNS_RDATASET_VALID(sigrdataset) && 607| 14| !dns_rdataset_isassociated(sigrdataset))); 608| | 609| 14| return (db->methods->findrdataset)(db, node, version, type, covers, now, 610| 14| rdataset, 611| 14| sigrdataset DNS__DB_FLARG_PASS); 612| 14|} dns_db_nodecount: 754| 2|dns_db_nodecount(dns_db_t *db) { 755| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 756| | 757| 2| if (db->methods->nodecount != NULL) { ------------------ | Branch (757:6): [True: 2, False: 0] ------------------ 758| 2| return (db->methods->nodecount)(db); 759| 2| } 760| 0| return 0; 761| 2|} dns__db_getoriginnode: 809| 2|dns__db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { 810| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 811| 2| REQUIRE(dns_db_iszone(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 812| 2| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 813| | 814| 2| if (db->methods->getoriginnode != NULL) { ------------------ | Branch (814:6): [True: 2, False: 0] ------------------ 815| 2| return (db->methods->getoriginnode)(db, 816| 2| nodep DNS__DB_FLARG_PASS); 817| 2| } else if (db->methods->findnode != NULL) { ------------------ | Branch (817:13): [True: 0, False: 0] ------------------ 818| 0| return (db->methods->findnode)(db, &db->origin, false, NULL, 819| 0| NULL, nodep DNS__DB_FLARG_PASS); 820| 0| } 821| | 822| 0| return ISC_R_NOTFOUND; 823| 2|} dns_db_setgluecachestats: 1035| 2|dns_db_setgluecachestats(dns_db_t *db, isc_stats_t *stats) { 1036| 2| REQUIRE(dns_db_iszone(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1037| 2| REQUIRE(stats != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1038| | 1039| 2| if (db->methods->setgluecachestats != NULL) { ------------------ | Branch (1039:6): [True: 2, False: 0] ------------------ 1040| 2| return (db->methods->setgluecachestats)(db, stats); 1041| 2| } 1042| | 1043| 0| return ISC_R_NOTIMPLEMENTED; 1044| 2|} dns_db_setmaxrrperset: 1082| 2|dns_db_setmaxrrperset(dns_db_t *db, uint32_t value) { 1083| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1084| | 1085| 2| if (db->methods->setmaxrrperset != NULL) { ------------------ | Branch (1085:6): [True: 2, False: 0] ------------------ 1086| 2| (db->methods->setmaxrrperset)(db, value); 1087| 2| } 1088| 2|} dns_db_setmaxtypepername: 1091| 2|dns_db_setmaxtypepername(dns_db_t *db, uint32_t value) { 1092| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1093| | 1094| 2| if (db->methods->setmaxtypepername != NULL) { ------------------ | Branch (1094:6): [True: 2, False: 0] ------------------ 1095| 2| (db->methods->setmaxtypepername)(db, value); 1096| 2| } 1097| 2|} db.c:impfind: 103| 2|impfind(const char *name) { 104| 4| ISC_LIST_FOREACH(implementations, imp, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 2|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 2, False: 0] | | ------------------ | | 236| 4| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 4, False: 0] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 2|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 2, False: 0] | | ------------------ ------------------ 105| 4| if (strcasecmp(name, imp->name) == 0) { ------------------ | Branch (105:7): [True: 2, False: 2] ------------------ 106| 2| return imp; 107| 2| } 108| 4| } 109| 0| return NULL; 110| 2|} db.c:call_updatenotify: 898| 2|call_updatenotify(dns_db_t *db) { 899| 2| rcu_read_lock(); 900| 2| struct cds_lfht *update_listeners = 901| 2| rcu_dereference(db->update_listeners); 902| 2| if (update_listeners != NULL) { ------------------ | Branch (902:6): [True: 2, False: 0] ------------------ 903| 2| struct cds_lfht_iter iter; 904| 2| dns_dbonupdatelistener_t *listener; 905| 2| cds_lfht_for_each_entry(update_listeners, &iter, listener, ------------------ | | 123| 2| for (cds_lfht_first(ht, iter), \ | | 124| 2| pos = cds_lfht_entry(cds_lfht_iter_get_node(iter), \ | | ------------------ | | | | 119| 2| caa_container_of_check_null(ptr, type, member) | | | | ------------------ | | | | | | 112| 2| __extension__ \ | | | | | | 113| 2| ({ \ | | | | | | 114| 2| const __typeof__(((type *) NULL)->member) * __ptr = (ptr); \ | | | | | | 115| 2| (__ptr) ? (type *)((char *)__ptr - offsetof(type, member)) : NULL; \ | | | | | | ------------------ | | | | | | | Branch (115:3): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 116| 2| }) | | | | ------------------ | | ------------------ | | 125| 2| __typeof__(*(pos)), member); \ | | 126| 2| pos != NULL; \ | | ------------------ | | | Branch (126:3): [True: 0, False: 2] | | ------------------ | | 127| 2| cds_lfht_next(ht, iter), \ | | 128| 0| pos = cds_lfht_entry(cds_lfht_iter_get_node(iter), \ | | ------------------ | | | | 119| 0| caa_container_of_check_null(ptr, type, member) | | | | ------------------ | | | | | | 112| 0| __extension__ \ | | | | | | 113| 0| ({ \ | | | | | | 114| 0| const __typeof__(((type *) NULL)->member) * __ptr = (ptr); \ | | | | | | 115| 0| (__ptr) ? (type *)((char *)__ptr - offsetof(type, member)) : NULL; \ | | | | | | ------------------ | | | | | | | Branch (115:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 116| 0| }) | | | | ------------------ | | ------------------ | | 129| 2| __typeof__(*(pos)), member)) ------------------ 906| 2| ht_node) { 907| 0| if (!cds_lfht_is_node_deleted(&listener->ht_node)) { ------------------ | Branch (907:8): [True: 0, False: 0] ------------------ 908| 0| listener->onupdate(db, listener->onupdate_arg); 909| 0| } 910| 0| } 911| 2| } 912| | rcu_read_unlock(); 913| 2|} qpzone.c:prio_type: 88| 24|prio_type(dns_typepair_t type) { 89| 24| switch (type) { ------------------ | Branch (89:10): [True: 12, False: 12] ------------------ 90| 4| case dns_rdatatype_soa: ------------------ | | 120| 4|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (90:2): [True: 4, False: 20] ------------------ 91| 4| case DNS_SIGTYPEPAIR(dns_rdatatype_soa): ------------------ | | 53| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 4| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (91:2): [True: 0, False: 24] ------------------ 92| 4| case dns_rdatatype_a: ------------------ | | 115| 4|#define dns_rdatatype_a ((dns_rdatatype_t)dns_rdatatype_a) ------------------ | Branch (92:2): [True: 0, False: 24] ------------------ 93| 4| case DNS_SIGTYPEPAIR(dns_rdatatype_a): ------------------ | | 53| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 4| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (93:2): [True: 0, False: 24] ------------------ 94| 4| case dns_rdatatype_mx: ------------------ | | 129| 4|#define dns_rdatatype_mx ((dns_rdatatype_t)dns_rdatatype_mx) ------------------ | Branch (94:2): [True: 0, False: 24] ------------------ 95| 4| case DNS_SIGTYPEPAIR(dns_rdatatype_mx): ------------------ | | 53| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 4| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (95:2): [True: 0, False: 24] ------------------ 96| 4| case dns_rdatatype_aaaa: ------------------ | | 142| 4|#define dns_rdatatype_aaaa ((dns_rdatatype_t)dns_rdatatype_aaaa) ------------------ | Branch (96:2): [True: 0, False: 24] ------------------ 97| 4| case DNS_SIGTYPEPAIR(dns_rdatatype_aaaa): ------------------ | | 53| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 4| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (97:2): [True: 0, False: 24] ------------------ 98| 4| case dns_rdatatype_nsec: ------------------ | | 161| 4|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (98:2): [True: 0, False: 24] ------------------ 99| 4| case DNS_SIGTYPEPAIR(dns_rdatatype_nsec): ------------------ | | 53| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 4| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (99:2): [True: 0, False: 24] ------------------ 100| 4| case dns_rdatatype_nsec3: ------------------ | | 164| 4|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (100:2): [True: 0, False: 24] ------------------ 101| 4| case DNS_SIGTYPEPAIR(dns_rdatatype_nsec3): ------------------ | | 53| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 4| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (101:2): [True: 0, False: 24] ------------------ 102| 12| case dns_rdatatype_ns: ------------------ | | 116| 12|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (102:2): [True: 8, False: 16] ------------------ 103| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_ns): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (103:2): [True: 0, False: 24] ------------------ 104| 12| case dns_rdatatype_ds: ------------------ | | 157| 12|#define dns_rdatatype_ds ((dns_rdatatype_t)dns_rdatatype_ds) ------------------ | Branch (104:2): [True: 0, False: 24] ------------------ 105| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_ds): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (105:2): [True: 0, False: 24] ------------------ 106| 12| case dns_rdatatype_cname: ------------------ | | 119| 12|#define dns_rdatatype_cname ((dns_rdatatype_t)dns_rdatatype_cname) ------------------ | Branch (106:2): [True: 0, False: 24] ------------------ 107| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_cname): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (107:2): [True: 0, False: 24] ------------------ 108| 12| case dns_rdatatype_dname: ------------------ | | 153| 12|#define dns_rdatatype_dname ((dns_rdatatype_t)dns_rdatatype_dname) ------------------ | Branch (108:2): [True: 0, False: 24] ------------------ 109| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_dname): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (109:2): [True: 0, False: 24] ------------------ 110| 12| case dns_rdatatype_svcb: ------------------ | | 177| 12|#define dns_rdatatype_svcb ((dns_rdatatype_t)dns_rdatatype_svcb) ------------------ | Branch (110:2): [True: 0, False: 24] ------------------ 111| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_svcb): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (111:2): [True: 0, False: 24] ------------------ 112| 12| case dns_rdatatype_https: ------------------ | | 178| 12|#define dns_rdatatype_https ((dns_rdatatype_t)dns_rdatatype_https) ------------------ | Branch (112:2): [True: 0, False: 24] ------------------ 113| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_https): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (113:2): [True: 0, False: 24] ------------------ 114| 12| case dns_rdatatype_dnskey: ------------------ | | 162| 12|#define dns_rdatatype_dnskey ((dns_rdatatype_t)dns_rdatatype_dnskey) ------------------ | Branch (114:2): [True: 0, False: 24] ------------------ 115| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_dnskey): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (115:2): [True: 0, False: 24] ------------------ 116| 12| case dns_rdatatype_srv: ------------------ | | 147| 12|#define dns_rdatatype_srv ((dns_rdatatype_t)dns_rdatatype_srv) ------------------ | Branch (116:2): [True: 0, False: 24] ------------------ 117| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_srv): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (117:2): [True: 0, False: 24] ------------------ 118| 12| case dns_rdatatype_txt: ------------------ | | 130| 12|#define dns_rdatatype_txt ((dns_rdatatype_t)dns_rdatatype_txt) ------------------ | Branch (118:2): [True: 0, False: 24] ------------------ 119| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_txt): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (119:2): [True: 0, False: 24] ------------------ 120| 12| case dns_rdatatype_ptr: ------------------ | | 126| 12|#define dns_rdatatype_ptr ((dns_rdatatype_t)dns_rdatatype_ptr) ------------------ | Branch (120:2): [True: 0, False: 24] ------------------ 121| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_ptr): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (121:2): [True: 0, False: 24] ------------------ 122| 12| case dns_rdatatype_naptr: ------------------ | | 149| 12|#define dns_rdatatype_naptr ((dns_rdatatype_t)dns_rdatatype_naptr) ------------------ | Branch (122:2): [True: 0, False: 24] ------------------ 123| 12| case DNS_SIGTYPEPAIR(dns_rdatatype_naptr): ------------------ | | 53| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (123:2): [True: 0, False: 24] ------------------ 124| 12| return true; 125| 24| } 126| 12| return false; 127| 24|} dns__dlz_initialize: 86| 2|dns__dlz_initialize(void) { 87| 2| isc_rwlock_init(&dlz_implock); 88| | ISC_LIST_INIT(dlz_implementations); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 89| 2|} dns_dnssec_keyfromrdata: 126| 96| isc_mem_t *mctx, dst_key_t **key) { 127| 96| isc_buffer_t b; 128| 96| isc_region_t r; 129| | 130| 96| INSIST(name != NULL); ------------------ | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 96, False: 0] | | | | ------------------ | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 131| 96| INSIST(rdata != NULL); ------------------ | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 96, False: 0] | | | | ------------------ | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 132| 96| INSIST(mctx != NULL); ------------------ | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 96, False: 0] | | | | ------------------ | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 133| 96| INSIST(key != NULL); ------------------ | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 96, False: 0] | | | | ------------------ | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 134| 96| INSIST(*key == NULL); ------------------ | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 96, False: 0] | | | | ------------------ | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 135| 96| REQUIRE(rdata->type == dns_rdatatype_key || ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 96, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 136| 96| rdata->type == dns_rdatatype_dnskey); 137| | 138| 96| dns_rdata_toregion(rdata, &r); 139| 96| isc_buffer_init(&b, r.base, r.length); 140| 96| isc_buffer_add(&b, r.length); 141| 96| return dst_key_fromdns(name, rdata->rdclass, &b, mctx, key); 142| 96|} dns_dnssec_verifymessage: 850| 96| dst_key_t *key) { 851| 96| dns_rdata_sig_t sig; /* SIG(0) */ 852| 96| unsigned char header[DNS_MESSAGE_HEADERLEN]; 853| 96| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 96| { \ | | 148| 96| .data = NULL, \ | | 149| 96| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 96|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 96| { \ | | | | | | 27| 96| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 96|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 96| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 96|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 96| } | | | | ------------------ | | ------------------ | | 150| 96| } ------------------ 854| 96| isc_region_t r, source_r, sig_r, header_r; 855| 96| isc_stdtime_t now; 856| 96| dst_context_t *ctx = NULL; 857| 96| isc_mem_t *mctx; 858| 96| isc_result_t result; 859| 96| uint16_t addcount, addcount_n; 860| 96| bool signeedsfree = false; 861| | 862| 96| REQUIRE(source != NULL); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 863| 96| REQUIRE(msg != NULL); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 864| 96| REQUIRE(key != NULL); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 865| | 866| 96| mctx = msg->mctx; 867| | 868| 96| msg->verify_attempted = 1; 869| 96| msg->verified_sig = 0; 870| 96| msg->sig0status = dns_tsigerror_badsig; 871| | 872| 96| if (is_response(msg)) { ------------------ | | 44| 96|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) | | ------------------ | | | Branch (44:26): [True: 1, False: 95] | | ------------------ ------------------ 873| 1| if (msg->query.base == NULL) { ------------------ | Branch (873:7): [True: 1, False: 0] ------------------ 874| 1| return DNS_R_UNEXPECTEDTSIG; 875| 1| } 876| 1| } 877| | 878| 95| isc_buffer_usedregion(source, &source_r); 879| | 880| 95| CHECK(dns_rdataset_first(msg->sig0)); ------------------ | | 251| 95| { \ | | 252| 95| result = (r); \ | | 253| 95| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 95] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 95| } ------------------ 881| 95| dns_rdataset_current(msg->sig0, &rdata); 882| | 883| 95| CHECK(dns_rdata_tostruct(&rdata, &sig, NULL)); ------------------ | | 251| 95| { \ | | 252| 95| result = (r); \ | | 253| 95| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 95] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 95| } ------------------ 884| 95| signeedsfree = true; 885| | 886| 95| if (sig.labels != 0) { ------------------ | Branch (886:6): [True: 9, False: 86] ------------------ 887| 9| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 262| 9| { \ | | 263| 9| result = (r); \ | | 264| 9| goto cleanup; \ | | 265| 9| } ------------------ 888| 0| } 889| | 890| 86| if (isc_serial_lt(sig.timeexpire, sig.timesigned)) { ------------------ | Branch (890:6): [True: 46, False: 40] ------------------ 891| 46| msg->sig0status = dns_tsigerror_badtime; 892| 46| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 262| 46| { \ | | 263| 46| result = (r); \ | | 264| 46| goto cleanup; \ | | 265| 46| } ------------------ 893| 0| } 894| | 895| 40| if (msg->fuzzing) { ------------------ | Branch (895:6): [True: 40, False: 0] ------------------ 896| 40| now = msg->fuzztime; 897| 40| } else { 898| 0| now = isc_stdtime_now(); 899| 0| } 900| | 901| 40| if (isc_serial_lt((uint32_t)now, sig.timesigned)) { ------------------ | Branch (901:6): [True: 6, False: 34] ------------------ 902| 6| msg->sig0status = dns_tsigerror_badtime; 903| 6| CLEANUP(DNS_R_SIGFUTURE); ------------------ | | 262| 6| { \ | | 263| 6| result = (r); \ | | 264| 6| goto cleanup; \ | | 265| 6| } ------------------ 904| 34| } else if (isc_serial_lt(sig.timeexpire, (uint32_t)now)) { ------------------ | Branch (904:13): [True: 15, False: 19] ------------------ 905| 15| msg->sig0status = dns_tsigerror_badtime; 906| 15| CLEANUP(DNS_R_SIGEXPIRED); ------------------ | | 262| 15| { \ | | 263| 15| result = (r); \ | | 264| 15| goto cleanup; \ | | 265| 15| } ------------------ 907| 0| } 908| | 909| 19| if (!dns_name_equal(dst_key_name(key), &sig.signer)) { ------------------ | Branch (909:6): [True: 0, False: 19] ------------------ 910| 0| msg->sig0status = dns_tsigerror_badkey; 911| 0| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 912| 0| } 913| | 914| 19| CHECK(dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, false, ------------------ | | 251| 19| { \ | | 252| 19| result = (r); \ | | 253| 19| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 19] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 19| } ------------------ 915| 19| &ctx)); 916| | 917| | /* 918| | * Digest the SIG(0) record, except for the signature. 919| | */ 920| 19| dns_rdata_toregion(&rdata, &r); 921| 19| r.length -= sig.siglen; 922| 19| CHECK(dst_context_adddata(ctx, &r)); ------------------ | | 251| 19| { \ | | 252| 19| result = (r); \ | | 253| 19| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 19] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 19| } ------------------ 923| | 924| | /* 925| | * If this is a response, digest the query. 926| | */ 927| 19| if (is_response(msg)) { ------------------ | | 44| 19|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) | | ------------------ | | | Branch (44:26): [True: 0, False: 19] | | ------------------ ------------------ 928| 0| CHECK(dst_context_adddata(ctx, &msg->query)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 929| 0| } 930| | 931| | /* 932| | * Extract the header. 933| | */ 934| 19| memmove(header, source_r.base, DNS_MESSAGE_HEADERLEN); ------------------ | | 145| 19|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 935| | 936| | /* 937| | * Decrement the additional field counter. 938| | */ 939| 19| memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2); ------------------ | | 145| 19|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 940| 19| addcount_n = ntohs(addcount); 941| 19| addcount = htons((uint16_t)(addcount_n - 1)); 942| 19| memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2); ------------------ | | 145| 19|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 943| | 944| | /* 945| | * Digest the modified header. 946| | */ 947| 19| header_r.base = (unsigned char *)header; 948| 19| header_r.length = DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 19|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 949| 19| CHECK(dst_context_adddata(ctx, &header_r)); ------------------ | | 251| 19| { \ | | 252| 19| result = (r); \ | | 253| 19| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 19] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 19| } ------------------ 950| | 951| | /* 952| | * Digest all non-SIG(0) records. 953| | */ 954| 19| r.base = source_r.base + DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 19|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 955| 19| r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 19|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 956| 19| CHECK(dst_context_adddata(ctx, &r)); ------------------ | | 251| 19| { \ | | 252| 19| result = (r); \ | | 253| 19| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 19] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 19| } ------------------ 957| | 958| 19| sig_r.base = sig.signature; 959| 19| sig_r.length = sig.siglen; 960| 19| result = dst_context_verify(ctx, &sig_r); 961| 19| if (result != ISC_R_SUCCESS) { ------------------ | Branch (961:6): [True: 18, False: 1] ------------------ 962| 18| msg->sig0status = dns_tsigerror_badsig; 963| 18| goto cleanup; 964| 18| } 965| | 966| 1| msg->verified_sig = 1; 967| 1| msg->sig0status = dns_rcode_noerror; ------------------ | | 269| 1|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 968| | 969| 1| dst_context_destroy(&ctx); 970| 1| dns_rdata_freestruct(&sig); 971| | 972| 1| return ISC_R_SUCCESS; 973| | 974| 94|cleanup: 975| 94| if (signeedsfree) { ------------------ | Branch (975:6): [True: 94, False: 0] ------------------ 976| 94| dns_rdata_freestruct(&sig); 977| 94| } 978| 94| if (ctx != NULL) { ------------------ | Branch (978:6): [True: 18, False: 76] ------------------ 979| 18| dst_context_destroy(&ctx); 980| 18| } 981| | 982| 94| return result; 983| 19|} dst__lib_initialize: 198| 2|dst__lib_initialize(void) { 199| 2| isc_mem_create("dst", &dst__mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 200| | 201| 2| dst__hmacmd5_init(&dst_t_func[DST_ALG_HMACMD5]); 202| 2| dst__hmacsha1_init(&dst_t_func[DST_ALG_HMACSHA1]); 203| 2| dst__hmacsha224_init(&dst_t_func[DST_ALG_HMACSHA224]); 204| 2| dst__hmacsha256_init(&dst_t_func[DST_ALG_HMACSHA256]); 205| 2| dst__hmacsha384_init(&dst_t_func[DST_ALG_HMACSHA384]); 206| 2| dst__hmacsha512_init(&dst_t_func[DST_ALG_HMACSHA512]); 207| | 208| | /* RSASHA1 (NSEC3RSASHA1) is verify only in FIPS mode. */ 209| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA1], DST_ALG_RSASHA1); 210| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_NSEC3RSASHA1], 211| 2| DST_ALG_NSEC3RSASHA1); 212| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA256], DST_ALG_RSASHA256); 213| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA512], DST_ALG_RSASHA512); 214| 2| dst__opensslecdsa_init(&dst_t_func[DST_ALG_ECDSA256]); 215| 2| dst__opensslecdsa_init(&dst_t_func[DST_ALG_ECDSA384]); 216| 2| dst__openssleddsa_init(&dst_t_func[DST_ALG_ED25519], DST_ALG_ED25519); 217| 2|#ifdef HAVE_OPENSSL_ED448 218| 2| dst__openssleddsa_init(&dst_t_func[DST_ALG_ED448], DST_ALG_ED448); 219| 2|#endif /* ifdef HAVE_OPENSSL_ED448 */ 220| | 221| |#if HAVE_GSSAPI 222| | dst__gssapi_init(&dst_t_func[DST_ALG_GSSAPI]); 223| |#endif /* HAVE_GSSAPI */ 224| | /* 225| | * RSASHA256 using assigned OID 1.2.840.113549.1.1.11 as 226| | * a private OID example. 227| | */ 228| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA256PRIVATEOID], 229| 2| DST_ALG_RSASHA256PRIVATEOID); 230| | /* 231| | * RSASHA512 using assigned OID 1.2.840.113549.1.1.13 as 232| | * a private OID example. 233| | */ 234| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA512PRIVATEOID], 235| 2| DST_ALG_RSASHA512PRIVATEOID); 236| 2|} dst_algorithm_supported: 244| 165|dst_algorithm_supported(unsigned int alg) { 245| 165| if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL) { ------------------ | Branch (245:6): [True: 0, False: 165] | Branch (245:29): [True: 0, False: 165] ------------------ 246| 0| return false; 247| 0| } 248| 165| return true; 249| 165|} dst_context_create: 266| 65| bool useforsigning, dst_context_t **dctxp) { 267| 65| dst_context_t *dctx; 268| 65| isc_result_t result; 269| | 270| 65| REQUIRE(VALID_KEY(key)); ------------------ | | 194| 65|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 130| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 65, False: 0] | | | | | Branch (42:11): [True: 65, False: 0] | | | | ------------------ | | | | 43| 65| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 271| 65| REQUIRE(mctx != NULL); ------------------ | | 194| 65|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 65| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 65, False: 0] | | | | ------------------ | | | | 43| 65| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 272| 65| REQUIRE(dctxp != NULL && *dctxp == NULL); ------------------ | | 194| 65|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 130| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 65, False: 0] | | | | | Branch (42:11): [True: 65, False: 0] | | | | ------------------ | | | | 43| 65| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 273| | 274| 65| if (key->func->createctx == NULL) { ------------------ | Branch (274:6): [True: 0, False: 65] ------------------ 275| 0| return DST_R_UNSUPPORTEDALG; 276| 0| } 277| 65| if (key->keydata.generic == NULL) { ------------------ | Branch (277:6): [True: 0, False: 65] ------------------ 278| 0| return DST_R_NULLKEY; 279| 0| } 280| | 281| 65| dctx = isc_mem_get(mctx, sizeof(*dctx)); ------------------ | | 128| 65|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 282| 65| *dctx = (dst_context_t){ 283| 65| .category = category, 284| 65| .use = (useforsigning) ? DO_SIGN : DO_VERIFY, ------------------ | Branch (284:10): [True: 0, False: 65] ------------------ 285| 65| }; 286| | 287| 65| dst_key_attach(key, &dctx->key); 288| 65| isc_mem_attach(mctx, &dctx->mctx); 289| 65| result = key->func->createctx(key, dctx); 290| 65| if (result != ISC_R_SUCCESS) { ------------------ | Branch (290:6): [True: 0, False: 65] ------------------ 291| 0| if (dctx->key != NULL) { ------------------ | Branch (291:7): [True: 0, False: 0] ------------------ 292| 0| dst_key_free(&dctx->key); 293| 0| } 294| 0| isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(dst_context_t)); ------------------ | | 161| 0| do { \ | | 162| 0| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 0| (p) = NULL; \ | | 164| 0| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 0] | | ------------------ ------------------ 295| 0| return result; 296| 0| } 297| 65| dctx->magic = CTX_MAGIC; ------------------ | | 54| 65|#define CTX_MAGIC ISC_MAGIC('D', 'S', 'T', 'C') | | ------------------ | | | | 31| 65|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 298| 65| *dctxp = dctx; 299| 65| return ISC_R_SUCCESS; 300| 65|} dst_context_destroy: 303| 65|dst_context_destroy(dst_context_t **dctxp) { 304| 65| dst_context_t *dctx; 305| | 306| 65| REQUIRE(dctxp != NULL && VALID_CTX(*dctxp)); ------------------ | | 194| 65|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 260| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 65, False: 0] | | | | | Branch (42:11): [True: 65, False: 0] | | | | | Branch (42:11): [True: 65, False: 0] | | | | ------------------ | | | | 43| 65| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 307| | 308| 65| dctx = *dctxp; 309| 65| *dctxp = NULL; 310| 65| INSIST(dctx->key->func->destroyctx != NULL); ------------------ | | 198| 65|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 65| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 65, False: 0] | | | | ------------------ | | | | 55| 65| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 311| 65| dctx->key->func->destroyctx(dctx); 312| 65| if (dctx->key != NULL) { ------------------ | Branch (312:6): [True: 65, False: 0] ------------------ 313| 65| dst_key_free(&dctx->key); 314| 65| } 315| 65| dctx->magic = 0; 316| | isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(dst_context_t)); ------------------ | | 161| 65| do { \ | | 162| 65| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 65| (p) = NULL; \ | | 164| 65| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 65] | | ------------------ ------------------ 317| 65|} dst_context_adddata: 320| 368|dst_context_adddata(dst_context_t *dctx, const isc_region_t *data) { 321| 368| REQUIRE(VALID_CTX(dctx)); ------------------ | | 194| 368|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 736| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 368, False: 0] | | | | | Branch (42:11): [True: 368, False: 0] | | | | ------------------ | | | | 43| 368| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 322| 368| REQUIRE(data != NULL); ------------------ | | 194| 368|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 368| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 368, False: 0] | | | | ------------------ | | | | 43| 368| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 323| 368| INSIST(dctx->key->func->adddata != NULL); ------------------ | | 198| 368|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 368| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 368, False: 0] | | | | ------------------ | | | | 55| 368| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 324| | 325| 368| return dctx->key->func->adddata(dctx, data); 326| 368|} dst_context_verify: 352| 65|dst_context_verify(dst_context_t *dctx, isc_region_t *sig) { 353| 65| REQUIRE(VALID_CTX(dctx)); ------------------ | | 194| 65|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 130| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 65, False: 0] | | | | | Branch (42:11): [True: 65, False: 0] | | | | ------------------ | | | | 43| 65| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 354| 65| REQUIRE(sig != NULL); ------------------ | | 194| 65|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 65| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 65, False: 0] | | | | ------------------ | | | | 43| 65| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 355| | 356| 65| CHECKALG(dctx->key->key_alg); ------------------ | | 188| 65| do { \ | | 189| 65| isc_result_t _r; \ | | 190| 65| _r = algorithm_status(alg); \ | | 191| 65| if (_r != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (191:7): [True: 0, False: 65] | | ------------------ | | 192| 65| return ((_r)); \ | | 193| 65| } while (0); | | ------------------ | | | Branch (193:11): [Folded, False: 65] | | ------------------ ------------------ 357| 65| if (dctx->key->keydata.generic == NULL) { ------------------ | Branch (357:6): [True: 0, False: 65] ------------------ 358| 0| return DST_R_NULLKEY; 359| 0| } 360| | 361| 65| if (dctx->key->func->verify == NULL) { ------------------ | Branch (361:6): [True: 0, False: 65] ------------------ 362| 0| return DST_R_NOTPUBLICKEY; 363| 0| } 364| | 365| 65| return dctx->key->func->verify(dctx, sig); 366| 65|} dst_key_todns: 633| 2|dst_key_todns(const dst_key_t *key, isc_buffer_t *target) { 634| 2| REQUIRE(VALID_KEY(key)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 635| 2| REQUIRE(target != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 636| | 637| 2| CHECKALG(key->key_alg); ------------------ | | 188| 2| do { \ | | 189| 2| isc_result_t _r; \ | | 190| 2| _r = algorithm_status(alg); \ | | 191| 2| if (_r != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (191:7): [True: 0, False: 2] | | ------------------ | | 192| 2| return ((_r)); \ | | 193| 2| } while (0); | | ------------------ | | | Branch (193:11): [Folded, False: 2] | | ------------------ ------------------ 638| | 639| 2| if (key->func->todns == NULL) { ------------------ | Branch (639:6): [True: 0, False: 2] ------------------ 640| 0| return DST_R_UNSUPPORTEDALG; 641| 0| } 642| | 643| 2| if (isc_buffer_availablelength(target) < 4) { ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (643:6): [True: 0, False: 2] ------------------ 644| 0| return ISC_R_NOSPACE; 645| 0| } 646| 2| isc_buffer_putuint16(target, (uint16_t)(key->key_flags & 0xffff)); 647| 2| isc_buffer_putuint8(target, (uint8_t)key->key_proto); 648| 2| isc_buffer_putuint8(target, 649| 2| (uint8_t)dst_algorithm_tosecalg(key->key_alg)); 650| | 651| 2| if (key->keydata.generic == NULL) { ------------------ | Branch (651:6): [True: 0, False: 2] ------------------ 652| 0| return ISC_R_SUCCESS; 653| 0| } 654| | 655| 2| return key->func->todns(key, target); 656| 2|} dst_key_fromdns: 660| 96| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 661| 96| uint8_t alg, proto; 662| 96| uint32_t flags; 663| 96| dst_key_t *key = NULL; 664| 96| dns_keytag_t id, rid; 665| 96| isc_region_t r; 666| | 667| 96| isc_buffer_remainingregion(source, &r); 668| | 669| 96| if (isc_buffer_remaininglength(source) < 4) { ------------------ | | 159| 96|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (669:6): [True: 0, False: 96] ------------------ 670| 0| return DST_R_INVALIDPUBLICKEY; 671| 0| } 672| 96| flags = isc_buffer_getuint16(source); 673| 96| proto = isc_buffer_getuint8(source); 674| 96| alg = isc_buffer_getuint8(source); 675| | 676| 96| id = dst_region_computeid(&r); 677| 96| rid = dst_region_computerid(&r); 678| | 679| 96| RETERR(frombuffer(name, alg, flags, proto, rdclass, source, mctx, ------------------ | | 272| 96| { \ | | 273| 96| isc_result_t _r = (x); \ | | 274| 96| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 96] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 96| } ------------------ 680| 96| &key)); 681| 96| key->key_id = id; 682| 96| key->key_rid = rid; 683| | 684| 96| *keyp = key; 685| 96| return ISC_R_SUCCESS; 686| 96|} dst_key_frombuffer: 691| 2| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 692| 2| dst_key_t *key = NULL; 693| 2| isc_result_t result; 694| | 695| 2| RETERR(frombuffer(name, alg, flags, protocol, rdclass, source, mctx, ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 696| 2| &key)); 697| | 698| 2| result = computeid(key); 699| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (699:6): [True: 0, False: 2] ------------------ 700| 0| dst_key_free(&key); 701| 0| return result; 702| 0| } 703| | 704| 2| *keyp = key; 705| 2| return ISC_R_SUCCESS; 706| 2|} dst_key_attach: 1193| 67|dst_key_attach(dst_key_t *source, dst_key_t **target) { 1194| 67| REQUIRE(target != NULL && *target == NULL); ------------------ | | 194| 67|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 134| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 67, False: 0] | | | | | Branch (42:11): [True: 67, False: 0] | | | | ------------------ | | | | 43| 67| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1195| 67| REQUIRE(VALID_KEY(source)); ------------------ | | 194| 67|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 134| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 67, False: 0] | | | | | Branch (42:11): [True: 67, False: 0] | | | | ------------------ | | | | 43| 67| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1196| | 1197| | isc_refcount_increment(&source->refs); ------------------ | | 81| 67| ({ \ | | 82| 67| uint_fast32_t __v; \ | | 83| 67| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 67| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 67| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 198| 67|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 134| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:11): [True: 67, False: 0] | | | | | | | Branch (54:11): [True: 67, False: 0] | | | | | | ------------------ | | | | | | 55| 67| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 67| __v; \ | | 86| 67| }) ------------------ 1198| 67| *target = source; 1199| 67|} dst_key_free: 1202| 163|dst_key_free(dst_key_t **keyp) { 1203| 163| REQUIRE(keyp != NULL && VALID_KEY(*keyp)); ------------------ | | 194| 163|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 652| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 163, False: 0] | | | | | Branch (42:11): [True: 163, False: 0] | | | | | Branch (42:11): [True: 163, False: 0] | | | | ------------------ | | | | 43| 163| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1204| 163| dst_key_t *key = *keyp; 1205| 163| *keyp = NULL; 1206| | 1207| 163| if (isc_refcount_decrement(&key->refs) == 1) { ------------------ | | 94| 163| ({ \ | | 95| 163| uint_fast32_t __v; \ | | 96| 163| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 163| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 163| INSIST(__v > 0); \ | | ------------------ | | | | 198| 163|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 163| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 163, False: 0] | | | | | | ------------------ | | | | | | 55| 163| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 163| __v; \ | | 99| 163| }) ------------------ | Branch (1207:6): [True: 96, False: 67] ------------------ 1208| 96| isc_refcount_destroy(&key->refs); ------------------ | | 60| 96| ISC_REQUIRE(isc_refcount_current(target) == 0) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1209| 96| isc_mem_t *mctx = key->mctx; 1210| 96| if (key->keydata.generic != NULL) { ------------------ | Branch (1210:7): [True: 96, False: 0] ------------------ 1211| 96| INSIST(key->func->destroy != NULL); ------------------ | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 96, False: 0] | | | | ------------------ | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1212| 96| key->func->destroy(key); 1213| 96| } 1214| 96| if (key->directory != NULL) { ------------------ | Branch (1214:7): [True: 0, False: 96] ------------------ 1215| 0| isc_mem_free(mctx, key->directory); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1216| 0| } 1217| 96| if (key->label != NULL) { ------------------ | Branch (1217:7): [True: 0, False: 96] ------------------ 1218| 0| isc_mem_free(mctx, key->label); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1219| 0| } 1220| 96| dns_name_free(key->key_name, mctx); 1221| 96| isc_mem_put(mctx, key->key_name, sizeof(dns_name_t)); ------------------ | | 150| 96| do { \ | | 151| 96| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 96| (p) = NULL; \ | | 153| 96| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 96] | | ------------------ ------------------ 1222| 96| if (key->key_tkeytoken) { ------------------ | Branch (1222:7): [True: 0, False: 96] ------------------ 1223| 0| isc_buffer_free(&key->key_tkeytoken); 1224| 0| } 1225| 96| isc_mutex_destroy(&key->mdlock); ------------------ | | 72| 96|#define isc_mutex_destroy(mp) isc__mutex_destroy(mp) | | ------------------ | | | | 100| 96| { \ | | | | 101| 96| int _ret = pthread_mutex_destroy(mp); \ | | | | 102| 96| PTHREADS_RUNTIME_CHECK(pthread_mutex_destroy, _ret); \ | | | | ------------------ | | | | | | 284| 96| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 96] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 103| 96| } | | ------------------ ------------------ 1226| 96| isc_safe_memwipe(key, sizeof(*key)); 1227| | isc_mem_putanddetach(&mctx, key, sizeof(*key)); ------------------ | | 161| 96| do { \ | | 162| 96| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 96| (p) = NULL; \ | | 164| 96| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 96] | | ------------------ ------------------ 1228| 96| } 1229| 163|} dst_key_sigsize: 1251| 215|dst_key_sigsize(const dst_key_t *key, unsigned int *n) { 1252| 215| REQUIRE(VALID_KEY(key)); ------------------ | | 194| 215|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 430| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 215, False: 0] | | | | | Branch (42:11): [True: 215, False: 0] | | | | ------------------ | | | | 43| 215| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1253| 215| REQUIRE(n != NULL); ------------------ | | 194| 215|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 215| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 215, False: 0] | | | | ------------------ | | | | 43| 215| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1254| | 1255| 215| switch (key->key_alg) { 1256| 0| case DST_ALG_RSASHA1: ------------------ | Branch (1256:2): [True: 0, False: 215] ------------------ 1257| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (1257:2): [True: 0, False: 215] ------------------ 1258| 0| case DST_ALG_RSASHA256: ------------------ | Branch (1258:2): [True: 0, False: 215] ------------------ 1259| 0| case DST_ALG_RSASHA512: ------------------ | Branch (1259:2): [True: 0, False: 215] ------------------ 1260| 0| *n = (key->key_size + 7) / 8; 1261| 0| break; 1262| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (1262:2): [True: 0, False: 215] ------------------ 1263| 0| *n = (key->key_size + 7) / 8 + sizeof(oid_rsasha256); 1264| 0| break; 1265| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (1265:2): [True: 0, False: 215] ------------------ 1266| 0| *n = (key->key_size + 7) / 8 + sizeof(oid_rsasha512); 1267| 0| break; 1268| 0| case DST_ALG_ECDSA256: ------------------ | Branch (1268:2): [True: 0, False: 215] ------------------ 1269| 0| *n = DNS_SIG_ECDSA256SIZE; ------------------ | | 69| 0|#define DNS_SIG_ECDSA256SIZE 64 ------------------ 1270| 0| break; 1271| 0| case DST_ALG_ECDSA384: ------------------ | Branch (1271:2): [True: 0, False: 215] ------------------ 1272| 0| *n = DNS_SIG_ECDSA384SIZE; ------------------ | | 72| 0|#define DNS_SIG_ECDSA384SIZE 96 ------------------ 1273| 0| break; 1274| 0| case DST_ALG_ED25519: ------------------ | Branch (1274:2): [True: 0, False: 215] ------------------ 1275| 0| *n = DNS_SIG_ED25519SIZE; ------------------ | | 75| 0|#define DNS_SIG_ED25519SIZE 64 ------------------ 1276| 0| break; 1277| 0| case DST_ALG_ED448: ------------------ | Branch (1277:2): [True: 0, False: 215] ------------------ 1278| 0| *n = DNS_SIG_ED448SIZE; ------------------ | | 78| 0|#define DNS_SIG_ED448SIZE 114 ------------------ 1279| 0| break; 1280| 0| case DST_ALG_HMACMD5: ------------------ | Branch (1280:2): [True: 0, False: 215] ------------------ 1281| 0| *n = ISC_MD5_DIGESTLENGTH; ------------------ | | 48| 0|#define ISC_MD5_DIGESTLENGTH 16 ------------------ 1282| 0| break; 1283| 0| case DST_ALG_HMACSHA1: ------------------ | Branch (1283:2): [True: 0, False: 215] ------------------ 1284| 0| *n = ISC_SHA1_DIGESTLENGTH; ------------------ | | 50| 0|#define ISC_SHA1_DIGESTLENGTH 20 ------------------ 1285| 0| break; 1286| 0| case DST_ALG_HMACSHA224: ------------------ | Branch (1286:2): [True: 0, False: 215] ------------------ 1287| 0| *n = ISC_SHA224_DIGESTLENGTH; ------------------ | | 52| 0|#define ISC_SHA224_DIGESTLENGTH 28 ------------------ 1288| 0| break; 1289| 215| case DST_ALG_HMACSHA256: ------------------ | Branch (1289:2): [True: 215, False: 0] ------------------ 1290| 215| *n = ISC_SHA256_DIGESTLENGTH; ------------------ | | 54| 215|#define ISC_SHA256_DIGESTLENGTH 32 ------------------ 1291| 215| break; 1292| 0| case DST_ALG_HMACSHA384: ------------------ | Branch (1292:2): [True: 0, False: 215] ------------------ 1293| 0| *n = ISC_SHA384_DIGESTLENGTH; ------------------ | | 56| 0|#define ISC_SHA384_DIGESTLENGTH 48 ------------------ 1294| 0| break; 1295| 0| case DST_ALG_HMACSHA512: ------------------ | Branch (1295:2): [True: 0, False: 215] ------------------ 1296| 0| *n = ISC_SHA512_DIGESTLENGTH; ------------------ | | 58| 0|#define ISC_SHA512_DIGESTLENGTH 64 ------------------ 1297| 0| break; 1298| 0| case DST_ALG_GSSAPI: ------------------ | Branch (1298:2): [True: 0, False: 215] ------------------ 1299| 0| *n = 128; /*%< XXX */ 1300| 0| break; 1301| 0| default: ------------------ | Branch (1301:2): [True: 0, False: 215] ------------------ 1302| 0| return DST_R_UNSUPPORTEDALG; 1303| 215| } 1304| 215| return ISC_R_SUCCESS; 1305| 215|} dst_algorithm_tosecalg: 2596| 2|dst_algorithm_tosecalg(dst_algorithm_t dst_alg) { 2597| 2| static dns_secalg_t dns_alg[DST_MAX_ALGS] = { 2598| 2| [DST_ALG_RSASHA256PRIVATEOID] = DNS_KEYALG_PRIVATEOID, 2599| 2| [DST_ALG_RSASHA512PRIVATEOID] = DNS_KEYALG_PRIVATEOID, 2600| 2| }; 2601| | 2602| 2| if (dst_alg < 256) { ------------------ | Branch (2602:6): [True: 2, False: 0] ------------------ 2603| 2| return dst_alg; 2604| 2| } 2605| 0| if (dst_alg < DST_MAX_ALGS) { ------------------ | Branch (2605:6): [True: 0, False: 0] ------------------ 2606| 0| return dns_alg[dst_alg]; 2607| 0| } 2608| 0| return 0; 2609| 0|} dst_api.c:get_key_struct: 1379| 98| dns_rdataclass_t rdclass, dns_ttl_t ttl, isc_mem_t *mctx) { 1380| 98| dst_key_t *key; 1381| | 1382| 98| key = isc_mem_get(mctx, sizeof(dst_key_t)); ------------------ | | 128| 98|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1383| 98| *key = (dst_key_t){ 1384| 98| .key_name = isc_mem_get(mctx, sizeof(dns_name_t)), ------------------ | | 128| 98|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1385| 98| .key_alg = alg, 1386| 98| .key_flags = flags, 1387| 98| .key_proto = protocol, 1388| 98| .key_size = bits, 1389| 98| .key_class = rdclass, 1390| 98| .key_ttl = ttl, 1391| 98| .func = dst_t_func[alg], 1392| 98| }; 1393| | 1394| 98| dns_name_init(key->key_name); 1395| 98| dns_name_dup(name, mctx, key->key_name); 1396| | 1397| 98| isc_refcount_init(&key->refs, 1); ------------------ | | 44| 98|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 1398| 98| isc_mem_attach(mctx, &key->mctx); 1399| | 1400| 98| isc_mutex_init(&key->mdlock); ------------------ | | 68| 98|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 98| { \ | | | | 80| 98| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 98| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 98| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 98] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 98| } | | ------------------ ------------------ 1401| | 1402| 98| key->magic = KEY_MAGIC; ------------------ | | 53| 98|#define KEY_MAGIC ISC_MAGIC('D', 'S', 'T', 'K') | | ------------------ | | | | 31| 98|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1403| 98| return key; 1404| 98|} dst_api.c:computeid: 2068| 2|computeid(dst_key_t *key) { 2069| 2| isc_buffer_t dnsbuf; 2070| 2| unsigned char dns_array[DST_KEY_MAXSIZE]; 2071| 2| isc_region_t r; 2072| | 2073| 2| isc_buffer_init(&dnsbuf, dns_array, sizeof(dns_array)); 2074| 2| RETERR(dst_key_todns(key, &dnsbuf)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 2075| | 2076| 2| isc_buffer_usedregion(&dnsbuf, &r); 2077| 2| key->key_id = dst_region_computeid(&r); 2078| 2| key->key_rid = dst_region_computerid(&r); 2079| 2| return ISC_R_SUCCESS; 2080| 2|} dst_api.c:frombuffer: 2085| 98| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 2086| 98| dst_key_t *key; 2087| 98| isc_result_t result; 2088| | 2089| 98| REQUIRE(dns_name_isabsolute(name)); ------------------ | | 194| 98|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 98| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 98, False: 0] | | | | ------------------ | | | | 43| 98| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2090| 98| REQUIRE(source != NULL); ------------------ | | 194| 98|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 98| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 98, False: 0] | | | | ------------------ | | | | 43| 98| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2091| 98| REQUIRE(mctx != NULL); ------------------ | | 194| 98|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 98| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 98, False: 0] | | | | ------------------ | | | | 43| 98| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2092| 98| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 194| 98|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 196| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 98, False: 0] | | | | | Branch (42:11): [True: 98, False: 0] | | | | ------------------ | | | | 43| 98| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2093| | 2094| 98| if (alg == DNS_KEYALG_PRIVATEDNS) { ------------------ | Branch (2094:6): [True: 0, False: 98] ------------------ 2095| 0| isc_buffer_t b = *source; 2096| 0| alg = dst_algorithm_fromprivatedns(&b); 2097| 0| if (alg == 0) { ------------------ | Branch (2097:7): [True: 0, False: 0] ------------------ 2098| 0| return DST_R_UNSUPPORTEDALG; 2099| 0| } 2100| 0| } 2101| | 2102| 98| if (alg == DNS_KEYALG_PRIVATEOID) { ------------------ | Branch (2102:6): [True: 0, False: 98] ------------------ 2103| 0| isc_buffer_t b = *source; 2104| 0| alg = dst_algorithm_fromprivateoid(&b); 2105| 0| if (alg == 0) { ------------------ | Branch (2105:7): [True: 0, False: 0] ------------------ 2106| 0| return DST_R_UNSUPPORTEDALG; 2107| 0| } 2108| 0| } 2109| | 2110| 98| key = get_key_struct(name, alg, flags, protocol, 0, rdclass, 0, mctx); 2111| | 2112| 98| if (isc_buffer_remaininglength(source) > 0) { ------------------ | | 159| 98|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (2112:6): [True: 98, False: 0] ------------------ 2113| 98| result = algorithm_status(alg); 2114| 98| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2114:7): [True: 0, False: 98] ------------------ 2115| 0| dst_key_free(&key); 2116| 0| return result; 2117| 0| } 2118| 98| if (key->func->fromdns == NULL) { ------------------ | Branch (2118:7): [True: 0, False: 98] ------------------ 2119| 0| dst_key_free(&key); 2120| 0| return DST_R_UNSUPPORTEDALG; 2121| 0| } 2122| | 2123| 98| result = key->func->fromdns(key, source); 2124| 98| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2124:7): [True: 0, False: 98] ------------------ 2125| 0| dst_key_free(&key); 2126| 0| return result; 2127| 0| } 2128| 98| } 2129| | 2130| 98| *keyp = key; 2131| 98| return ISC_R_SUCCESS; 2132| 98|} dst_api.c:algorithm_status: 2135| 165|algorithm_status(unsigned int alg) { 2136| 165| if (dst_algorithm_supported(alg)) { ------------------ | Branch (2136:6): [True: 165, False: 0] ------------------ 2137| 165| return ISC_R_SUCCESS; 2138| 165| } 2139| 0| return DST_R_UNSUPPORTEDALG; 2140| 165|} dns__dyndb_initialize: 55| 2|dns__dyndb_initialize(void) { 56| 2| isc_mutex_init(&dyndb_lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 57| | ISC_LIST_INIT(dyndb_implementations); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 58| 2|} dns_fixedname_init: 19| 4.26k|dns_fixedname_init(dns_fixedname_t *fixed) { 20| 4.26k| dns_name_init(&fixed->name); 21| 4.26k| isc_buffer_init(&fixed->buffer, fixed->data, DNS_NAME_MAXWIRE); ------------------ | | 190| 4.26k|#define DNS_NAME_MAXWIRE 255 ------------------ 22| 4.26k| dns_name_setbuffer(&fixed->name, &fixed->buffer); 23| 4.26k|} dns_fixedname_name: 31| 4.04k|dns_fixedname_name(dns_fixedname_t *fixed) { 32| 4.04k| return &fixed->name; 33| 4.04k|} dns_fixedname_initname: 36| 3.67k|dns_fixedname_initname(dns_fixedname_t *fixed) { 37| 3.67k| dns_fixedname_init(fixed); 38| 3.67k| return dns_fixedname_name(fixed); 39| 3.67k|} dns_fwdtable_create: 56| 2| dns_fwdtable_t **fwdtablep) { 57| 2| dns_fwdtable_t *fwdtable = NULL; 58| | 59| 2| REQUIRE(fwdtablep != NULL && *fwdtablep == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 60| | 61| 2| fwdtable = isc_mem_get(mctx, sizeof(*fwdtable)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 62| 2| *fwdtable = (dns_fwdtable_t){ .magic = FWDTABLEMAGIC }; ------------------ | | 35| 2|#define FWDTABLEMAGIC ISC_MAGIC('F', 'w', 'd', 'T') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 63| | 64| 2| dns_qpmulti_create(mctx, &qpmethods, view, &fwdtable->table); 65| | 66| 2| isc_mem_attach(mctx, &fwdtable->mctx); 67| 2| *fwdtablep = fwdtable; 68| 2|} hmac_link.c:hmac_createctx: 161| 46|hmac_createctx(const dst_key_t *key, dst_context_t *dctx) { 162| 46| isc_result_t result; 163| 46| isc_hmac_t *ctx = isc_hmac_new(); /* Either returns or abort()s */ 164| | 165| 46| result = isc_hmac_init(ctx, key->keydata.hmac_key); 166| 46| if (result != ISC_R_SUCCESS) { ------------------ | Branch (166:6): [True: 0, False: 46] ------------------ 167| 0| isc_hmac_free(ctx); 168| 0| return DST_R_UNSUPPORTEDALG; 169| 0| } 170| | 171| 46| dctx->ctxdata.hmac_ctx = ctx; 172| 46| return ISC_R_SUCCESS; 173| 46|} hmac_link.c:hmac_destroyctx: 176| 46|hmac_destroyctx(dst_context_t *dctx) { 177| 46| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 178| 46| REQUIRE(ctx != NULL); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 46| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 179| | 180| 46| isc_hmac_free(ctx); 181| | dctx->ctxdata.hmac_ctx = NULL; 182| 46|} hmac_link.c:hmac_adddata: 185| 311|hmac_adddata(const dst_context_t *dctx, const isc_region_t *data) { 186| 311| isc_result_t result; 187| 311| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 188| | 189| 311| REQUIRE(ctx != NULL); ------------------ | | 194| 311|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 311| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 311, False: 0] | | | | ------------------ | | | | 43| 311| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 190| | 191| 311| result = isc_hmac_update(ctx, data->base, data->length); 192| 311| if (result != ISC_R_SUCCESS) { ------------------ | Branch (192:6): [True: 0, False: 311] ------------------ 193| 0| return DST_R_OPENSSLFAILURE; 194| 0| } 195| | 196| 311| return ISC_R_SUCCESS; 197| 311|} hmac_link.c:hmac_verify: 209| 46|hmac_verify(const dst_context_t *dctx, const isc_region_t *sig) { 210| 46| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 211| 46| unsigned char digest[ISC_MAX_MD_SIZE]; 212| 46| isc_buffer_t hmac; 213| | 214| 46| REQUIRE(ctx != NULL); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 46| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 215| | 216| 46| isc_buffer_init(&hmac, digest, sizeof(digest)); 217| | 218| 46| if (isc_hmac_final(ctx, &hmac) != ISC_R_SUCCESS) { ------------------ | Branch (218:6): [True: 0, False: 46] ------------------ 219| 0| return DST_R_OPENSSLFAILURE; 220| 0| } 221| | 222| 46| if (sig->length > isc_buffer_usedlength(&hmac)) { ------------------ | | 157| 46|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ | Branch (222:6): [True: 0, False: 46] ------------------ 223| 0| return DST_R_VERIFYFAILURE; 224| 0| } 225| | 226| 46| return isc_safe_memequal(digest, sig->base, sig->length) ------------------ | Branch (226:9): [True: 6, False: 40] ------------------ 227| 46| ? ISC_R_SUCCESS 228| 46| : DST_R_VERIFYFAILURE; 229| 46|} hmac_link.c:hmac_fromdns: 302| 2|hmac_fromdns(isc_md_type_t type, dst_key_t *key, isc_buffer_t *data) { 303| 2| isc_hmac_key_t *hkey = NULL; 304| 2| isc_result_t result; 305| 2| isc_region_t r; 306| | 307| 2| isc_buffer_remainingregion(data, &r); 308| 2| if (r.length == 0) { ------------------ | Branch (308:6): [True: 0, False: 2] ------------------ 309| 0| return ISC_R_SUCCESS; 310| 0| } 311| | 312| 2| result = isc_hmac_key_create(type, r.base, r.length, key->mctx, &hkey); 313| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (313:6): [True: 0, False: 2] ------------------ 314| 0| return DST_R_OPENSSLFAILURE; 315| 0| } 316| | 317| 2| key->key_size = isc_hmac_key_expose(hkey).length * 8; 318| 2| key->keydata.hmac_key = hkey; 319| | 320| 2| isc_buffer_forward(data, r.length); 321| | 322| 2| return ISC_R_SUCCESS; 323| 2|} hmac_link.c:hmac_todns: 287| 2|hmac_todns(const dst_key_t *key, isc_buffer_t *data) { 288| 2| isc_region_t raw_key; 289| | 290| 2| REQUIRE(key != NULL && key->keydata.hmac_key != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 291| | 292| 2| raw_key = isc_hmac_key_expose(key->keydata.hmac_key); 293| | 294| 2| if (isc_buffer_availablelength(data) < raw_key.length) { ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (294:6): [True: 0, False: 2] ------------------ 295| 0| return ISC_R_NOSPACE; 296| 0| } 297| | 298| 2| return isc_buffer_copyregion(data, &raw_key); 299| 2|} hmac_link.c:hmacsha256_createctx: 57| 46| dst_context_t *dctx) { \ 58| 46| return (hmac_createctx(key, dctx)); \ 59| 46| } \ hmac_link.c:hmacsha256_destroyctx: 60| 46| static void hmac##alg##_destroyctx(dst_context_t *dctx) { \ 61| 46| hmac_destroyctx(dctx); \ 62| 46| } \ hmac_link.c:hmacsha256_adddata: 64| 311| const isc_region_t *data) { \ 65| 311| return (hmac_adddata(dctx, data)); \ 66| 311| } \ hmac_link.c:hmacsha256_verify: 72| 46| const isc_region_t *sig) { \ 73| 46| return (hmac_verify(dctx, sig)); \ 74| 46| } \ hmac_link.c:hmacsha256_todns: 90| 2| isc_buffer_t *data) { \ 91| 2| return (hmac_todns(key, data)); \ 92| 2| } \ hmac_link.c:hmacsha256_fromdns: 94| 2| isc_buffer_t *data) { \ 95| 2| return (hmac_fromdns(ISC_MD_##alg, key, data)); \ ------------------ | | 51| 2|#define ISC_MD_sha256 ISC_MD_SHA256 ------------------ 96| 2| } \ name.c:dns_decompress_getpermitted: 251| 900|dns_decompress_getpermitted(dns_decompress_t dctx) { 252| 900| return dctx == DNS_DECOMPRESS_ALWAYS || ------------------ | Branch (252:9): [True: 898, False: 2] ------------------ 253| 2| dctx == DNS_DECOMPRESS_PERMITTED; ------------------ | Branch (253:9): [True: 0, False: 2] ------------------ 254| 900|} rdata.c:dns_decompress_setpermitted: 237| 1.94k|dns_decompress_setpermitted(dns_decompress_t dctx, bool permitted) { 238| 1.94k| if (dctx == DNS_DECOMPRESS_NEVER || dctx == DNS_DECOMPRESS_ALWAYS) { ------------------ | Branch (238:6): [True: 0, False: 1.94k] | Branch (238:38): [True: 1.94k, False: 0] ------------------ 239| 1.94k| return dctx; 240| 1.94k| } else if (permitted) { ------------------ | Branch (240:13): [True: 0, False: 0] ------------------ 241| 0| return DNS_DECOMPRESS_PERMITTED; 242| 0| } else { 243| 0| return DNS_DECOMPRESS_DEFAULT; 244| 0| } 245| 1.94k|} dns_lib_initialize: 36| 2|dns_lib_initialize(void) { 37| 2| isc__lib_initialize(); 38| 2| dns__lib_initialize(); 39| 2|} fixedname.c:dns_name_init: 209| 4.26k|dns_name_init(dns_name_t *name) { 210| 4.26k| *name = (dns_name_t){ 211| 4.26k| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 4.26k|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 4.26k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 4.26k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.26k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.26k| { \ | | | | 27| 4.26k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.26k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.26k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.26k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.26k| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 4.26k| { \ | | 22| 4.26k| .head = NULL, \ | | 23| 4.26k| .tail = NULL, \ | | 24| 4.26k| } ------------------ 214| 4.26k| }; 215| 4.26k|} fixedname.c:dns_name_setbuffer: 298| 4.26k|dns_name_setbuffer(dns_name_t *name, isc_buffer_t *buffer) { 299| 4.26k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 4.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8.53k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.26k, False: 0] | | | | | Branch (42:11): [True: 4.26k, False: 0] | | | | ------------------ | | | | 43| 4.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 300| 4.26k| REQUIRE((buffer != NULL && name->buffer == NULL) || (buffer == NULL)); ------------------ | | 194| 4.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.26k, False: 0] | | | | | Branch (42:11): [True: 4.26k, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 4.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 301| | 302| 4.26k| name->buffer = buffer; 303| 4.26k|} name.c:dns_name_countlabels: 595| 10|dns_name_countlabels(const dns_name_t *name) { 596| 10| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 597| | 598| | return dns_name_offsets(name, NULL); 599| 10|} name.c:dns_name_invalidate: 264| 96|dns_name_invalidate(dns_name_t *name) { 265| 96| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 96, False: 0] | | | | | Branch (42:11): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 266| | 267| 96| name->magic = 0; 268| 96| name->ndata = NULL; 269| 96| name->length = 0; 270| 96| name->attributes = (struct dns_name_attrs){}; 271| 96| name->buffer = NULL; 272| 96| ISC_LINK_INIT(name, link); ------------------ | | 57| 96|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 96| do { \ | | | | 54| 96| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 96|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 96| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 96|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 96| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 96] | | | | ------------------ | | ------------------ ------------------ 273| 96|} qpzone.c:dns_name_init: 209| 6|dns_name_init(dns_name_t *name) { 210| 6| *name = (dns_name_t){ 211| 6| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 6|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 6|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 6| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 6|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 6| { \ | | | | 27| 6| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 6| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 6| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 6| { \ | | 22| 6| .head = NULL, \ | | 23| 6| .tail = NULL, \ | | 24| 6| } ------------------ 214| 6| }; 215| 6|} qpzone.c:dns_name_countlabels: 595| 12|dns_name_countlabels(const dns_name_t *name) { 596| 12| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 12, False: 0] | | | | | Branch (42:11): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 597| | 598| | return dns_name_offsets(name, NULL); 599| 12|} rdata.c:dns_name_init: 209| 4.49k|dns_name_init(dns_name_t *name) { 210| 4.49k| *name = (dns_name_t){ 211| 4.49k| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 4.49k|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 4.49k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 4.49k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.49k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.49k| { \ | | | | 27| 4.49k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.49k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.49k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.49k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.49k| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 4.49k| { \ | | 22| 4.49k| .head = NULL, \ | | 23| 4.49k| .tail = NULL, \ | | 24| 4.49k| } ------------------ 214| 4.49k| }; 215| 4.49k|} tsig.c:dns_name_toregion: 705| 92|dns_name_toregion(const dns_name_t *name, isc_region_t *r) { 706| 92| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 92|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 184| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 92, False: 0] | | | | | Branch (42:11): [True: 92, False: 0] | | | | ------------------ | | | | 43| 92| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 707| 92| REQUIRE(r != NULL); ------------------ | | 194| 92|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 92| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 92, False: 0] | | | | ------------------ | | | | 43| 92| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 708| | 709| 92| r->base = name->ndata; 710| 92| r->length = name->length; 711| 92|} zone.c:dns_name_init: 209| 2|dns_name_init(dns_name_t *name) { 210| 2| *name = (dns_name_t){ 211| 2| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 2|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 214| 2| }; 215| 2|} dst_api.c:dns_name_init: 209| 98|dns_name_init(dns_name_t *name) { 210| 98| *name = (dns_name_t){ 211| 98| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 98|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 98|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 98| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 98|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 98| { \ | | | | 27| 98| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 98|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 98| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 98|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 98| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 98| { \ | | 22| 98| .head = NULL, \ | | 23| 98| .tail = NULL, \ | | 24| 98| } ------------------ 214| 98| }; 215| 98|} master.c:dns_name_toregion: 705| 4|dns_name_toregion(const dns_name_t *name, isc_region_t *r) { 706| 4| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 707| 4| REQUIRE(r != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 708| | 709| 4| r->base = name->ndata; 710| 4| r->length = name->length; 711| 4|} message.c:dns_rdatatype_questiononly: 622| 95|dns_rdatatype_questiononly(dns_rdatatype_t type) { 623| 95| return (dns_rdatatype_attributes(type) & 624| 95| DNS_RDATATYPEATTR_QUESTIONONLY) != 0; 625| 95|} rdatavec.c:dns_rdatatype_issig: 735| 6|dns_rdatatype_issig(dns_rdatatype_t type) { 736| 6| return type == dns_rdatatype_rrsig; ------------------ | | 160| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ 737| 6|} master.c:dns_rdatatype_ismeta: 581| 6|dns_rdatatype_ismeta(dns_rdatatype_t type) { 582| 6| return (dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_META) != 0; 583| 6|} master.c:dns_rdatatype_atparent: 649| 6|dns_rdatatype_atparent(dns_rdatatype_t type) { 650| 6| return (dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_ATPARENT) != 651| 6| 0; 652| 6|} master.c:dns_rdatatype_issig: 735| 6|dns_rdatatype_issig(dns_rdatatype_t type) { 736| 6| return type == dns_rdatatype_rrsig; ------------------ | | 160| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ 737| 6|} dns_iptable_create: 27| 4|dns_iptable_create(isc_mem_t *mctx, dns_iptable_t **target) { 28| 4| dns_iptable_t *tab = isc_mem_get(mctx, sizeof(*tab)); ------------------ | | 128| 4|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 29| 4| *tab = (dns_iptable_t){ 30| 4| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 4|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 31| 4| .magic = DNS_IPTABLE_MAGIC, ------------------ | | 35| 4|#define DNS_IPTABLE_MAGIC ISC_MAGIC('T', 'a', 'b', 'l') | | ------------------ | | | | 31| 4|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 32| 4| }; 33| 4| isc_mem_attach(mctx, &tab->mctx); 34| | 35| 4| isc_radix_create(mctx, &tab->radix, RADIX_MAXBITS); ------------------ | | 189| 4|#define RADIX_MAXBITS 128 ------------------ 36| | 37| 4| *target = tab; 38| 4|} dns_journal_open: 732| 2| dns_journal_t **journalp) { 733| 2| isc_result_t result; 734| 2| size_t namelen; 735| 2| char backup[1024]; 736| 2| bool writable, create; 737| | 738| 2| create = ((mode & DNS_JOURNAL_CREATE) != 0); ------------------ | | 45| 2|#define DNS_JOURNAL_CREATE 0x00000001 /* true */ ------------------ 739| 2| writable = ((mode & (DNS_JOURNAL_WRITE | DNS_JOURNAL_CREATE)) != 0); ------------------ | | 46| 2|#define DNS_JOURNAL_WRITE 0x00000002 ------------------ writable = ((mode & (DNS_JOURNAL_WRITE | DNS_JOURNAL_CREATE)) != 0); ------------------ | | 45| 2|#define DNS_JOURNAL_CREATE 0x00000001 /* true */ ------------------ 740| | 741| 2| result = journal_open(mctx, filename, writable, create, false, 742| 2| journalp); 743| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (743:6): [True: 2, False: 0] ------------------ 744| 2| namelen = strlen(filename); 745| 2| if (namelen > 4U && strcmp(filename + namelen - 4, ".jnl") == 0) ------------------ | Branch (745:7): [True: 2, False: 0] | Branch (745:23): [True: 2, False: 0] ------------------ 746| 2| { 747| 2| namelen -= 4; 748| 2| } 749| | 750| 2| result = snprintf(backup, sizeof(backup), "%.*s.jbk", 751| 2| (int)namelen, filename); 752| 2| if (result >= sizeof(backup)) { ------------------ | Branch (752:7): [True: 0, False: 2] ------------------ 753| 0| return ISC_R_NOSPACE; 754| 0| } 755| 2| result = journal_open(mctx, backup, writable, writable, false, 756| 2| journalp); 757| 2| } 758| 2| return result; 759| 2|} journal.c:journal_open: 585| 4| bool downgrade, dns_journal_t **journalp) { 586| 4| FILE *fp = NULL; 587| 4| isc_result_t result; 588| 4| journal_rawheader_t rawheader; 589| 4| dns_journal_t *j; 590| | 591| 4| REQUIRE(journalp != NULL && *journalp == NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 592| | 593| 4| j = isc_mem_get(mctx, sizeof(*j)); ------------------ | | 128| 4|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 594| 4| *j = (dns_journal_t){ .state = JOURNAL_STATE_INVALID, 595| 4| .filename = isc_mem_strdup(mctx, filename), ------------------ | | 144| 4|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 596| 4| .xhdr_version = XHDR_VERSION2 }; 597| 4| isc_mem_attach(mctx, &j->mctx); 598| | 599| 4| result = isc_stdio_open(j->filename, writable ? "rb+" : "rb", &fp); ------------------ | Branch (599:39): [True: 0, False: 4] ------------------ 600| 4| if (result == ISC_R_FILENOTFOUND) { ------------------ | Branch (600:6): [True: 4, False: 0] ------------------ 601| 4| if (create) { ------------------ | Branch (601:7): [True: 0, False: 4] ------------------ 602| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, 603| 0| DNS_LOGMODULE_JOURNAL, ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 604| 0| "journal file %s does not exist, " 605| 0| "creating it", 606| 0| j->filename); 607| 0| CHECK(journal_file_create(mctx, downgrade, filename)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 608| | /* 609| | * Retry. 610| | */ 611| 0| result = isc_stdio_open(j->filename, "rb+", &fp); 612| 4| } else { 613| 4| CLEANUP(ISC_R_NOTFOUND); ------------------ | | 262| 4| { \ | | 263| 4| result = (r); \ | | 264| 4| goto cleanup; \ | | 265| 4| } ------------------ 614| 0| } 615| 4| } 616| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (616:6): [True: 0, False: 0] ------------------ 617| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL, 618| 0| ISC_LOG_ERROR, "%s: open: %s", j->filename, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 619| 0| isc_result_totext(result)); 620| 0| CLEANUP(ISC_R_UNEXPECTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 621| 0| } 622| | 623| 0| j->fp = fp; 624| | 625| | /* 626| | * Set magic early so that seek/read can succeed. 627| | */ 628| 0| j->magic = DNS_JOURNAL_MAGIC; ------------------ | | 341| 0|#define DNS_JOURNAL_MAGIC ISC_MAGIC('J', 'O', 'U', 'R') | | ------------------ | | | | 31| 0|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 629| | 630| 0| CHECK(journal_seek(j, 0)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 631| 0| CHECK(journal_read(j, &rawheader, sizeof(rawheader))); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 632| | 633| 0| if (memcmp(rawheader.h.format, journal_header_ver1.format, ------------------ | Branch (633:6): [True: 0, False: 0] ------------------ 634| 0| sizeof(journal_header_ver1.format)) == 0) 635| 0| { 636| | /* 637| | * The file header says it's the old format, but it 638| | * still might have the new xhdr format because we 639| | * forgot to change the format string when we introduced 640| | * the new xhdr. When we first try to read it, we assume 641| | * it uses the new xhdr format. If that fails, we'll be 642| | * called a second time with compat set to true, in which 643| | * case we can lower xhdr_version to 1 if we find a 644| | * corrupt transaction. 645| | */ 646| 0| j->header_ver1 = true; 647| 0| } else if (memcmp(rawheader.h.format, initial_journal_header.format, ------------------ | Branch (647:13): [True: 0, False: 0] ------------------ 648| 0| sizeof(initial_journal_header.format)) == 0) 649| 0| { 650| | /* 651| | * File header says this is format version 2; all 652| | * transactions have to match. 653| | */ 654| 0| j->header_ver1 = false; 655| 0| } else { 656| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL, 657| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 658| 0| "%s: journal format not recognized", j->filename); 659| 0| CLEANUP(ISC_R_UNEXPECTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 660| 0| } 661| 0| journal_header_decode(&rawheader, &j->header); 662| | 663| | /* 664| | * If there is an index, read the raw index into a dynamically 665| | * allocated buffer and then convert it into a cooked index. 666| | */ 667| 0| if (j->header.index_size != 0) { ------------------ | Branch (667:6): [True: 0, False: 0] ------------------ 668| 0| unsigned int i; 669| 0| unsigned int rawbytes; 670| 0| unsigned char *p; 671| | 672| 0| rawbytes = ISC_CHECKED_MUL(j->header.index_size, ------------------ | | 32| 0| ({ \ | | 33| 0| typeof(a) _c; \ | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | 35| 0| INSIST(!_overflow); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 36| 0| _c; \ | | 37| 0| }) ------------------ 673| 0| sizeof(journal_rawpos_t)); 674| 0| j->rawindex = isc_mem_get(mctx, rawbytes); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 675| | 676| 0| CHECK(journal_read(j, j->rawindex, rawbytes)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 677| | 678| 0| j->index = isc_mem_cget(mctx, j->header.index_size, ------------------ | | 130| 0| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 131| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 679| 0| sizeof(journal_pos_t)); 680| | 681| 0| p = j->rawindex; 682| 0| for (i = 0; i < j->header.index_size; i++) { ------------------ | Branch (682:15): [True: 0, False: 0] ------------------ 683| 0| j->index[i].serial = decode_uint32(p); 684| 0| p += 4; 685| 0| j->index[i].offset = decode_uint32(p); 686| 0| p += 4; 687| 0| } 688| 0| INSIST(p == j->rawindex + rawbytes); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 689| 0| } 690| 0| j->offset = -1; /* Invalid, must seek explicitly. */ 691| | 692| | /* 693| | * Initialize the iterator. 694| | */ 695| 0| dns_name_init(&j->it.name); 696| 0| dns_rdata_init(&j->it.rdata); 697| | 698| | /* 699| | * Set up empty initial buffers for unchecked and checked 700| | * wire format RR data. They will be reallocated 701| | * later. 702| | */ 703| 0| isc_buffer_init(&j->it.source, NULL, 0); 704| 0| isc_buffer_init(&j->it.target, NULL, 0); 705| 0| j->it.dctx = DNS_DECOMPRESS_NEVER; 706| | 707| 0| j->state = writable ? JOURNAL_STATE_WRITE : JOURNAL_STATE_READ; ------------------ | Branch (707:13): [True: 0, False: 0] ------------------ 708| | 709| 0| *journalp = j; 710| 0| return ISC_R_SUCCESS; 711| | 712| 4|cleanup: 713| 4| j->magic = 0; 714| 4| if (j->rawindex != NULL) { ------------------ | Branch (714:6): [True: 0, False: 4] ------------------ 715| 0| isc_mem_cput(j->mctx, j->rawindex, j->header.index_size, ------------------ | | 155| 0| do { \ | | 156| 0| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 157| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 0| (p) = NULL; \ | | 159| 0| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 0] | | ------------------ ------------------ 716| 0| sizeof(journal_rawpos_t)); 717| 0| } 718| 4| if (j->index != NULL) { ------------------ | Branch (718:6): [True: 0, False: 4] ------------------ 719| 0| isc_mem_cput(j->mctx, j->index, j->header.index_size, ------------------ | | 155| 0| do { \ | | 156| 0| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 157| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 0| (p) = NULL; \ | | 159| 0| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 0] | | ------------------ ------------------ 720| 0| sizeof(journal_pos_t)); 721| 0| } 722| 4| isc_mem_free(j->mctx, j->filename); ------------------ | | 166| 4| do { \ | | 167| 4| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 4| (p) = NULL; \ | | 169| 4| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 4] | | ------------------ ------------------ 723| 4| if (j->fp != NULL) { ------------------ | Branch (723:6): [True: 0, False: 4] ------------------ 724| 0| (void)isc_stdio_close(j->fp); 725| 0| } 726| | isc_mem_putanddetach(&j->mctx, j, sizeof(*j)); ------------------ | | 161| 4| do { \ | | 162| 4| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 4| (p) = NULL; \ | | 164| 4| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 4] | | ------------------ ------------------ 727| 4| return result; 728| 0|} dst_region_computeid: 30| 217|dst_region_computeid(const isc_region_t *source) { 31| 217| uint32_t ac; 32| 217| const unsigned char *p; 33| 217| int size; 34| | 35| 217| REQUIRE(source != NULL); ------------------ | | 194| 217|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 217| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 217, False: 0] | | | | ------------------ | | | | 43| 217| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 36| 217| REQUIRE(source->length >= 4); ------------------ | | 194| 217|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 217| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 217, False: 0] | | | | ------------------ | | | | 43| 217| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 37| | 38| 217| p = source->base; 39| 217| size = source->length; 40| | 41| 28.6k| for (ac = 0; size > 1; size -= 2, p += 2) { ------------------ | Branch (41:15): [True: 28.4k, False: 217] ------------------ 42| 28.4k| ac += ((*p) << 8) + *(p + 1); 43| 28.4k| } 44| | 45| 217| if (size > 0) { ------------------ | Branch (45:6): [True: 0, False: 217] ------------------ 46| 0| ac += ((*p) << 8); 47| 0| } 48| 217| ac += (ac >> 16) & 0xffff; 49| | 50| 217| return (uint16_t)(ac & 0xffff); 51| 217|} dst_region_computerid: 54| 98|dst_region_computerid(const isc_region_t *source) { 55| 98| uint32_t ac; 56| 98| const unsigned char *p; 57| 98| int size; 58| | 59| 98| REQUIRE(source != NULL); ------------------ | | 194| 98|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 98| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 98, False: 0] | | | | ------------------ | | | | 43| 98| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 60| 98| REQUIRE(source->length >= 4); ------------------ | | 194| 98|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 98| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 98, False: 0] | | | | ------------------ | | | | 43| 98| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 61| | 62| 98| p = source->base; 63| 98| size = source->length; 64| | 65| 98| ac = ((*p) << 8) + *(p + 1); 66| 98| ac |= DNS_KEYFLAG_REVOKE; 67| 12.6k| for (size -= 2, p += 2; size > 1; size -= 2, p += 2) { ------------------ | Branch (67:26): [True: 12.5k, False: 98] ------------------ 68| 12.5k| ac += ((*p) << 8) + *(p + 1); 69| 12.5k| } 70| | 71| 98| if (size > 0) { ------------------ | Branch (71:6): [True: 0, False: 98] ------------------ 72| 0| ac += ((*p) << 8); 73| 0| } 74| 98| ac += (ac >> 16) & 0xffff; 75| | 76| 98| return (uint16_t)(ac & 0xffff); 77| 98|} dst_key_name: 80| 19|dst_key_name(const dst_key_t *key) { 81| 19| REQUIRE(VALID_KEY(key)); ------------------ | | 194| 19|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 19, False: 0] | | | | | Branch (42:11): [True: 19, False: 0] | | | | ------------------ | | | | 43| 19| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 82| 19| return key->key_name; 83| 19|} dst_key_size: 86| 2|dst_key_size(const dst_key_t *key) { 87| 2| REQUIRE(VALID_KEY(key)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 88| 2| return key->key_size; 89| 2|} dst_key_alg: 92| 217|dst_key_alg(const dst_key_t *key) { 93| 217| REQUIRE(VALID_KEY(key)); ------------------ | | 194| 217|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 434| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 217, False: 0] | | | | | Branch (42:11): [True: 217, False: 0] | | | | ------------------ | | | | 43| 217| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 94| 217| return key->key_alg; 95| 217|} dst_key_getbits: 213| 14|dst_key_getbits(const dst_key_t *key) { 214| 14| REQUIRE(VALID_KEY(key)); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 14, False: 0] | | | | | Branch (42:11): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 215| 14| return key->key_bits; 216| 14|} dns__lib_initialize: 44| 2|dns__lib_initialize(void) { 45| 2| if (isc_refcount_increment0(&dns__lib_references) > 0) { ------------------ | | 68| 2| ({ \ | | 69| 2| uint_fast32_t __v; \ | | 70| 2| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 2| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 71| 2| INSIST(__v < UINT32_MAX); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 2| __v; \ | | 73| 2| }) ------------------ | Branch (45:6): [True: 0, False: 2] ------------------ 46| 0| return; 47| 0| } 48| | 49| 2| dst__lib_initialize(); 50| 2| dns__acl_initialize(); 51| 2| dns__dlz_initialize(); 52| 2| dns__db_initialize(); 53| 2| dns__dyndb_initialize(); 54| 2| dns__qp_initialize(); 55| 2| dns__qpzone_initialize(); 56| 2| dns__zone_keymgmt_initialize(); 57| 2|} dns_master_loadfile: 2551| 2| dns_ttl_t maxttl) { 2552| 2| dns_loadctx_t *lctx = NULL; 2553| 2| isc_result_t result; 2554| | 2555| 2| loadctx_create(format, mctx, options, resign, top, zclass, origin, 2556| 2| callbacks, NULL, NULL, include_cb, include_arg, NULL, 2557| 2| &lctx); 2558| | 2559| 2| lctx->maxttl = maxttl; 2560| | 2561| 2| CHECK((lctx->openfile)(lctx, master_file)); ------------------ | | 251| 2| { \ | | 252| 2| result = (r); \ | | 253| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 2] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 2| } ------------------ 2562| | 2563| 2| result = (lctx->load)(lctx); 2564| 2| INSIST(result != DNS_R_CONTINUE); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2565| | 2566| 2|cleanup: 2567| 2| dns_loadctx_detach(&lctx); 2568| 2| return result; 2569| 2|} dns_master_initrawheader: 2912| 2|dns_master_initrawheader(dns_masterrawheader_t *header) { 2913| 2| memset(header, 0, sizeof(dns_masterrawheader_t)); 2914| 2|} master.c:loadctx_destroy: 414| 2|loadctx_destroy(dns_loadctx_t *lctx) { 415| 2| REQUIRE(DNS_LCTX_VALID(lctx)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 416| | 417| 2| isc_refcount_destroy(&lctx->references); ------------------ | | 60| 2| ISC_REQUIRE(isc_refcount_current(target) == 0) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 418| | 419| 2| lctx->magic = 0; 420| 2| if (lctx->inc != NULL) { ------------------ | Branch (420:6): [True: 2, False: 0] ------------------ 421| 2| incctx_destroy(lctx->mctx, lctx->inc); 422| 2| } 423| | 424| 2| if (lctx->f != NULL) { ------------------ | Branch (424:6): [True: 0, False: 2] ------------------ 425| 0| isc_result_t result = isc_stdio_close(lctx->f); 426| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (426:7): [True: 0, False: 0] ------------------ 427| 0| UNEXPECTED_ERROR("isc_stdio_close() failed: %s", ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 428| 0| isc_result_totext(result)); 429| 0| } 430| 0| } 431| | 432| | /* isc_lex_destroy() will close all open streams */ 433| 2| if (lctx->lex != NULL && !lctx->keep_lex) { ------------------ | Branch (433:6): [True: 2, False: 0] | Branch (433:27): [True: 2, False: 0] ------------------ 434| 2| isc_lex_destroy(&lctx->lex); 435| 2| } 436| | 437| | isc_mem_putanddetach(&lctx->mctx, lctx, sizeof(*lctx)); ------------------ | | 161| 2| do { \ | | 162| 2| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 2| (p) = NULL; \ | | 164| 2| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 2] | | ------------------ ------------------ 438| 2|} master.c:incctx_destroy: 398| 2|incctx_destroy(isc_mem_t *mctx, dns_incctx_t *ictx) { 399| 2| dns_incctx_t *parent; 400| | 401| 2|again: 402| 2| parent = ictx->parent; 403| 2| ictx->parent = NULL; 404| | 405| 2| isc_mem_put(mctx, ictx, sizeof(*ictx)); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 406| | 407| 2| if (parent != NULL) { ------------------ | Branch (407:6): [True: 0, False: 2] ------------------ 408| 0| ictx = parent; 409| 0| goto again; 410| 0| } 411| 2|} master.c:loadctx_create: 478| 2| isc_lex_t *lex, dns_loadctx_t **lctxp) { 479| 2| dns_loadctx_t *lctx = NULL; 480| 2| isc_region_t r; 481| | 482| 2| REQUIRE(lctxp != NULL && *lctxp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 483| 2| REQUIRE(callbacks != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 484| 2| REQUIRE(callbacks->update != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 485| 2| REQUIRE(callbacks->error != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 486| 2| REQUIRE(callbacks->warn != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 487| 2| REQUIRE(mctx != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 488| 2| REQUIRE(dns_name_isabsolute(top)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 489| 2| REQUIRE(dns_name_isabsolute(origin)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 490| | 491| 2| lctx = isc_mem_get(mctx, sizeof(*lctx)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 492| 2| *lctx = (dns_loadctx_t){ 493| 2| .format = format, 494| 2| .ttl_known = ((options & DNS_MASTER_NOTTL) != 0), ------------------ | | 57| 2|#define DNS_MASTER_NOTTL 0x00008000 /*%< Don't require ttl. */ ------------------ 495| 2| .default_ttl_known = ((options & DNS_MASTER_NOTTL) != 0), ------------------ | | 57| 2|#define DNS_MASTER_NOTTL 0x00008000 /*%< Don't require ttl. */ ------------------ 496| 2| .warn_1035 = true, 497| 2| .warn_sigexpired = true, 498| 2| .options = options, 499| 2| .zclass = zclass, 500| 2| .resign = resign, 501| 2| .include_cb = include_cb, 502| 2| .include_arg = include_arg, 503| 2| .first = true, 504| 2| .done = done, 505| 2| .callbacks = callbacks, 506| 2| .done_arg = done_arg, 507| 2| }; 508| | 509| 2| incctx_create(mctx, origin, &lctx->inc); 510| | 511| 2| switch (format) { 512| 2| case dns_masterformat_text: ------------------ | Branch (512:2): [True: 2, False: 0] ------------------ 513| 2| lctx->openfile = openfile_text; 514| 2| lctx->load = load_text; 515| 2| break; 516| 0| case dns_masterformat_raw: ------------------ | Branch (516:2): [True: 0, False: 2] ------------------ 517| 0| lctx->openfile = openfile_raw; 518| 0| lctx->load = load_raw; 519| 0| break; 520| 0| default: ------------------ | Branch (520:2): [True: 0, False: 2] ------------------ 521| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 522| 2| } 523| | 524| 2| if (lex != NULL) { ------------------ | Branch (524:6): [True: 0, False: 2] ------------------ 525| 0| lctx->lex = lex; 526| 0| lctx->keep_lex = true; 527| 2| } else { 528| 2| isc_lexspecials_t specials; 529| 2| lctx->lex = NULL; 530| 2| isc_lex_create(mctx, TOKENSIZ, &lctx->lex); ------------------ | | 84| 2|#define TOKENSIZ (8 * 1024) ------------------ 531| 2| lctx->keep_lex = false; 532| | /* 533| | * If specials change update dns_test_rdatafromstring() 534| | * in lib/dns/tests/dnstest.c. 535| | */ 536| 2| memset(specials, 0, sizeof(specials)); 537| 2| specials[0] = 1; 538| 2| specials['('] = 1; 539| 2| specials[')'] = 1; 540| 2| specials['"'] = 1; 541| 2| isc_lex_setspecials(lctx->lex, specials); 542| 2| isc_lex_setcomments(lctx->lex, ISC_LEXCOMMENT_DNSMASTERFILE); ------------------ | | 97| 2|#define ISC_LEXCOMMENT_DNSMASTERFILE 0x08 ------------------ 543| 2| } 544| | 545| 2| lctx->now = isc_stdtime_now(); 546| | 547| 2| lctx->top = dns_fixedname_initname(&lctx->fixed_top); 548| 2| dns_name_toregion(top, &r); 549| 2| dns_name_fromregion(lctx->top, &r); 550| | 551| 2| dns_master_initrawheader(&lctx->header); 552| | 553| 2| isc_refcount_init(&lctx->references, 1); /* Implicit attach. */ ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 554| 2| isc_mem_attach(mctx, &lctx->mctx); 555| | 556| 2| lctx->magic = DNS_LCTX_MAGIC; ------------------ | | 173| 2|#define DNS_LCTX_MAGIC ISC_MAGIC('L', 'c', 't', 'x') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 557| 2| *lctxp = lctx; 558| 2| return; 559| 2|} master.c:incctx_create: 441| 2|incctx_create(isc_mem_t *mctx, dns_name_t *origin, dns_incctx_t **ictxp) { 442| 2| dns_incctx_t *ictx; 443| 2| isc_region_t r; 444| 2| int i; 445| | 446| 2| ictx = isc_mem_get(mctx, sizeof(*ictx)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 447| | 448| 10| for (i = 0; i < NBUFS; i++) { ------------------ | | 63| 10|#define NBUFS 4 ------------------ | Branch (448:14): [True: 8, False: 2] ------------------ 449| 8| dns_fixedname_init(&ictx->fixed[i]); 450| 8| ictx->in_use[i] = false; 451| 8| } 452| | 453| 2| ictx->origin_in_use = 0; 454| 2| ictx->origin = dns_fixedname_name(&ictx->fixed[ictx->origin_in_use]); 455| 2| ictx->in_use[ictx->origin_in_use] = true; 456| 2| dns_name_toregion(origin, &r); 457| 2| dns_name_fromregion(ictx->origin, &r); 458| | 459| 2| ictx->glue = NULL; 460| 2| ictx->current = NULL; 461| 2| ictx->glue_in_use = -1; 462| 2| ictx->current_in_use = -1; 463| 2| ictx->parent = NULL; 464| 2| ictx->drop = false; 465| 2| ictx->glue_line = 0; 466| 2| ictx->current_line = 0; 467| 2| ictx->origin_changed = true; 468| | 469| 2| *ictxp = ictx; 470| 2|} master.c:openfile_text: 967| 2|openfile_text(dns_loadctx_t *lctx, const char *master_file) { 968| 2| return isc_lex_openfile(lctx->lex, master_file); 969| 2|} master.c:load_text: 985| 2|load_text(dns_loadctx_t *lctx) { 986| 2| dns_rdataclass_t rdclass; 987| 2| dns_rdatatype_t type, covers; 988| 2| uint32_t ttl_offset = 0; 989| 2| dns_name_t *new_name = NULL; 990| 2| bool current_has_delegation = false; 991| 2| bool finish_origin = false; 992| 2| bool finish_include = false; 993| 2| bool read_till_eol = false; 994| 2| bool initialws; 995| 2| char *include_file = NULL; 996| 2| isc_token_t token; 997| 2| isc_result_t result = ISC_R_UNEXPECTED; 998| 2| rdatalist_head_t glue_list; 999| 2| rdatalist_head_t current_list; 1000| 2| dns_rdatalist_t *rdatalist = NULL; 1001| 2| dns_rdatalist_t *new_rdatalist = NULL; 1002| 2| int rdlcount = 0; 1003| 2| int rdlcount_save = 0; 1004| 2| int rdatalist_size = 0; 1005| 2| isc_buffer_t buffer; 1006| 2| isc_buffer_t target; 1007| 2| isc_buffer_t target_ft; 1008| 2| isc_buffer_t target_save; 1009| 2| dns_rdata_t *rdata = NULL; 1010| 2| dns_rdata_t *new_rdata = NULL; 1011| 2| int rdcount = 0; 1012| 2| int rdcount_save = 0; 1013| 2| int rdata_size = 0; 1014| 2| unsigned char *target_mem = NULL; 1015| 2| int target_size = TSIZ; ------------------ | | 72| 2|#define TSIZ (128 * 1024) ------------------ 1016| 2| int new_in_use; 1017| 2| isc_mem_t *mctx = NULL; 1018| 2| dns_rdatacallbacks_t *callbacks = NULL; 1019| 2| dns_incctx_t *ictx = NULL; 1020| 2| char *range = NULL; 1021| 2| char *lhs = NULL; 1022| 2| char *gtype = NULL; 1023| 2| char *rhs = NULL; 1024| 2| const char *source = NULL; 1025| 2| unsigned long line = 0; 1026| 2| bool explicit_ttl; 1027| 2| char classname1[DNS_RDATACLASS_FORMATSIZE]; 1028| 2| char classname2[DNS_RDATACLASS_FORMATSIZE]; 1029| 2| unsigned int options = 0; 1030| | 1031| 2| REQUIRE(DNS_LCTX_VALID(lctx)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1032| 2| callbacks = lctx->callbacks; 1033| 2| mctx = lctx->mctx; 1034| 2| ictx = lctx->inc; 1035| | 1036| 2| ISC_LIST_INIT(glue_list); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 1037| 2| ISC_LIST_INIT(current_list); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 1038| | 1039| | /* 1040| | * Allocate target_size of buffer space. This is greater than twice 1041| | * the maximum individual RR data size. 1042| | */ 1043| 2| target_mem = isc_mem_get(mctx, target_size); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1044| 2| isc_buffer_init(&target, target_mem, target_size); 1045| 2| target_save = target; 1046| | 1047| | /* open a database transaction */ 1048| 2| if (callbacks->setup != NULL) { ------------------ | Branch (1048:6): [True: 2, False: 0] ------------------ 1049| 2| callbacks->setup(callbacks->add_private); 1050| 2| } 1051| | 1052| 2| if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) { ------------------ | | 47| 2|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ | Branch (1052:6): [True: 0, False: 2] ------------------ 1053| 0| options |= DNS_RDATA_CHECKNAMES; ------------------ | | 210| 0|#define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES | | ------------------ | | | | 135| 0|#define DNS_NAME_CHECKNAMES 0x0002 /*%< Used by rdata. */ | | ------------------ ------------------ 1054| 0| } 1055| 2| if ((lctx->options & DNS_MASTER_CHECKNAMESFAIL) != 0) { ------------------ | | 48| 2|#define DNS_MASTER_CHECKNAMESFAIL 0x00000200 ------------------ | Branch (1055:6): [True: 0, False: 2] ------------------ 1056| 0| options |= DNS_RDATA_CHECKNAMESFAIL; ------------------ | | 211| 0|#define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL | | ------------------ | | | | 136| 0|#define DNS_NAME_CHECKNAMESFAIL 0x0004 /*%< Used by rdata. */ | | ------------------ ------------------ 1057| 0| } 1058| 2| if ((lctx->options & DNS_MASTER_CHECKMX) != 0) { ------------------ | | 52| 2|#define DNS_MASTER_CHECKMX 0x00000800 ------------------ | Branch (1058:6): [True: 0, False: 2] ------------------ 1059| 0| options |= DNS_RDATA_CHECKMX; ------------------ | | 213| 0|#define DNS_RDATA_CHECKMX DNS_NAME_CHECKMX | | ------------------ | | | | 138| 0|#define DNS_NAME_CHECKMX 0x0010 /*%< Used by rdata. */ | | ------------------ ------------------ 1060| 0| } 1061| 2| if ((lctx->options & DNS_MASTER_CHECKMXFAIL) != 0) { ------------------ | | 53| 2|#define DNS_MASTER_CHECKMXFAIL 0x00001000 ------------------ | Branch (1061:6): [True: 0, False: 2] ------------------ 1062| 0| options |= DNS_RDATA_CHECKMXFAIL; ------------------ | | 214| 0|#define DNS_RDATA_CHECKMXFAIL DNS_NAME_CHECKMXFAIL | | ------------------ | | | | 139| 0|#define DNS_NAME_CHECKMXFAIL 0x0020 /*%< Used by rdata. */ | | ------------------ ------------------ 1063| 0| } 1064| 2| source = isc_lex_getsourcename(lctx->lex); 1065| 8| while (true) { ------------------ | Branch (1065:9): [True: 8, Folded] ------------------ 1066| 8| dns_rdatalist_t *this = NULL; 1067| | 1068| 8| if (atomic_load_acquire(&lctx->canceled)) { ------------------ | | 50| 8|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (50:32): [True: 0, False: 8] | | ------------------ ------------------ 1069| 0| result = ISC_R_CANCELED; 1070| 0| goto log_and_cleanup; 1071| 0| } 1072| | 1073| 8| initialws = false; 1074| 8| line = isc_lex_getsourceline(lctx->lex); 1075| 8| GETTOKEN(lctx->lex, ISC_LEXOPT_INITIALWS | ISC_LEXOPT_QSTRING, ------------------ | | 259| 8| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 8| do { \ | | | | 215| 8| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 8| switch (result) { \ | | | | 217| 8| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 8, False: 0] | | | | ------------------ | | | | 218| 8| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 8] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 8] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 8] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 8| } \ | | | | 247| 8| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 8] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 8| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 1076| 8| &token, true); 1077| 8| line = isc_lex_getsourceline(lctx->lex); 1078| | 1079| 8| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1079:7): [True: 2, False: 6] ------------------ 1080| 2| if (read_till_eol) { ------------------ | Branch (1080:8): [True: 0, False: 2] ------------------ 1081| 0| WARNUNEXPECTEDEOF(lctx->lex); ------------------ | | 283| 0| do { \ | | 284| 0| if (isc_lex_isfile(lexer)) \ | | ------------------ | | | Branch (284:7): [True: 0, False: 0] | | ------------------ | | 285| 0| (*callbacks->warn)(callbacks, \ | | 286| 0| "%s: file does not end with " \ | | 287| 0| "newline", \ | | 288| 0| source); \ | | 289| 0| } while (0) | | ------------------ | | | Branch (289:11): [Folded, False: 0] | | ------------------ ------------------ 1082| 0| } 1083| | /* Pop the include stack? */ 1084| 2| if (ictx->parent != NULL) { ------------------ | Branch (1084:8): [True: 0, False: 2] ------------------ 1085| 0| COMMITALL; ------------------ | | 262| 0| do { \ | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | 264| 0| source, ictx->current_line); \ | | 265| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 266| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (267:14): [True: 0, False: 0] | | ------------------ | | 268| 0| goto insist_and_cleanup; \ | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | 270| 0| source, ictx->glue_line); \ | | 271| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 272| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (273:14): [True: 0, False: 0] | | ------------------ | | 274| 0| goto insist_and_cleanup; \ | | 275| 0| rdcount = 0; \ | | 276| 0| rdlcount = 0; \ | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | 278| 0| rdcount_save = rdcount; \ | | 279| 0| rdlcount_save = rdlcount; \ | | 280| 0| } while (0) | | ------------------ | | | Branch (280:11): [Folded, False: 0] | | ------------------ ------------------ 1086| 0| lctx->inc = ictx->parent; 1087| 0| ictx->parent = NULL; 1088| 0| incctx_destroy(lctx->mctx, ictx); 1089| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == ------------------ | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ ------------------ 1090| 0| ISC_R_SUCCESS); 1091| 0| line = isc_lex_getsourceline(lctx->lex); 1092| 0| POST(line); ------------------ | | 70| 0|#define POST(x) (void)(x) ------------------ 1093| 0| source = isc_lex_getsourcename(lctx->lex); 1094| 0| ictx = lctx->inc; 1095| 0| continue; 1096| 0| } 1097| 2| break; 1098| 2| } 1099| | 1100| 6| if (token.type == isc_tokentype_eol) { ------------------ | Branch (1100:7): [True: 0, False: 6] ------------------ 1101| 0| read_till_eol = false; 1102| 0| continue; /* blank line */ 1103| 0| } 1104| | 1105| 6| if (read_till_eol) { ------------------ | Branch (1105:7): [True: 0, False: 6] ------------------ 1106| 0| continue; 1107| 0| } 1108| | 1109| 6| if (token.type == isc_tokentype_initialws) { ------------------ | Branch (1109:7): [True: 0, False: 6] ------------------ 1110| | /* 1111| | * Still working on the same name. 1112| | */ 1113| 0| initialws = true; 1114| 6| } else if (token.type == isc_tokentype_string || ------------------ | Branch (1114:14): [True: 6, False: 0] ------------------ 1115| 0| token.type == isc_tokentype_qstring) ------------------ | Branch (1115:7): [True: 0, False: 0] ------------------ 1116| 6| { 1117| | /* 1118| | * "$" Support. 1119| | * 1120| | * "$ORIGIN" and "$INCLUDE" can both take domain names. 1121| | * The processing of "$ORIGIN" and "$INCLUDE" extends 1122| | * across the normal domain name processing. 1123| | */ 1124| | 1125| 6| if (strcasecmp(DNS_AS_STR(token), "$ORIGIN") == 0) { ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1125:8): [True: 0, False: 6] ------------------ 1126| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1127| 0| finish_origin = true; 1128| 6| } else if (strcasecmp(DNS_AS_STR(token), "$TTL") == 0) { ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1128:15): [True: 0, False: 6] ------------------ 1129| 0| GETTOKENERR(lctx->lex, 0, &token, false, ------------------ | | 214| 0| do { \ | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | 216| 0| switch (result) { \ | | 217| 0| case ISC_R_SUCCESS: \ | | ------------------ | | | Branch (217:3): [True: 0, False: 0] | | ------------------ | | 218| 0| break; \ | | 219| 0| case ISC_R_NOTFILE: \ | | ------------------ | | | Branch (219:3): [True: 0, False: 0] | | ------------------ | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | | Branch (221:8): [True: 0, False: 0] | | ------------------ | | 222| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 223| 0| COMMITALL; \ | | ------------------ | | | | 262| 0| do { \ | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | 264| 0| source, ictx->current_line); \ | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 266| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | ------------------ | | | | | Branch (267:14): [True: 0, False: 0] | | | | ------------------ | | | | 268| 0| goto insist_and_cleanup; \ | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | 270| 0| source, ictx->glue_line); \ | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 272| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | ------------------ | | | | | Branch (273:14): [True: 0, False: 0] | | | | ------------------ | | | | 274| 0| goto insist_and_cleanup; \ | | | | 275| 0| rdcount = 0; \ | | | | 276| 0| rdlcount = 0; \ | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | 278| 0| rdcount_save = rdcount; \ | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | 280| 0| } while (0) | | | | ------------------ | | | | | Branch (280:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 224| 0| lctx->inc = ictx->parent; \ | | 225| 0| ictx->parent = NULL; \ | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | ------------------ | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | ------------------ | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | ------------------ | | | | | Branch (241:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 228| 0| ISC_R_SUCCESS); \ | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | 230| 0| POST(line); \ | | ------------------ | | | | 70| 0|#define POST(x) (void)(x) | | ------------------ | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | 232| 0| ictx = lctx->inc; \ | | 233| 0| continue; \ | | 234| 0| } \ | | 235| 0| goto insist_and_cleanup; \ | | 236| 0| case ISC_R_UNEXPECTED: \ | | ------------------ | | | Branch (236:3): [True: 0, False: 0] | | ------------------ | | 237| 0| goto insist_and_cleanup; \ | | 238| 0| default: \ | | ------------------ | | | Branch (238:3): [True: 0, False: 0] | | ------------------ | | 239| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 240| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 241| 0| LOGIT(result); \ | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ | | 242| 0| read_till_eol = true; \ | | 243| 0| err goto next_line; \ | | 244| 0| } else \ | | 245| 0| goto log_and_cleanup; \ | | 246| 0| } \ | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | ------------------ | | | Branch (247:7): [True: 0, False: 0] | | ------------------ | | 248| 0| result = DNS_R_SYNTAX; \ | | 249| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 250| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 251| 0| LOGIT(result); \ | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ | | 252| 0| read_till_eol = true; \ | | 253| 0| goto next_line; \ | | 254| 0| } else \ | | 255| 0| goto log_and_cleanup; \ | | 256| 0| } \ | | 257| 0| } while (0) | | ------------------ | | | Branch (257:11): [Folded, False: 0] | | ------------------ ------------------ 1130| 0| lctx->ttl = 0; 1131| 0| lctx->default_ttl_known = true;); 1132| 0| result = dns_ttl_fromtext( 1133| 0| &token.value.as_textregion, &lctx->ttl); 1134| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1135| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1136| 0| lctx->ttl = 0; 1137| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1137:16): [True: 0, False: 0] ------------------ 1138| 0| goto insist_and_cleanup; 1139| 0| } 1140| 0| limit_ttl(callbacks, source, line, &lctx->ttl); 1141| 0| lctx->default_ttl = lctx->ttl; 1142| 0| lctx->default_ttl_known = true; 1143| 0| EXPECTEOL; ------------------ | | 292| 0| do { \ | | 293| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | | | ------------------ | | | | | | 214| 0| do { \ | | | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | | | 216| 0| switch (result) { \ | | | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | | | ------------------ | | | | | | | Branch (217:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 218| 0| break; \ | | | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | | | ------------------ | | | | | | | Branch (219:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (221:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 222| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 262| 0| do { \ | | | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | | | 275| 0| rdcount = 0; \ | | | | | | | | 276| 0| rdlcount = 0; \ | | | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | | | 280| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | | | 225| 0| ictx->parent = NULL; \ | | | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | | | ------------------ | | | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 70| 0|#define POST(x) (void)(x) | | | | | | ------------------ | | | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | | | 232| 0| ictx = lctx->inc; \ | | | | | | 233| 0| continue; \ | | | | | | 234| 0| } \ | | | | | | 235| 0| goto insist_and_cleanup; \ | | | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | | | ------------------ | | | | | | | Branch (236:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 237| 0| goto insist_and_cleanup; \ | | | | | | 238| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (238:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 240| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 242| 0| read_till_eol = true; \ | | | | | | 243| 0| err goto next_line; \ | | | | | | 244| 0| } else \ | | | | | | 245| 0| goto log_and_cleanup; \ | | | | | | 246| 0| } \ | | | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | | | ------------------ | | | | | | | Branch (247:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 250| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 251| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 252| 0| read_till_eol = true; \ | | | | | | 253| 0| goto next_line; \ | | | | | | 254| 0| } else \ | | | | | | 255| 0| goto log_and_cleanup; \ | | | | | | 256| 0| } \ | | | | | | 257| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (257:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 294| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (294:7): [True: 0, False: 0] | | ------------------ | | 295| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 296| 0| result = DNS_R_EXTRATOKEN; \ | | 297| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 298| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 299| 0| LOGIT(result); \ | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ | | 300| 0| read_till_eol = true; \ | | 301| 0| break; \ | | 302| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (302:15): [True: 0, False: 0] | | ------------------ | | 303| 0| goto log_and_cleanup; \ | | 304| 0| } \ | | 305| 0| } while (0) | | ------------------ | | | Branch (305:11): [Folded, False: 0] | | ------------------ ------------------ 1144| 0| continue; 1145| 6| } else if (strcasecmp(DNS_AS_STR(token), "$INCLUDE") == ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1145:15): [True: 0, False: 6] ------------------ 1146| 6| 0) 1147| 0| { 1148| 0| COMMITALL; ------------------ | | 262| 0| do { \ | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | 264| 0| source, ictx->current_line); \ | | 265| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 266| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (267:14): [True: 0, False: 0] | | ------------------ | | 268| 0| goto insist_and_cleanup; \ | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | 270| 0| source, ictx->glue_line); \ | | 271| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 272| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (273:14): [True: 0, False: 0] | | ------------------ | | 274| 0| goto insist_and_cleanup; \ | | 275| 0| rdcount = 0; \ | | 276| 0| rdlcount = 0; \ | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | 278| 0| rdcount_save = rdcount; \ | | 279| 0| rdlcount_save = rdlcount; \ | | 280| 0| } while (0) | | ------------------ | | | Branch (280:11): [Folded, False: 0] | | ------------------ ------------------ 1149| 0| if (ttl_offset != 0) { ------------------ | Branch (1149:9): [True: 0, False: 0] ------------------ 1150| 0| (callbacks->error)(callbacks, 1151| 0| "%s: %s:%lu: " 1152| 0| "$INCLUDE " 1153| 0| "may not be used " 1154| 0| "with $DATE", 1155| 0| "dns_master_load", 1156| 0| source, line); 1157| 0| result = DNS_R_SYNTAX; 1158| 0| goto insist_and_cleanup; 1159| 0| } 1160| 0| GETTOKEN(lctx->lex, ISC_LEXOPT_QSTRING, &token, ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1161| 0| false); 1162| 0| if (include_file != NULL) { ------------------ | Branch (1162:9): [True: 0, False: 0] ------------------ 1163| 0| isc_mem_free(mctx, include_file); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1164| 0| } 1165| 0| include_file = 1166| 0| isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1167| 0| GETTOKEN(lctx->lex, 0, &token, true); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1168| | 1169| 0| if (token.type == isc_tokentype_eol || ------------------ | Branch (1169:9): [True: 0, False: 0] ------------------ 1170| 0| token.type == isc_tokentype_eof) ------------------ | Branch (1170:9): [True: 0, False: 0] ------------------ 1171| 0| { 1172| 0| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1172:10): [True: 0, False: 0] ------------------ 1173| 0| WARNUNEXPECTEDEOF(lctx->lex); ------------------ | | 283| 0| do { \ | | 284| 0| if (isc_lex_isfile(lexer)) \ | | ------------------ | | | Branch (284:7): [True: 0, False: 0] | | ------------------ | | 285| 0| (*callbacks->warn)(callbacks, \ | | 286| 0| "%s: file does not end with " \ | | 287| 0| "newline", \ | | 288| 0| source); \ | | 289| 0| } while (0) | | ------------------ | | | Branch (289:11): [Folded, False: 0] | | ------------------ ------------------ 1174| 0| } 1175| | /* 1176| | * No origin field. 1177| | */ 1178| 0| result = pushfile(include_file, 1179| 0| ictx->origin, lctx); 1180| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1181| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1182| 0| LOGITFILE(result, include_file); ------------------ | | 317| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (317:6): [True: 0, False: 0] | | | Branch (317:37): [True: 0, False: 0] | | ------------------ | | 318| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (318:6): [True: 0, False: 0] | | | Branch (318:33): [True: 0, False: 0] | | ------------------ | | 319| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (319:6): [True: 0, False: 0] | | ------------------ | | 320| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 321| 0| "dns_master_load", source, line, filename, \ | | 322| 0| isc_result_totext(result)); \ | | 323| 0| else \ | | 324| 0| LOGIT(result) | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1183| 0| continue; 1184| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1184:17): [True: 0, False: 0] ------------------ 1185| 0| LOGITFILE(result, include_file); ------------------ | | 317| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (317:6): [True: 0, False: 0] | | | Branch (317:37): [True: 0, False: 0] | | ------------------ | | 318| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (318:6): [True: 0, False: 0] | | | Branch (318:33): [True: 0, False: 0] | | ------------------ | | 319| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (319:6): [True: 0, False: 0] | | ------------------ | | 320| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 321| 0| "dns_master_load", source, line, filename, \ | | 322| 0| isc_result_totext(result)); \ | | 323| 0| else \ | | 324| 0| LOGIT(result) | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1186| 0| goto insist_and_cleanup; 1187| 0| } 1188| 0| ictx = lctx->inc; 1189| 0| source = isc_lex_getsourcename( 1190| 0| lctx->lex); 1191| 0| line = isc_lex_getsourceline(lctx->lex); 1192| 0| POST(line); ------------------ | | 70| 0|#define POST(x) (void)(x) ------------------ 1193| 0| continue; 1194| 0| } 1195| | /* 1196| | * There is an origin field. Fall through 1197| | * to domain name processing code and do 1198| | * the actual inclusion later. 1199| | */ 1200| 0| finish_include = true; 1201| 6| } else if (strcasecmp(DNS_AS_STR(token), "$DATE") == 0) ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1201:15): [True: 0, False: 6] ------------------ 1202| 0| { 1203| 0| int64_t dump_time64; 1204| 0| isc_stdtime_t dump_time; 1205| 0| isc_stdtime_t current_time = isc_stdtime_now(); 1206| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1207| 0| result = dns_time64_fromtext(DNS_AS_STR(token), ------------------ | | 176| 0|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ 1208| 0| &dump_time64); 1209| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1210| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1211| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 1212| 0| dump_time64 = 0; 1213| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1213:16): [True: 0, False: 0] ------------------ 1214| 0| goto log_and_cleanup; 1215| 0| } 1216| 0| dump_time = (isc_stdtime_t)dump_time64; 1217| 0| if (dump_time != dump_time64) { ------------------ | Branch (1217:9): [True: 0, False: 0] ------------------ 1218| 0| UNEXPECTED_ERROR("%s: %s:%lu: $DATE " ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1219| 0| "outside epoch", 1220| 0| "dns_master_load", 1221| 0| source, line); 1222| 0| result = ISC_R_UNEXPECTED; 1223| 0| goto insist_and_cleanup; 1224| 0| } 1225| 0| if (dump_time > current_time) { ------------------ | Branch (1225:9): [True: 0, False: 0] ------------------ 1226| 0| UNEXPECTED_ERROR("%s: %s:%lu: " ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1227| 0| "$DATE in future, " 1228| 0| "using current date", 1229| 0| "dns_master_load", 1230| 0| source, line); 1231| 0| dump_time = current_time; 1232| 0| } 1233| 0| ttl_offset = current_time - dump_time; 1234| 0| EXPECTEOL; ------------------ | | 292| 0| do { \ | | 293| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | | | ------------------ | | | | | | 214| 0| do { \ | | | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | | | 216| 0| switch (result) { \ | | | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | | | ------------------ | | | | | | | Branch (217:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 218| 0| break; \ | | | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | | | ------------------ | | | | | | | Branch (219:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (221:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 222| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 262| 0| do { \ | | | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | | | 275| 0| rdcount = 0; \ | | | | | | | | 276| 0| rdlcount = 0; \ | | | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | | | 280| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | | | 225| 0| ictx->parent = NULL; \ | | | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | | | ------------------ | | | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 70| 0|#define POST(x) (void)(x) | | | | | | ------------------ | | | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | | | 232| 0| ictx = lctx->inc; \ | | | | | | 233| 0| continue; \ | | | | | | 234| 0| } \ | | | | | | 235| 0| goto insist_and_cleanup; \ | | | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | | | ------------------ | | | | | | | Branch (236:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 237| 0| goto insist_and_cleanup; \ | | | | | | 238| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (238:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 240| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 242| 0| read_till_eol = true; \ | | | | | | 243| 0| err goto next_line; \ | | | | | | 244| 0| } else \ | | | | | | 245| 0| goto log_and_cleanup; \ | | | | | | 246| 0| } \ | | | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | | | ------------------ | | | | | | | Branch (247:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 250| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 251| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 252| 0| read_till_eol = true; \ | | | | | | 253| 0| goto next_line; \ | | | | | | 254| 0| } else \ | | | | | | 255| 0| goto log_and_cleanup; \ | | | | | | 256| 0| } \ | | | | | | 257| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (257:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 294| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (294:7): [True: 0, False: 0] | | ------------------ | | 295| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 296| 0| result = DNS_R_EXTRATOKEN; \ | | 297| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 298| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 299| 0| LOGIT(result); \ | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ | | 300| 0| read_till_eol = true; \ | | 301| 0| break; \ | | 302| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (302:15): [True: 0, False: 0] | | ------------------ | | 303| 0| goto log_and_cleanup; \ | | 304| 0| } \ | | 305| 0| } while (0) | | ------------------ | | | Branch (305:11): [Folded, False: 0] | | ------------------ ------------------ 1235| 0| continue; 1236| 6| } else if (strcasecmp(DNS_AS_STR(token), "$GENERATE") == ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1236:15): [True: 0, False: 6] ------------------ 1237| 6| 0) 1238| 0| { 1239| | /* 1240| | * Lazy cleanup. 1241| | */ 1242| 0| if (range != NULL) { ------------------ | Branch (1242:9): [True: 0, False: 0] ------------------ 1243| 0| isc_mem_free(mctx, range); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1244| 0| } 1245| 0| if (lhs != NULL) { ------------------ | Branch (1245:9): [True: 0, False: 0] ------------------ 1246| 0| isc_mem_free(mctx, lhs); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1247| 0| } 1248| 0| if (gtype != NULL) { ------------------ | Branch (1248:9): [True: 0, False: 0] ------------------ 1249| 0| isc_mem_free(mctx, gtype); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1250| 0| } 1251| 0| if (rhs != NULL) { ------------------ | Branch (1251:9): [True: 0, False: 0] ------------------ 1252| 0| isc_mem_free(mctx, rhs); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1253| 0| } 1254| 0| range = lhs = gtype = rhs = NULL; 1255| | /* RANGE */ 1256| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1257| 0| range = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1258| | /* LHS */ 1259| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1260| 0| lhs = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1261| 0| rdclass = 0; 1262| 0| explicit_ttl = false; 1263| | /* CLASS? */ 1264| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1265| 0| if (dns_rdataclass_fromtext( ------------------ | Branch (1265:9): [True: 0, False: 0] ------------------ 1266| 0| &rdclass, 1267| 0| &token.value.as_textregion) == 1268| 0| ISC_R_SUCCESS) 1269| 0| { 1270| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1271| 0| } 1272| | /* TTL? */ 1273| 0| if (dns_ttl_fromtext(&token.value.as_textregion, ------------------ | Branch (1273:9): [True: 0, False: 0] ------------------ 1274| 0| &lctx->ttl) == 1275| 0| ISC_R_SUCCESS) 1276| 0| { 1277| 0| limit_ttl(callbacks, source, line, 1278| 0| &lctx->ttl); 1279| 0| lctx->ttl_known = true; 1280| 0| explicit_ttl = true; 1281| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1282| 0| } 1283| | /* CLASS? */ 1284| 0| if (rdclass == 0 && ------------------ | Branch (1284:9): [True: 0, False: 0] ------------------ 1285| 0| dns_rdataclass_fromtext( ------------------ | Branch (1285:9): [True: 0, False: 0] ------------------ 1286| 0| &rdclass, 1287| 0| &token.value.as_textregion) == 1288| 0| ISC_R_SUCCESS) 1289| 0| { 1290| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1291| 0| } 1292| | /* TYPE */ 1293| 0| gtype = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1294| | /* RHS */ 1295| 0| GETTOKEN(lctx->lex, ISC_LEXOPT_QSTRING, &token, ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1296| 0| false); 1297| 0| rhs = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1298| 0| if (!lctx->ttl_known && ------------------ | Branch (1298:9): [True: 0, False: 0] ------------------ 1299| 0| !lctx->default_ttl_known) ------------------ | Branch (1299:9): [True: 0, False: 0] ------------------ 1300| 0| { 1301| 0| (*callbacks->error)(callbacks, 1302| 0| "%s: %s:%lu: no " 1303| 0| "TTL specified", 1304| 0| "dns_master_load", 1305| 0| source, line); 1306| 0| result = DNS_R_NOTTL; 1307| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1308| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1309| 0| lctx->ttl = 0; 1310| 0| } else { 1311| 0| goto insist_and_cleanup; 1312| 0| } 1313| 0| } else if (!explicit_ttl && ------------------ | Branch (1313:16): [True: 0, False: 0] ------------------ 1314| 0| lctx->default_ttl_known) ------------------ | Branch (1314:9): [True: 0, False: 0] ------------------ 1315| 0| { 1316| 0| lctx->ttl = lctx->default_ttl; 1317| 0| } 1318| | /* 1319| | * If the class specified does not match the 1320| | * zone's class print out a error message and 1321| | * exit. 1322| | */ 1323| 0| if (rdclass != 0 && rdclass != lctx->zclass) { ------------------ | Branch (1323:9): [True: 0, False: 0] | Branch (1323:25): [True: 0, False: 0] ------------------ 1324| 0| goto bad_class; 1325| 0| } 1326| 0| result = generate(lctx, range, lhs, gtype, rhs, 1327| 0| source, line); 1328| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1329| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1330| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1330:16): [True: 0, False: 0] ------------------ 1331| 0| goto insist_and_cleanup; 1332| 0| } 1333| 0| EXPECTEOL; ------------------ | | 292| 0| do { \ | | 293| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | | | ------------------ | | | | | | 214| 0| do { \ | | | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | | | 216| 0| switch (result) { \ | | | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | | | ------------------ | | | | | | | Branch (217:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 218| 0| break; \ | | | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | | | ------------------ | | | | | | | Branch (219:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (221:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 222| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 262| 0| do { \ | | | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | | | 275| 0| rdcount = 0; \ | | | | | | | | 276| 0| rdlcount = 0; \ | | | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | | | 280| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | | | 225| 0| ictx->parent = NULL; \ | | | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | | | ------------------ | | | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 70| 0|#define POST(x) (void)(x) | | | | | | ------------------ | | | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | | | 232| 0| ictx = lctx->inc; \ | | | | | | 233| 0| continue; \ | | | | | | 234| 0| } \ | | | | | | 235| 0| goto insist_and_cleanup; \ | | | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | | | ------------------ | | | | | | | Branch (236:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 237| 0| goto insist_and_cleanup; \ | | | | | | 238| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (238:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 240| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 242| 0| read_till_eol = true; \ | | | | | | 243| 0| err goto next_line; \ | | | | | | 244| 0| } else \ | | | | | | 245| 0| goto log_and_cleanup; \ | | | | | | 246| 0| } \ | | | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | | | ------------------ | | | | | | | Branch (247:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 250| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 251| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 252| 0| read_till_eol = true; \ | | | | | | 253| 0| goto next_line; \ | | | | | | 254| 0| } else \ | | | | | | 255| 0| goto log_and_cleanup; \ | | | | | | 256| 0| } \ | | | | | | 257| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (257:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 294| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (294:7): [True: 0, False: 0] | | ------------------ | | 295| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 296| 0| result = DNS_R_EXTRATOKEN; \ | | 297| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 298| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 299| 0| LOGIT(result); \ | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ | | 300| 0| read_till_eol = true; \ | | 301| 0| break; \ | | 302| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (302:15): [True: 0, False: 0] | | ------------------ | | 303| 0| goto log_and_cleanup; \ | | 304| 0| } \ | | 305| 0| } while (0) | | ------------------ | | | Branch (305:11): [Folded, False: 0] | | ------------------ ------------------ 1334| 0| continue; 1335| 6| } else if (strncasecmp(DNS_AS_STR(token), "$", 1) == 0) ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1335:15): [True: 0, False: 6] ------------------ 1336| 0| { 1337| 0| (callbacks->error)(callbacks, 1338| 0| "%s: %s:%lu: " 1339| 0| "unknown $ directive '%s'", 1340| 0| "dns_master_load", source, 1341| 0| line, DNS_AS_STR(token)); ------------------ | | 176| 0|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ 1342| 0| result = DNS_R_SYNTAX; 1343| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1344| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1345| 0| } else { 1346| 0| goto insist_and_cleanup; 1347| 0| } 1348| 0| } 1349| | 1350| | /* 1351| | * Normal processing resumes. 1352| | */ 1353| 6| new_in_use = find_free_name(ictx); 1354| 6| new_name = dns_fixedname_initname( 1355| 6| &ictx->fixed[new_in_use]); 1356| 6| isc_buffer_init(&buffer, token.value.as_region.base, 1357| 6| token.value.as_region.length); 1358| 6| isc_buffer_add(&buffer, token.value.as_region.length); 1359| 6| isc_buffer_setactive(&buffer, 1360| 6| token.value.as_region.length); 1361| 6| result = dns_name_fromtext(new_name, &buffer, 1362| 6| ictx->origin, 0); 1363| 6| if (MANYERRS(lctx, result)) { ------------------ | | 308| 6| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 6] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 6| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1364| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1365| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 1366| 0| read_till_eol = true; 1367| 0| continue; 1368| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1368:15): [True: 0, False: 6] ------------------ 1369| 0| goto log_and_cleanup; 1370| 0| } 1371| | 1372| | /* 1373| | * Finish $ORIGIN / $INCLUDE processing if required. 1374| | */ 1375| 6| if (finish_origin) { ------------------ | Branch (1375:8): [True: 0, False: 6] ------------------ 1376| 0| if (ictx->origin_in_use != -1) { ------------------ | Branch (1376:9): [True: 0, False: 0] ------------------ 1377| 0| ictx->in_use[ictx->origin_in_use] = 1378| 0| false; 1379| 0| } 1380| 0| ictx->origin_in_use = new_in_use; 1381| 0| ictx->in_use[ictx->origin_in_use] = true; 1382| 0| ictx->origin = new_name; 1383| 0| ictx->origin_changed = true; 1384| 0| finish_origin = false; 1385| 0| EXPECTEOL; ------------------ | | 292| 0| do { \ | | 293| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | | | ------------------ | | | | | | 214| 0| do { \ | | | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | | | 216| 0| switch (result) { \ | | | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | | | ------------------ | | | | | | | Branch (217:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 218| 0| break; \ | | | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | | | ------------------ | | | | | | | Branch (219:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (221:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 222| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 262| 0| do { \ | | | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | | | 275| 0| rdcount = 0; \ | | | | | | | | 276| 0| rdlcount = 0; \ | | | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | | | 280| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | | | 225| 0| ictx->parent = NULL; \ | | | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | | | ------------------ | | | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 70| 0|#define POST(x) (void)(x) | | | | | | ------------------ | | | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | | | 232| 0| ictx = lctx->inc; \ | | | | | | 233| 0| continue; \ | | | | | | 234| 0| } \ | | | | | | 235| 0| goto insist_and_cleanup; \ | | | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | | | ------------------ | | | | | | | Branch (236:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 237| 0| goto insist_and_cleanup; \ | | | | | | 238| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (238:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 240| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 242| 0| read_till_eol = true; \ | | | | | | 243| 0| err goto next_line; \ | | | | | | 244| 0| } else \ | | | | | | 245| 0| goto log_and_cleanup; \ | | | | | | 246| 0| } \ | | | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | | | ------------------ | | | | | | | Branch (247:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 250| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 251| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 252| 0| read_till_eol = true; \ | | | | | | 253| 0| goto next_line; \ | | | | | | 254| 0| } else \ | | | | | | 255| 0| goto log_and_cleanup; \ | | | | | | 256| 0| } \ | | | | | | 257| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (257:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 294| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (294:7): [True: 0, False: 0] | | ------------------ | | 295| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 296| 0| result = DNS_R_EXTRATOKEN; \ | | 297| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 298| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 299| 0| LOGIT(result); \ | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ | | 300| 0| read_till_eol = true; \ | | 301| 0| break; \ | | 302| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (302:15): [True: 0, False: 0] | | ------------------ | | 303| 0| goto log_and_cleanup; \ | | 304| 0| } \ | | 305| 0| } while (0) | | ------------------ | | | Branch (305:11): [Folded, False: 0] | | ------------------ ------------------ 1386| 0| continue; 1387| 0| } 1388| 6| if (finish_include) { ------------------ | Branch (1388:8): [True: 0, False: 6] ------------------ 1389| 0| finish_include = false; 1390| 0| EXPECTEOL; ------------------ | | 292| 0| do { \ | | 293| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | | | ------------------ | | | | | | 214| 0| do { \ | | | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | | | 216| 0| switch (result) { \ | | | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | | | ------------------ | | | | | | | Branch (217:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 218| 0| break; \ | | | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | | | ------------------ | | | | | | | Branch (219:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (221:8): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 222| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 262| 0| do { \ | | | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | | | 314| 0| } | | | | | | | | ------------------ | | | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | | | 275| 0| rdcount = 0; \ | | | | | | | | 276| 0| rdlcount = 0; \ | | | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | | | 280| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | | | 225| 0| ictx->parent = NULL; \ | | | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | | | ------------------ | | | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 70| 0|#define POST(x) (void)(x) | | | | | | ------------------ | | | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | | | 232| 0| ictx = lctx->inc; \ | | | | | | 233| 0| continue; \ | | | | | | 234| 0| } \ | | | | | | 235| 0| goto insist_and_cleanup; \ | | | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | | | ------------------ | | | | | | | Branch (236:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 237| 0| goto insist_and_cleanup; \ | | | | | | 238| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (238:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 240| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 242| 0| read_till_eol = true; \ | | | | | | 243| 0| err goto next_line; \ | | | | | | 244| 0| } else \ | | | | | | 245| 0| goto log_and_cleanup; \ | | | | | | 246| 0| } \ | | | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | | | ------------------ | | | | | | | Branch (247:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 250| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 251| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 252| 0| read_till_eol = true; \ | | | | | | 253| 0| goto next_line; \ | | | | | | 254| 0| } else \ | | | | | | 255| 0| goto log_and_cleanup; \ | | | | | | 256| 0| } \ | | | | | | 257| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (257:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 294| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (294:7): [True: 0, False: 0] | | ------------------ | | 295| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 296| 0| result = DNS_R_EXTRATOKEN; \ | | 297| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 298| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 299| 0| LOGIT(result); \ | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ | | 300| 0| read_till_eol = true; \ | | 301| 0| break; \ | | 302| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (302:15): [True: 0, False: 0] | | ------------------ | | 303| 0| goto log_and_cleanup; \ | | 304| 0| } \ | | 305| 0| } while (0) | | ------------------ | | | Branch (305:11): [Folded, False: 0] | | ------------------ ------------------ 1391| 0| result = pushfile(include_file, new_name, lctx); 1392| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1393| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1394| 0| LOGITFILE(result, include_file); ------------------ | | 317| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (317:6): [True: 0, False: 0] | | | Branch (317:37): [True: 0, False: 0] | | ------------------ | | 318| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (318:6): [True: 0, False: 0] | | | Branch (318:33): [True: 0, False: 0] | | ------------------ | | 319| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (319:6): [True: 0, False: 0] | | ------------------ | | 320| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 321| 0| "dns_master_load", source, line, filename, \ | | 322| 0| isc_result_totext(result)); \ | | 323| 0| else \ | | 324| 0| LOGIT(result) | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1395| 0| continue; 1396| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1396:16): [True: 0, False: 0] ------------------ 1397| 0| LOGITFILE(result, include_file); ------------------ | | 317| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (317:6): [True: 0, False: 0] | | | Branch (317:37): [True: 0, False: 0] | | ------------------ | | 318| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (318:6): [True: 0, False: 0] | | | Branch (318:33): [True: 0, False: 0] | | ------------------ | | 319| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (319:6): [True: 0, False: 0] | | ------------------ | | 320| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 321| 0| "dns_master_load", source, line, filename, \ | | 322| 0| isc_result_totext(result)); \ | | 323| 0| else \ | | 324| 0| LOGIT(result) | | ------------------ | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 328| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1398| 0| goto insist_and_cleanup; 1399| 0| } 1400| 0| ictx = lctx->inc; 1401| 0| ictx->origin_changed = true; 1402| 0| source = isc_lex_getsourcename(lctx->lex); 1403| 0| line = isc_lex_getsourceline(lctx->lex); 1404| 0| POST(line); ------------------ | | 70| 0|#define POST(x) (void)(x) ------------------ 1405| 0| continue; 1406| 0| } 1407| | 1408| | /* 1409| | * "$" Processing Finished 1410| | */ 1411| | 1412| | /* 1413| | * If we are processing glue and the new name does 1414| | * not match the current glue name, commit the glue 1415| | * and pop stacks leaving us in 'normal' processing 1416| | * state. Linked lists are undone by commit(). 1417| | */ 1418| 6| if (ictx->glue != NULL && ------------------ | Branch (1418:8): [True: 0, False: 6] ------------------ 1419| 0| !dns_name_caseequal(ictx->glue, new_name)) ------------------ | Branch (1419:8): [True: 0, False: 0] ------------------ 1420| 0| { 1421| 0| result = commit(callbacks, lctx, &glue_list, 1422| 0| ictx->glue, source, 1423| 0| ictx->glue_line); 1424| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1425| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1426| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1426:16): [True: 0, False: 0] ------------------ 1427| 0| goto insist_and_cleanup; 1428| 0| } 1429| 0| if (ictx->glue_in_use != -1) { ------------------ | Branch (1429:9): [True: 0, False: 0] ------------------ 1430| 0| ictx->in_use[ictx->glue_in_use] = false; 1431| 0| } 1432| 0| ictx->glue_in_use = -1; 1433| 0| ictx->glue = NULL; 1434| 0| rdcount = rdcount_save; 1435| 0| rdlcount = rdlcount_save; 1436| 0| target = target_save; 1437| 0| } 1438| | 1439| | /* 1440| | * If we are in 'normal' processing state and the new 1441| | * name does not match the current name, see if the 1442| | * new name is for glue and treat it as such, 1443| | * otherwise we have a new name so commit what we 1444| | * have. 1445| | */ 1446| 6| if ((ictx->glue == NULL) && ------------------ | Branch (1446:8): [True: 6, False: 0] ------------------ 1447| 6| (ictx->current == NULL || ------------------ | Branch (1447:9): [True: 2, False: 4] ------------------ 1448| 4| !dns_name_caseequal(ictx->current, new_name))) ------------------ | Branch (1448:9): [True: 0, False: 4] ------------------ 1449| 2| { 1450| 2| if (current_has_delegation && ------------------ | Branch (1450:9): [True: 0, False: 2] ------------------ 1451| 0| is_glue(¤t_list, new_name)) ------------------ | Branch (1451:9): [True: 0, False: 0] ------------------ 1452| 0| { 1453| 0| rdcount_save = rdcount; 1454| 0| rdlcount_save = rdlcount; 1455| 0| target_save = target; 1456| 0| ictx->glue = new_name; 1457| 0| ictx->glue_in_use = new_in_use; 1458| 0| ictx->in_use[ictx->glue_in_use] = true; 1459| 2| } else { 1460| 2| result = commit(callbacks, lctx, 1461| 2| ¤t_list, 1462| 2| ictx->current, source, 1463| 2| ictx->current_line); 1464| 2| if (MANYERRS(lctx, result)) { ------------------ | | 308| 2| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 2] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 2| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1465| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1466| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1466:17): [True: 0, False: 2] ------------------ 1467| 0| goto insist_and_cleanup; 1468| 0| } 1469| 2| rdcount = 0; 1470| 2| rdlcount = 0; 1471| 2| if (ictx->current_in_use != -1) { ------------------ | Branch (1471:10): [True: 0, False: 2] ------------------ 1472| 0| ictx->in_use 1473| 0| [ictx->current_in_use] = 1474| 0| false; 1475| 0| } 1476| 2| ictx->current_in_use = new_in_use; 1477| 2| ictx->in_use[ictx->current_in_use] = 1478| 2| true; 1479| 2| ictx->current = new_name; 1480| 2| current_has_delegation = false; 1481| 2| isc_buffer_init(&target, target_mem, 1482| 2| target_size); 1483| 2| } 1484| | /* 1485| | * Check for internal wildcards. 1486| | */ 1487| 2| if ((lctx->options & ------------------ | Branch (1487:9): [True: 0, False: 2] ------------------ 1488| 2| DNS_MASTER_CHECKWILDCARD) != 0) ------------------ | | 50| 2| 0x00000400 /* Check for internal wildcards. \ ------------------ 1489| 0| { 1490| 0| check_wildcard(ictx, source, line, 1491| 0| callbacks); 1492| 0| } 1493| 2| } 1494| 6| if (dns_master_isprimary(lctx) && ------------------ | Branch (1494:8): [True: 6, False: 0] ------------------ 1495| 6| !dns_name_issubdomain(new_name, lctx->top)) ------------------ | Branch (1495:8): [True: 0, False: 6] ------------------ 1496| 0| { 1497| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1498| 0| dns_name_format(new_name, namebuf, 1499| 0| sizeof(namebuf)); 1500| | /* 1501| | * Ignore out-of-zone data. 1502| | */ 1503| 0| (*callbacks->warn)(callbacks, 1504| 0| "%s:%lu: " 1505| 0| "ignoring out-of-zone data " 1506| 0| "(%s)", 1507| 0| source, line, namebuf); 1508| 0| ictx->drop = true; 1509| 6| } else { 1510| 6| ictx->drop = false; 1511| 6| } 1512| 6| } else { 1513| 0| UNEXPECTED_ERROR("%s:%lu: isc_lex_gettoken() returned " ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1514| 0| "unexpected token type (%d)", 1515| 0| source, line, token.type); 1516| 0| result = ISC_R_UNEXPECTED; 1517| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1518| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1519| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 1520| 0| continue; 1521| 0| } else { 1522| 0| goto insist_and_cleanup; 1523| 0| } 1524| 0| } 1525| | 1526| | /* 1527| | * Find TTL, class and type. Both TTL and class are optional 1528| | * and may occur in any order if they exist. TTL and class 1529| | * come before type which must exist. 1530| | * 1531| | * [] [] 1532| | * [] [] 1533| | */ 1534| | 1535| 6| type = dns_rdatatype_none; ------------------ | | 114| 6|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1536| 6| rdclass = 0; 1537| | 1538| 6| GETTOKEN(lctx->lex, 0, &token, initialws); ------------------ | | 259| 6| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 6| do { \ | | | | 215| 6| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 6| switch (result) { \ | | | | 217| 6| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 6, False: 0] | | | | ------------------ | | | | 218| 6| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 6] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 6] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 6] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 6| } \ | | | | 247| 6| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 6] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 6| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 1539| | 1540| 6| if (initialws) { ------------------ | Branch (1540:7): [True: 0, False: 6] ------------------ 1541| 0| if (token.type == isc_tokentype_eol) { ------------------ | Branch (1541:8): [True: 0, False: 0] ------------------ 1542| 0| read_till_eol = false; 1543| 0| continue; /* blank line */ 1544| 0| } 1545| | 1546| 0| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1546:8): [True: 0, False: 0] ------------------ 1547| 0| WARNUNEXPECTEDEOF(lctx->lex); ------------------ | | 283| 0| do { \ | | 284| 0| if (isc_lex_isfile(lexer)) \ | | ------------------ | | | Branch (284:7): [True: 0, False: 0] | | ------------------ | | 285| 0| (*callbacks->warn)(callbacks, \ | | 286| 0| "%s: file does not end with " \ | | 287| 0| "newline", \ | | 288| 0| source); \ | | 289| 0| } while (0) | | ------------------ | | | Branch (289:11): [Folded, False: 0] | | ------------------ ------------------ 1548| 0| read_till_eol = false; 1549| 0| isc_lex_ungettoken(lctx->lex, &token); 1550| 0| continue; 1551| 0| } 1552| | 1553| 0| if (ictx->current == NULL) { ------------------ | Branch (1553:8): [True: 0, False: 0] ------------------ 1554| 0| (*callbacks->error)(callbacks, 1555| 0| "%s:%lu: no current owner " 1556| 0| "name", 1557| 0| source, line); 1558| 0| result = DNS_R_NOOWNER; 1559| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1560| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1561| 0| read_till_eol = true; 1562| 0| continue; 1563| 0| } else { 1564| 0| goto insist_and_cleanup; 1565| 0| } 1566| 0| } 1567| | 1568| 0| if (ictx->origin_changed) { ------------------ | Branch (1568:8): [True: 0, False: 0] ------------------ 1569| 0| char cbuf[DNS_NAME_FORMATSIZE]; 1570| 0| char obuf[DNS_NAME_FORMATSIZE]; 1571| 0| dns_name_format(ictx->current, cbuf, 1572| 0| sizeof(cbuf)); 1573| 0| dns_name_format(ictx->origin, obuf, 1574| 0| sizeof(obuf)); 1575| 0| (*callbacks->warn)(callbacks, 1576| 0| "%s:%lu: record with " 1577| 0| "inherited " 1578| 0| "owner (%s) immediately " 1579| 0| "after " 1580| 0| "$ORIGIN (%s)", 1581| 0| source, line, cbuf, obuf); 1582| 0| } 1583| 0| } 1584| | 1585| 6| ictx->origin_changed = false; 1586| | 1587| 6| if (dns_rdataclass_fromtext(&rdclass, ------------------ | Branch (1587:7): [True: 0, False: 6] ------------------ 1588| 6| &token.value.as_textregion) == 1589| 6| ISC_R_SUCCESS) 1590| 0| { 1591| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1592| 0| } 1593| | 1594| 6| explicit_ttl = false; 1595| 6| result = dns_ttl_fromtext(&token.value.as_textregion, 1596| 6| &lctx->ttl); 1597| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1597:7): [True: 6, False: 0] ------------------ 1598| 6| limit_ttl(callbacks, source, line, &lctx->ttl); 1599| 6| explicit_ttl = true; 1600| 6| lctx->ttl_known = true; 1601| 6| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 6| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 6| do { \ | | | | 215| 6| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 6| switch (result) { \ | | | | 217| 6| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 6, False: 0] | | | | ------------------ | | | | 218| 6| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 6] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 6] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 6] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 6| } \ | | | | 247| 6| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 6] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 6| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 1602| 6| } 1603| | 1604| 6| if (token.type != isc_tokentype_string) { ------------------ | Branch (1604:7): [True: 0, False: 6] ------------------ 1605| 0| UNEXPECTED_ERROR("isc_lex_gettoken() returned " ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1606| 0| "unexpected token type"); 1607| 0| result = ISC_R_UNEXPECTED; 1608| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1609| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1610| 0| read_till_eol = true; 1611| 0| continue; 1612| 0| } else { 1613| 0| goto insist_and_cleanup; 1614| 0| } 1615| 0| } 1616| | 1617| 6| if (rdclass == 0 && ------------------ | Branch (1617:7): [True: 6, False: 0] ------------------ 1618| 6| dns_rdataclass_fromtext(&rdclass, ------------------ | Branch (1618:7): [True: 6, False: 0] ------------------ 1619| 6| &token.value.as_textregion) == 1620| 6| ISC_R_SUCCESS) 1621| 6| { 1622| 6| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 6| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 6| do { \ | | | | 215| 6| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 6| switch (result) { \ | | | | 217| 6| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 6, False: 0] | | | | ------------------ | | | | 218| 6| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 6] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 6] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 6] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 6| } \ | | | | 247| 6| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 6] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 6| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 1623| 6| } 1624| | 1625| 6| if (token.type != isc_tokentype_string) { ------------------ | Branch (1625:7): [True: 0, False: 6] ------------------ 1626| 0| UNEXPECTED_ERROR("isc_lex_gettoken() returned " ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1627| 0| "unexpected token type"); 1628| 0| result = ISC_R_UNEXPECTED; 1629| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1630| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1631| 0| read_till_eol = true; 1632| 0| continue; 1633| 0| } else { 1634| 0| goto insist_and_cleanup; 1635| 0| } 1636| 0| } 1637| | 1638| 6| result = dns_rdatatype_fromtext(&type, 1639| 6| &token.value.as_textregion); 1640| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1640:7): [True: 0, False: 6] ------------------ 1641| 0| (*callbacks->warn)( 1642| 0| callbacks, "%s:%lu: unknown RR type '%.*s'", 1643| 0| source, line, token.value.as_textregion.length, 1644| 0| token.value.as_textregion.base); 1645| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1646| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1647| 0| read_till_eol = true; 1648| 0| continue; 1649| 0| } else { 1650| 0| goto insist_and_cleanup; 1651| 0| } 1652| 0| } 1653| | 1654| | /* 1655| | * If the class specified does not match the zone's class 1656| | * print out a error message and exit. 1657| | */ 1658| 6| if (rdclass != 0 && rdclass != lctx->zclass) { ------------------ | Branch (1658:7): [True: 6, False: 0] | Branch (1658:23): [True: 0, False: 6] ------------------ 1659| 0| bad_class: 1660| | 1661| 0| dns_rdataclass_format(rdclass, classname1, 1662| 0| sizeof(classname1)); 1663| 0| dns_rdataclass_format(lctx->zclass, classname2, 1664| 0| sizeof(classname2)); 1665| 0| (*callbacks->error)(callbacks, 1666| 0| "%s:%lu: class '%s' != " 1667| 0| "zone class '%s'", 1668| 0| source, line, classname1, 1669| 0| classname2); 1670| 0| result = DNS_R_BADCLASS; 1671| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1672| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1673| 0| read_till_eol = true; 1674| 0| continue; 1675| 0| } else { 1676| 0| goto insist_and_cleanup; 1677| 0| } 1678| 0| } 1679| | 1680| 6| if (type == dns_rdatatype_ns && ictx->glue == NULL) { ------------------ | | 116| 12|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (1680:7): [True: 2, False: 4] | Branch (1680:35): [True: 2, False: 0] ------------------ 1681| 2| current_has_delegation = true; 1682| 2| } 1683| | 1684| | /* 1685| | * RFC1123: MD and MF are not allowed to be loaded from 1686| | * master files. 1687| | */ 1688| 6| if (dns_master_isprimary(lctx) && ------------------ | Branch (1688:7): [True: 6, False: 0] ------------------ 1689| 6| (type == dns_rdatatype_md || type == dns_rdatatype_mf)) ------------------ | | 117| 12|#define dns_rdatatype_md ((dns_rdatatype_t)dns_rdatatype_md) ------------------ (type == dns_rdatatype_md || type == dns_rdatatype_mf)) ------------------ | | 118| 6|#define dns_rdatatype_mf ((dns_rdatatype_t)dns_rdatatype_mf) ------------------ | Branch (1689:8): [True: 0, False: 6] | Branch (1689:36): [True: 0, False: 6] ------------------ 1690| 0| { 1691| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1692| | 1693| 0| result = DNS_R_OBSOLETE; 1694| | 1695| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1696| 0| (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s", 1697| 0| source, line, "type", typebuf, 1698| 0| isc_result_totext(result)); 1699| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1700| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1701| 0| } else { 1702| 0| goto insist_and_cleanup; 1703| 0| } 1704| 0| } 1705| | 1706| | /* 1707| | * RFC2930: TKEY and TSIG are not allowed to be loaded 1708| | * from master files. 1709| | */ 1710| 6| if (dns_master_isprimary(lctx) && dns_rdatatype_ismeta(type)) { ------------------ | Branch (1710:7): [True: 6, False: 0] | Branch (1710:37): [True: 0, False: 6] ------------------ 1711| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1712| | 1713| 0| result = DNS_R_METATYPE; 1714| | 1715| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1716| 0| (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s", 1717| 0| source, line, "type", typebuf, 1718| 0| isc_result_totext(result)); 1719| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1720| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1721| 0| } else { 1722| 0| goto insist_and_cleanup; 1723| 0| } 1724| 0| } 1725| | 1726| | /* 1727| | * Find a rdata structure. 1728| | */ 1729| 6| if (rdcount == rdata_size) { ------------------ | Branch (1729:7): [True: 2, False: 4] ------------------ 1730| 2| new_rdata = grow_rdata(rdata_size + RDSZ, rdata, ------------------ | | 61| 2|#define RDSZ 512 ------------------ 1731| 2| rdata_size, ¤t_list, 1732| 2| &glue_list, mctx); 1733| 2| rdata_size += RDSZ; ------------------ | | 61| 2|#define RDSZ 512 ------------------ 1734| 2| rdata = new_rdata; 1735| 2| } 1736| | 1737| | /* 1738| | * Peek at the NS record. 1739| | */ 1740| 6| if (type == dns_rdatatype_ns && ------------------ | | 116| 12|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (1740:7): [True: 2, False: 4] ------------------ 1741| 2| lctx->zclass == dns_rdataclass_in && ------------------ | | 24| 8|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (1741:7): [True: 2, False: 0] ------------------ 1742| 2| (lctx->options & DNS_MASTER_CHECKNS) != 0) ------------------ | | 38| 2| 0x00000040 /*%< \ ------------------ | Branch (1742:7): [True: 0, False: 2] ------------------ 1743| 0| { 1744| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 259| 0| GETTOKENERR(lexer, options, token, eol, {}) | | ------------------ | | | | 214| 0| do { \ | | | | 215| 0| result = gettoken(lexer, options, token, eol, callbacks); \ | | | | 216| 0| switch (result) { \ | | | | 217| 0| case ISC_R_SUCCESS: \ | | | | ------------------ | | | | | Branch (217:3): [True: 0, False: 0] | | | | ------------------ | | | | 218| 0| break; \ | | | | 219| 0| case ISC_R_NOTFILE: \ | | | | ------------------ | | | | | Branch (219:3): [True: 0, False: 0] | | | | ------------------ | | | | 220| 0| /* Treat "bad" $INCLUDE as eof. */ \ | | | | 221| 0| if (ictx->parent != NULL && LCTX_MANYERRORS(lctx)) { \ | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (221:8): [True: 0, False: 0] | | | | ------------------ | | | | 222| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 262| 0| do { \ | | | | | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 264| 0| source, ictx->current_line); \ | | | | | | 265| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 266| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (267:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 268| 0| goto insist_and_cleanup; \ | | | | | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 270| 0| source, ictx->glue_line); \ | | | | | | 271| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | | | ------------------ | | | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | | | ------------------ | | | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 272| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | | | 314| 0| } | | | | | | ------------------ | | | | | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (273:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 274| 0| goto insist_and_cleanup; \ | | | | | | 275| 0| rdcount = 0; \ | | | | | | 276| 0| rdlcount = 0; \ | | | | | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 278| 0| rdcount_save = rdcount; \ | | | | | | 279| 0| rdlcount_save = rdlcount; \ | | | | | | 280| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (280:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 224| 0| lctx->inc = ictx->parent; \ | | | | 225| 0| ictx->parent = NULL; \ | | | | 226| 0| incctx_destroy(lctx->mctx, ictx); \ | | | | 227| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == \ | | | | ------------------ | | | | | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (241:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 70| 0|#define POST(x) (void)(x) | | | | ------------------ | | | | 231| 0| source = isc_lex_getsourcename(lctx->lex); \ | | | | 232| 0| ictx = lctx->inc; \ | | | | 233| 0| continue; \ | | | | 234| 0| } \ | | | | 235| 0| goto insist_and_cleanup; \ | | | | 236| 0| case ISC_R_UNEXPECTED: \ | | | | ------------------ | | | | | Branch (236:3): [True: 0, False: 0] | | | | ------------------ | | | | 237| 0| goto insist_and_cleanup; \ | | | | 238| 0| default: \ | | | | ------------------ | | | | | Branch (238:3): [True: 0, False: 0] | | | | ------------------ | | | | 239| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 240| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 242| 0| read_till_eol = true; \ | | | | 243| 0| err goto next_line; \ | | | | 244| 0| } else \ | | | | 245| 0| goto log_and_cleanup; \ | | | | 246| 0| } \ | | | | 247| 0| if ((token)->type == isc_tokentype_special) { \ | | | | ------------------ | | | | | Branch (247:7): [True: 0, False: 0] | | | | ------------------ | | | | 248| 0| result = DNS_R_SYNTAX; \ | | | | 249| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (308:3): [True: 0, False: 0] | | | | | | | Branch (308:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | | | ------------------ | | | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | | | ------------------ | | | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | | | ------------------ | | | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 250| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (312:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 313| 0| (lctx)->result = r; \ | | | | | | 314| 0| } | | | | ------------------ | | | | 251| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 328| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 252| 0| read_till_eol = true; \ | | | | 253| 0| goto next_line; \ | | | | 254| 0| } else \ | | | | 255| 0| goto log_and_cleanup; \ | | | | 256| 0| } \ | | | | 257| 0| } while (0) | | | | ------------------ | | | | | Branch (257:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1745| 0| result = check_ns(lctx, &token, source, line); 1746| 0| isc_lex_ungettoken(lctx->lex, &token); 1747| 0| if ((lctx->options & DNS_MASTER_FATALNS) != 0) { ------------------ | | 43| 0| 0x00000080 /*%< \ ------------------ | Branch (1747:8): [True: 0, False: 0] ------------------ 1748| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1749| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1750| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1750:16): [True: 0, False: 0] ------------------ 1751| 0| goto insist_and_cleanup; 1752| 0| } 1753| 0| } 1754| 0| } 1755| | 1756| | /* 1757| | * Check owner name. 1758| | */ 1759| 6| options &= ~DNS_RDATA_CHECKREVERSE; ------------------ | | 212| 6|#define DNS_RDATA_CHECKREVERSE DNS_NAME_CHECKREVERSE | | ------------------ | | | | 137| 6|#define DNS_NAME_CHECKREVERSE 0x0008 /*%< Used by rdata. */ | | ------------------ ------------------ 1760| 6| if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) { ------------------ | | 47| 6|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ | Branch (1760:7): [True: 0, False: 6] ------------------ 1761| 0| bool ok; 1762| 0| dns_name_t *name; 1763| | 1764| 0| name = (ictx->glue != NULL) ? ictx->glue ------------------ | Branch (1764:11): [True: 0, False: 0] ------------------ 1765| 0| : ictx->current; 1766| 0| ok = dns_rdata_checkowner(name, lctx->zclass, type, 1767| 0| true); 1768| 0| if (!ok) { ------------------ | Branch (1768:8): [True: 0, False: 0] ------------------ 1769| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1770| 0| const char *desc; 1771| 0| dns_name_format(name, namebuf, sizeof(namebuf)); 1772| 0| result = DNS_R_BADOWNERNAME; 1773| 0| desc = isc_result_totext(result); 1774| 0| if (CHECKNAMESFAIL(lctx->options) || ------------------ | | 92| 0|#define CHECKNAMESFAIL(x) (((x) & DNS_MASTER_CHECKNAMESFAIL) != 0) | | ------------------ | | | | 48| 0|#define DNS_MASTER_CHECKNAMESFAIL 0x00000200 | | ------------------ | | | Branch (92:27): [True: 0, False: 0] | | ------------------ ------------------ 1775| 0| type == dns_rdatatype_nsec3) ------------------ | | 164| 0|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1775:9): [True: 0, False: 0] ------------------ 1776| 0| { 1777| 0| (*callbacks->error)( 1778| 0| callbacks, "%s:%lu: %s: %s", 1779| 0| source, line, namebuf, desc); 1780| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1781| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1782| 0| } else { 1783| 0| goto cleanup; 1784| 0| } 1785| 0| } else { 1786| 0| (*callbacks->warn)( 1787| 0| callbacks, "%s:%lu: %s: %s", 1788| 0| source, line, namebuf, desc); 1789| 0| } 1790| 0| } 1791| 0| if (type == dns_rdatatype_ptr && ------------------ | | 126| 0|#define dns_rdatatype_ptr ((dns_rdatatype_t)dns_rdatatype_ptr) ------------------ | Branch (1791:8): [True: 0, False: 0] ------------------ 1792| 0| !dns_name_isdnssd(name) && ------------------ | Branch (1792:8): [True: 0, False: 0] ------------------ 1793| 0| (dns_name_issubdomain(name, &in_addr_arpa) || ------------------ | Branch (1793:9): [True: 0, False: 0] ------------------ 1794| 0| dns_name_issubdomain(name, &ip6_arpa) || ------------------ | Branch (1794:9): [True: 0, False: 0] ------------------ 1795| 0| dns_name_issubdomain(name, &ip6_int))) ------------------ | Branch (1795:9): [True: 0, False: 0] ------------------ 1796| 0| { 1797| 0| options |= DNS_RDATA_CHECKREVERSE; ------------------ | | 212| 0|#define DNS_RDATA_CHECKREVERSE DNS_NAME_CHECKREVERSE | | ------------------ | | | | 137| 0|#define DNS_NAME_CHECKREVERSE 0x0008 /*%< Used by rdata. */ | | ------------------ ------------------ 1798| 0| } 1799| 0| } 1800| | 1801| | /* 1802| | * Read rdata contents. 1803| | */ 1804| 6| dns_rdata_init(&rdata[rdcount]); 1805| 6| target_ft = target; 1806| 6| result = dns_rdata_fromtext(&rdata[rdcount], lctx->zclass, type, 1807| 6| lctx->lex, ictx->origin, options, 1808| 6| lctx->mctx, &target, callbacks); 1809| 6| if (MANYERRS(lctx, result)) { ------------------ | | 308| 6| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 6] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 6| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1810| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1811| 0| continue; 1812| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1812:14): [True: 0, False: 6] ------------------ 1813| 0| goto insist_and_cleanup; 1814| 0| } 1815| | 1816| 6| if (ictx->drop) { ------------------ | Branch (1816:7): [True: 0, False: 6] ------------------ 1817| 0| target = target_ft; 1818| 0| continue; 1819| 0| } 1820| | 1821| 6| if (type == dns_rdatatype_soa && ------------------ | | 120| 12|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (1821:7): [True: 2, False: 4] ------------------ 1822| 2| (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 2|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (1822:7): [True: 2, False: 0] ------------------ 1823| 2| !dns_name_equal(ictx->current, lctx->top)) ------------------ | Branch (1823:7): [True: 0, False: 2] ------------------ 1824| 0| { 1825| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1826| 0| dns_name_format(ictx->current, namebuf, 1827| 0| sizeof(namebuf)); 1828| 0| (*callbacks->error)(callbacks, 1829| 0| "%s:%lu: SOA " 1830| 0| "record not at top of zone (%s)", 1831| 0| source, line, namebuf); 1832| 0| result = DNS_R_NOTZONETOP; 1833| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1834| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1835| 0| read_till_eol = true; 1836| 0| target = target_ft; 1837| 0| continue; 1838| 0| } else { 1839| 0| goto insist_and_cleanup; 1840| 0| } 1841| 0| } 1842| | 1843| 6| if (type == dns_rdatatype_svcb && ------------------ | | 177| 12|#define dns_rdatatype_svcb ((dns_rdatatype_t)dns_rdatatype_svcb) ------------------ | Branch (1843:7): [True: 0, False: 6] ------------------ 1844| 0| (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 0|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (1844:7): [True: 0, False: 0] ------------------ 1845| 0| (lctx->options & DNS_MASTER_CHECKSVCB) != 0) ------------------ | | 59| 0|#define DNS_MASTER_CHECKSVCB 0x00020000 /*%< Check SVBC records */ ------------------ | Branch (1845:7): [True: 0, False: 0] ------------------ 1846| 0| { 1847| 0| result = dns_rdata_checksvcb(ictx->current, 1848| 0| &rdata[rdcount]); 1849| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1849:8): [True: 0, False: 0] ------------------ 1850| 0| (*callbacks->error)(callbacks, 1851| 0| "%s:%lu: SVCB " 1852| 0| "record not valid: %s", 1853| 0| source, line, 1854| 0| isc_result_totext(result)); 1855| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1856| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1857| 0| target = target_ft; 1858| 0| continue; 1859| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1859:16): [True: 0, False: 0] ------------------ 1860| 0| goto insist_and_cleanup; 1861| 0| } 1862| 0| } 1863| 0| } 1864| | 1865| 6| if (dns_rdatatype_atparent(type) && ------------------ | Branch (1865:7): [True: 0, False: 6] ------------------ 1866| 0| dns_master_isprimary(lctx) && ------------------ | Branch (1866:7): [True: 0, False: 0] ------------------ 1867| 0| dns_name_equal(ictx->current, lctx->top)) ------------------ | Branch (1867:7): [True: 0, False: 0] ------------------ 1868| 0| { 1869| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1870| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1871| | 1872| 0| dns_name_format(ictx->current, namebuf, 1873| 0| sizeof(namebuf)); 1874| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1875| 0| (*callbacks->error)( 1876| 0| callbacks, 1877| 0| "%s:%lu: %s record at top of zone (%s)", source, 1878| 0| line, typebuf, namebuf); 1879| 0| result = DNS_R_ATZONETOP; 1880| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1881| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1882| 0| target = target_ft; 1883| 0| continue; 1884| 0| } else { 1885| 0| goto insist_and_cleanup; 1886| 0| } 1887| 0| } 1888| | 1889| 6| if (dns_rdatatype_issig(type)) { ------------------ | Branch (1889:7): [True: 0, False: 6] ------------------ 1890| 0| covers = dns_rdata_covers(&rdata[rdcount]); 1891| 6| } else { 1892| 6| covers = dns_rdatatype_none; ------------------ | | 114| 6|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1893| 6| } 1894| | 1895| 6| if (!lctx->ttl_known && !lctx->default_ttl_known) { ------------------ | Branch (1895:7): [True: 0, False: 6] | Branch (1895:27): [True: 0, False: 0] ------------------ 1896| 0| if (type == dns_rdatatype_soa) { ------------------ | | 120| 0|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (1896:8): [True: 0, False: 0] ------------------ 1897| 0| (*callbacks->warn)(callbacks, 1898| 0| "%s:%lu: no TTL specified; " 1899| 0| "using SOA MINTTL instead", 1900| 0| source, line); 1901| 0| lctx->ttl = dns_soa_getminimum(&rdata[rdcount]); 1902| 0| limit_ttl(callbacks, source, line, &lctx->ttl); 1903| 0| lctx->default_ttl = lctx->ttl; 1904| 0| lctx->default_ttl_known = true; 1905| 0| } else if ((lctx->options & DNS_MASTER_HINT) != 0) { ------------------ | | 35| 0|#define DNS_MASTER_HINT 0x00000010 /*%< Loading a hint master file. */ ------------------ | Branch (1905:15): [True: 0, False: 0] ------------------ 1906| | /* 1907| | * Zero TTL's are fine for hints. 1908| | */ 1909| 0| lctx->ttl = 0; 1910| 0| lctx->default_ttl = lctx->ttl; 1911| 0| lctx->default_ttl_known = true; 1912| 0| } else { 1913| 0| (*callbacks->warn)(callbacks, 1914| 0| "%s:%lu: no TTL specified; " 1915| 0| "zone rejected", 1916| 0| source, line); 1917| 0| result = DNS_R_NOTTL; 1918| 0| if (MANYERRS(lctx, result)) { ------------------ | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 0] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 0| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1919| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 1920| 0| lctx->ttl = 0; 1921| 0| } else { 1922| 0| goto insist_and_cleanup; 1923| 0| } 1924| 0| } 1925| 6| } else if (!explicit_ttl && lctx->default_ttl_known) { ------------------ | Branch (1925:14): [True: 0, False: 6] | Branch (1925:31): [True: 0, False: 0] ------------------ 1926| 0| lctx->ttl = lctx->default_ttl; 1927| 6| } else if (!explicit_ttl && lctx->warn_1035) { ------------------ | Branch (1927:14): [True: 0, False: 6] | Branch (1927:31): [True: 0, False: 0] ------------------ 1928| 0| (*callbacks->warn)(callbacks, 1929| 0| "%s:%lu: " 1930| 0| "using RFC1035 TTL semantics", 1931| 0| source, line); 1932| 0| lctx->warn_1035 = false; 1933| 0| } 1934| | 1935| 6| if (type == dns_rdatatype_rrsig && lctx->warn_sigexpired) { ------------------ | | 160| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1935:7): [True: 0, False: 6] | Branch (1935:38): [True: 0, False: 0] ------------------ 1936| 0| dns_rdata_rrsig_t sig; 1937| 0| result = dns_rdata_tostruct(&rdata[rdcount], &sig, 1938| 0| NULL); 1939| 0| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ ------------------ 1940| 0| if (isc_serial_lt(sig.timeexpire, lctx->now)) { ------------------ | Branch (1940:8): [True: 0, False: 0] ------------------ 1941| 0| (*callbacks->warn)(callbacks, 1942| 0| "%s:%lu: " 1943| 0| "signature has expired", 1944| 0| source, line); 1945| 0| lctx->warn_sigexpired = false; 1946| 0| } 1947| 0| } 1948| | 1949| 6| if ((lctx->options & DNS_MASTER_AGETTL) != 0) { ------------------ | | 30| 6|#define DNS_MASTER_AGETTL 0x00000001 /*%< Age the ttl based on $DATE. */ ------------------ | Branch (1949:7): [True: 0, False: 6] ------------------ 1950| | /* 1951| | * Adjust the TTL for $DATE. If the RR has 1952| | * already expired, set its TTL to 0. This 1953| | * should be okay even if the TTL stretching 1954| | * feature is not in effect, because it will 1955| | * just be quickly expired by the cache, and the 1956| | * way this was written before the patch it 1957| | * could potentially add 0 TTLs anyway. 1958| | */ 1959| 0| if (lctx->ttl < ttl_offset) { ------------------ | Branch (1959:8): [True: 0, False: 0] ------------------ 1960| 0| lctx->ttl = 0; 1961| 0| } else { 1962| 0| lctx->ttl -= ttl_offset; 1963| 0| } 1964| 0| } 1965| | 1966| | /* 1967| | * Find type in rdatalist. 1968| | * If it does not exist create new one and prepend to list 1969| | * as this will minimise list traversal. 1970| | */ 1971| 6| if (ictx->glue != NULL) { ------------------ | Branch (1971:7): [True: 0, False: 6] ------------------ 1972| 0| this = ISC_LIST_HEAD(glue_list); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1973| 6| } else { 1974| 6| this = ISC_LIST_HEAD(current_list); ------------------ | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1975| 6| } 1976| | 1977| 12| while (this != NULL) { ------------------ | Branch (1977:10): [True: 6, False: 6] ------------------ 1978| 6| if (this->type == type && this->covers == covers) { ------------------ | Branch (1978:8): [True: 0, False: 6] | Branch (1978:30): [True: 0, False: 0] ------------------ 1979| 0| break; 1980| 0| } 1981| 6| this = ISC_LIST_NEXT(this, link); ------------------ | | 140| 6|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 1982| 6| } 1983| | 1984| 6| if (this == NULL) { ------------------ | Branch (1984:7): [True: 6, False: 0] ------------------ 1985| 6| if (rdlcount == rdatalist_size) { ------------------ | Branch (1985:8): [True: 2, False: 4] ------------------ 1986| 2| new_rdatalist = grow_rdatalist( 1987| 2| rdatalist_size + RDLSZ, rdatalist, ------------------ | | 56| 2|#define RDLSZ 32 ------------------ 1988| 2| rdatalist_size, ¤t_list, 1989| 2| &glue_list, mctx); 1990| 2| rdatalist = new_rdatalist; 1991| 2| rdatalist_size += RDLSZ; ------------------ | | 56| 2|#define RDLSZ 32 ------------------ 1992| 2| } 1993| 6| this = &rdatalist[rdlcount++]; 1994| 6| dns_rdatalist_init(this); 1995| 6| this->type = type; 1996| 6| this->covers = covers; 1997| 6| this->rdclass = lctx->zclass; 1998| 6| this->ttl = lctx->ttl; 1999| 6| if (ictx->glue != NULL) { ------------------ | Branch (1999:8): [True: 0, False: 6] ------------------ 2000| 0| ISC_LIST_INITANDPREPEND(glue_list, this, link); ------------------ | | 85| 0| __ISC_LIST_PREPENDUNSAFE(list, elt, link) | | ------------------ | | | | 67| 0| do { \ | | | | 68| 0| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| (list).head->link.prev = (elt); \ | | | | 70| 0| } else { \ | | | | 71| 0| (list).tail = (elt); \ | | | | 72| 0| } \ | | | | 73| 0| (elt)->link.prev = NULL; \ | | | | 74| 0| (elt)->link.next = (list).head; \ | | | | 75| 0| (list).head = (elt); \ | | | | 76| 0| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2001| 6| } else { 2002| 6| ISC_LIST_INITANDPREPEND(current_list, this, ------------------ | | 85| 6| __ISC_LIST_PREPENDUNSAFE(list, elt, link) | | ------------------ | | | | 67| 6| do { \ | | | | 68| 6| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 4, False: 2] | | | | ------------------ | | | | 69| 4| (list).head->link.prev = (elt); \ | | | | 70| 4| } else { \ | | | | 71| 2| (list).tail = (elt); \ | | | | 72| 2| } \ | | | | 73| 6| (elt)->link.prev = NULL; \ | | | | 74| 6| (elt)->link.next = (list).head; \ | | | | 75| 6| (list).head = (elt); \ | | | | 76| 6| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 2003| 6| link); 2004| 6| } 2005| 6| } else if (this->ttl != lctx->ttl) { ------------------ | Branch (2005:14): [True: 0, False: 0] ------------------ 2006| 0| (*callbacks->warn)(callbacks, 2007| 0| "%s:%lu: " 2008| 0| "TTL set to prior TTL (%lu)", 2009| 0| source, line, this->ttl); 2010| 0| lctx->ttl = this->ttl; 2011| 0| } 2012| | 2013| 6| if ((lctx->options & DNS_MASTER_CHECKTTL) != 0 && ------------------ | | 58| 6|#define DNS_MASTER_CHECKTTL 0x00010000 /*%< Check max-zone-ttl */ ------------------ | Branch (2013:7): [True: 0, False: 6] ------------------ 2014| 0| lctx->ttl > lctx->maxttl) ------------------ | Branch (2014:7): [True: 0, False: 0] ------------------ 2015| 0| { 2016| 0| (callbacks->error)(callbacks, 2017| 0| "dns_master_load: %s:%lu: " 2018| 0| "TTL %d exceeds configured " 2019| 0| "max-zone-ttl %d", 2020| 0| source, line, lctx->ttl, 2021| 0| lctx->maxttl); 2022| 0| result = ISC_R_RANGE; 2023| 0| goto log_and_cleanup; 2024| 0| } 2025| | 2026| 6| ISC_LIST_APPEND(this->rdata, &rdata[rdcount], link); ------------------ | | 100| 6| do { \ | | 101| 6| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 6| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 6| do { \ | | | | 89| 6| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 6] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 6| } else { \ | | | | 92| 6| (list).head = (elt); \ | | | | 93| 6| } \ | | | | 94| 6| (elt)->link.prev = (list).tail; \ | | | | 95| 6| (elt)->link.next = NULL; \ | | | | 96| 6| (list).tail = (elt); \ | | | | 97| 6| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 6] | | | | ------------------ | | ------------------ | | 103| 6| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 6] | | ------------------ ------------------ 2027| 6| if (ictx->glue != NULL) { ------------------ | Branch (2027:7): [True: 0, False: 6] ------------------ 2028| 0| ictx->glue_line = line; 2029| 6| } else { 2030| 6| ictx->current_line = line; 2031| 6| } 2032| 6| rdcount++; 2033| | 2034| | /* 2035| | * We must have at least 64k as rdlen is 16 bits. 2036| | * If we don't commit everything we have so far. 2037| | */ 2038| 6| if ((target.length - target.used) < MINTSIZ) { ------------------ | | 76| 6|#define MINTSIZ DNS_RDATA_MAXLENGTH | | ------------------ | | | | 181| 6|#define DNS_RDATA_MAXLENGTH 65512U | | ------------------ ------------------ | Branch (2038:7): [True: 0, False: 6] ------------------ 2039| 0| COMMITALL; ------------------ | | 262| 0| do { \ | | 263| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | 264| 0| source, ictx->current_line); \ | | 265| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 266| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 267| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (267:14): [True: 0, False: 0] | | ------------------ | | 268| 0| goto insist_and_cleanup; \ | | 269| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | 270| 0| source, ictx->glue_line); \ | | 271| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 308| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (308:3): [True: 0, False: 0] | | | | | Branch (308:32): [True: 0, False: 0] | | | | ------------------ | | | | 309| 0| LCTX_MANYERRORS(lctx)) | | | | ------------------ | | | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | | | ------------------ | | | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | | | ------------------ | | | | | | | Branch (211:31): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 272| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (312:6): [True: 0, False: 0] | | | | ------------------ | | | | 313| 0| (lctx)->result = r; \ | | | | 314| 0| } | | ------------------ | | 273| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (273:14): [True: 0, False: 0] | | ------------------ | | 274| 0| goto insist_and_cleanup; \ | | 275| 0| rdcount = 0; \ | | 276| 0| rdlcount = 0; \ | | 277| 0| isc_buffer_init(&target, target_mem, target_size); \ | | 278| 0| rdcount_save = rdcount; \ | | 279| 0| rdlcount_save = rdlcount; \ | | 280| 0| } while (0) | | ------------------ | | | Branch (280:11): [Folded, False: 0] | | ------------------ ------------------ 2040| 0| } 2041| 6| next_line:; 2042| 6| } 2043| | 2044| | /* 2045| | * Commit what has not yet been committed. 2046| | */ 2047| 2| result = commit(callbacks, lctx, ¤t_list, ictx->current, source, 2048| 2| ictx->current_line); 2049| 2| if (MANYERRS(lctx, result)) { ------------------ | | 308| 2| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 2] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 2| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2050| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 2051| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2051:13): [True: 0, False: 2] ------------------ 2052| 0| goto insist_and_cleanup; 2053| 0| } 2054| 2| result = commit(callbacks, lctx, &glue_list, ictx->glue, source, 2055| 2| ictx->glue_line); 2056| 2| if (MANYERRS(lctx, result)) { ------------------ | | 308| 2| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 2] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 2| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2057| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 2058| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2058:13): [True: 0, False: 2] ------------------ 2059| 0| goto insist_and_cleanup; 2060| 2| } else if (lctx->result != ISC_R_SUCCESS) { ------------------ | Branch (2060:13): [True: 0, False: 2] ------------------ 2061| 0| result = lctx->result; 2062| 2| } else if (lctx->seen_include) { ------------------ | Branch (2062:13): [True: 0, False: 2] ------------------ 2063| 0| result = DNS_R_SEENINCLUDE; 2064| 0| } 2065| | 2066| 2| goto cleanup; 2067| | 2068| 2|log_and_cleanup: 2069| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 2070| | 2071| 0|insist_and_cleanup: 2072| 0| INSIST(result != ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2073| | 2074| 2|cleanup: 2075| | /* commit the database transaction */ 2076| 2| if (callbacks->commit != NULL) { ------------------ | Branch (2076:6): [True: 2, False: 0] ------------------ 2077| 2| callbacks->commit(callbacks->add_private); 2078| 2| } 2079| | 2080| 2| ISC_LIST_FOREACH(current_list, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2081| 0| ISC_LIST_UNLINK(current_list, this, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2082| 0| } 2083| 2| ISC_LIST_FOREACH(glue_list, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2084| 0| ISC_LIST_UNLINK(glue_list, this, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2085| 0| } 2086| 2| if (rdatalist != NULL) { ------------------ | Branch (2086:6): [True: 2, False: 0] ------------------ 2087| 2| isc_mem_cput(mctx, rdatalist, rdatalist_size, ------------------ | | 155| 2| do { \ | | 156| 2| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 2| ({ \ | | | | 33| 2| typeof(a) _c; \ | | | | 34| 2| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 2| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 157| 2| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 2|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 2| (p) = NULL; \ | | 159| 2| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 2] | | ------------------ ------------------ 2088| 2| sizeof(*rdatalist)); 2089| 2| } 2090| 2| if (rdata != NULL) { ------------------ | Branch (2090:6): [True: 2, False: 0] ------------------ 2091| 2| isc_mem_cput(mctx, rdata, rdata_size, sizeof(*rdata)); ------------------ | | 155| 2| do { \ | | 156| 2| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 2| ({ \ | | | | 33| 2| typeof(a) _c; \ | | | | 34| 2| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 2| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 157| 2| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 2|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 2| (p) = NULL; \ | | 159| 2| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 2] | | ------------------ ------------------ 2092| 2| } 2093| 2| if (target_mem != NULL) { ------------------ | Branch (2093:6): [True: 2, False: 0] ------------------ 2094| 2| isc_mem_put(mctx, target_mem, target_size); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 2095| 2| } 2096| 2| if (include_file != NULL) { ------------------ | Branch (2096:6): [True: 0, False: 2] ------------------ 2097| 0| isc_mem_free(mctx, include_file); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 2098| 0| } 2099| 2| if (range != NULL) { ------------------ | Branch (2099:6): [True: 0, False: 2] ------------------ 2100| 0| isc_mem_free(mctx, range); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 2101| 0| } 2102| 2| if (lhs != NULL) { ------------------ | Branch (2102:6): [True: 0, False: 2] ------------------ 2103| 0| isc_mem_free(mctx, lhs); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 2104| 0| } 2105| 2| if (gtype != NULL) { ------------------ | Branch (2105:6): [True: 0, False: 2] ------------------ 2106| 0| isc_mem_free(mctx, gtype); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 2107| 0| } 2108| 2| if (rhs != NULL) { ------------------ | Branch (2108:6): [True: 0, False: 2] ------------------ 2109| 0| isc_mem_free(mctx, rhs); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 2110| 0| } 2111| | 2112| 2| return result; 2113| 0|} master.c:gettoken: 348| 26| dns_rdatacallbacks_t *callbacks) { 349| 26| isc_result_t result; 350| | 351| 26| options |= ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ISC_LEXOPT_DNSMULTILINE | ------------------ | | 62| 26|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ options |= ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ISC_LEXOPT_DNSMULTILINE | ------------------ | | 63| 26|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ options |= ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ISC_LEXOPT_DNSMULTILINE | ------------------ | | 77| 26|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ 352| 26| ISC_LEXOPT_ESCAPE; ------------------ | | 81| 26|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 353| 26| result = isc_lex_gettoken(lex, options, token); 354| 26| if (result != ISC_R_SUCCESS) { ------------------ | Branch (354:6): [True: 0, False: 26] ------------------ 355| 0| switch (result) { 356| 0| default: ------------------ | Branch (356:3): [True: 0, False: 0] ------------------ 357| 0| (*callbacks->error)(callbacks, 358| 0| "dns_master_load: %s:%lu:" 359| 0| " isc_lex_gettoken() failed: %s", 360| 0| isc_lex_getsourcename(lex), 361| 0| isc_lex_getsourceline(lex), 362| 0| isc_result_totext(result)); 363| 0| return result; 364| 0| } 365| | /*NOTREACHED*/ 366| 0| } 367| 26| if (eol != true) { ------------------ | Branch (367:6): [True: 18, False: 8] ------------------ 368| 18| if (token->type == isc_tokentype_eol || ------------------ | Branch (368:7): [True: 0, False: 18] ------------------ 369| 18| token->type == isc_tokentype_eof) ------------------ | Branch (369:7): [True: 0, False: 18] ------------------ 370| 0| { 371| 0| { 372| 0| unsigned long int line; 373| 0| const char *what; 374| 0| const char *file; 375| 0| file = isc_lex_getsourcename(lex); 376| 0| line = isc_lex_getsourceline(lex); 377| 0| if (token->type == isc_tokentype_eol) { ------------------ | Branch (377:9): [True: 0, False: 0] ------------------ 378| 0| line--; 379| 0| what = "line"; 380| 0| } else { 381| 0| what = "file"; 382| 0| } 383| 0| (*callbacks->error)(callbacks, 384| 0| "dns_master_load: %s:%lu: " 385| 0| "unexpected end of %s", 386| 0| file, line, what); 387| 0| return ISC_R_UNEXPECTEDEND; 388| 0| } 389| 0| } 390| 18| } 391| 26| return ISC_R_SUCCESS; 392| 26|} master.c:commit: 2823| 6| unsigned int line) { 2824| 6| dns_rdataset_t dataset; 2825| 6| isc_result_t result = ISC_R_SUCCESS; 2826| 6| char namebuf[DNS_NAME_FORMATSIZE]; 2827| 6| void (*error)(struct dns_rdatacallbacks *, const char *, ...); 2828| | 2829| 6| error = callbacks->error; 2830| | 2831| 6| ISC_LIST_FOREACH(*head, this, link) { ------------------ | | 234| 6| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 6| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 2|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 2, False: 4] | | ------------------ | | 236| 12| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 6, False: 6] | | ------------------ | | 237| 6| elt = elt##_next, \ | | 238| 6| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 4|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 4, False: 2] | | ------------------ ------------------ 2832| 6| dns_rdataset_init(&dataset); 2833| 6| dns_rdatalist_tordataset(this, &dataset); 2834| 6| dataset.trust = dns_trust_ultimate; ------------------ | | 380| 6|#define dns_trust_ultimate ((dns_trust_t)dns_trust_ultimate) ------------------ 2835| | /* 2836| | * If this is a secure dynamic zone set the re-signing time. 2837| | */ 2838| 6| if (dataset.type == dns_rdatatype_rrsig && ------------------ | | 160| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (2838:7): [True: 0, False: 6] ------------------ 2839| 0| (lctx->options & DNS_MASTER_RESIGN) != 0) ------------------ | | 55| 0|#define DNS_MASTER_RESIGN 0x00002000 ------------------ | Branch (2839:7): [True: 0, False: 0] ------------------ 2840| 0| { 2841| 0| dataset.attributes.resign = true; 2842| 0| dataset.resign = resign_fromlist(this, lctx); 2843| 0| } 2844| 6| result = callbacks->update(callbacks->add_private, owner, 2845| 6| &dataset, 2846| 6| DNS_DIFFOP_ADD DNS__DB_FILELINE); 2847| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2847:7): [True: 0, False: 6] ------------------ 2848| 0| dns_name_format(owner, namebuf, sizeof(namebuf)); 2849| 0| if (source != NULL) { ------------------ | Branch (2849:8): [True: 0, False: 0] ------------------ 2850| 0| (*error)(callbacks, "%s: %s:%lu: %s: %s", 2851| 0| "dns_master_load", source, line, 2852| 0| namebuf, isc_result_totext(result)); 2853| 0| } else { 2854| 0| (*error)(callbacks, "%s: %s: %s", 2855| 0| "dns_master_load", namebuf, 2856| 0| isc_result_totext(result)); 2857| 0| } 2858| 0| } 2859| 6| if (MANYERRS(lctx, result)) { ------------------ | | 308| 6| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (308:3): [True: 0, False: 6] | | | Branch (308:32): [True: 0, False: 0] | | ------------------ | | 309| 6| LCTX_MANYERRORS(lctx)) | | ------------------ | | | | 211| 0|#define LCTX_MANYERRORS(lctx) (((lctx)->options & DNS_MASTER_MANYERRORS) != 0) | | | | ------------------ | | | | | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ | | | | ------------------ | | | | | Branch (211:31): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2860| 0| SETRESULT(lctx, result); ------------------ | | 312| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (312:6): [True: 0, False: 0] | | ------------------ | | 313| 0| (lctx)->result = r; \ | | 314| 0| } ------------------ 2861| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2861:14): [True: 0, False: 6] ------------------ 2862| 0| break; 2863| 0| } 2864| 6| ISC_LIST_UNLINK(*head, this, link); ------------------ | | 137| 6| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 6| do { \ | | | | 133| 6| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 6| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 6| do { \ | | | | | | 110| 6| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 4, False: 2] | | | | | | ------------------ | | | | | | 111| 4| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 4| } else { \ | | | | | | 113| 2| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 2| (list).tail = (elt)->link.prev; \ | | | | | | 115| 2| } \ | | | | | | 116| 6| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 6| } else { \ | | | | | | 119| 6| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 6| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 6| (list).head = (elt)->link.next; \ | | | | | | 121| 6| } \ | | | | | | 122| 6| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 6| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 6| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 6| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 6| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 6| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 6| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 6] | | | | | | ------------------ | | | | ------------------ | | | | 135| 6| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 2865| 6| } 2866| | 2867| 6| return result; 2868| 6|} master.c:limit_ttl: 896| 6| unsigned int line, uint32_t *ttlp) { 897| 6| if (*ttlp > 0x7fffffffUL) { ------------------ | Branch (897:6): [True: 0, False: 6] ------------------ 898| 0| (callbacks->warn)(callbacks, 899| 0| "%s: %s:%lu: " 900| 0| "$TTL %lu > MAXTTL, " 901| 0| "setting $TTL to 0", 902| 0| "dns_master_load", source, line, *ttlp); 903| 0| *ttlp = 0; 904| 0| } 905| 6|} master.c:find_free_name: 972| 6|find_free_name(dns_incctx_t *incctx) { 973| 6| int i; 974| | 975| 16| for (i = 0; i < (NBUFS - 1); i++) { ------------------ | | 63| 16|#define NBUFS 4 ------------------ | Branch (975:14): [True: 16, False: 0] ------------------ 976| 16| if (!incctx->in_use[i]) { ------------------ | Branch (976:7): [True: 6, False: 10] ------------------ 977| 6| break; 978| 6| } 979| 16| } 980| 6| INSIST(!incctx->in_use[i]); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 981| 6| return i; 982| 6|} master.c:dns_master_isprimary: 340| 18|dns_master_isprimary(dns_loadctx_t *lctx) { 341| 18| return (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 18|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (341:9): [True: 18, False: 0] ------------------ 342| 18| (lctx->options & DNS_MASTER_SECONDARY) == 0 && ------------------ | | 36| 18|#define DNS_MASTER_SECONDARY 0x00000020 /*%< Secondary master file. */ ------------------ | Branch (342:9): [True: 18, False: 0] ------------------ 343| 18| (lctx->options & DNS_MASTER_KEY) == 0; ------------------ | | 56| 18|#define DNS_MASTER_KEY 0x00004000 /*%< Loading a key zone master file. */ ------------------ | Branch (343:9): [True: 18, False: 0] ------------------ 344| 18|} master.c:grow_rdata: 2738| 2| rdatalist_head_t *current, rdatalist_head_t *glue, isc_mem_t *mctx) { 2739| 2| dns_rdata_t *newlist; 2740| 2| int rdcount = 0; 2741| 2| ISC_LIST(dns_rdata_t) save; ------------------ | | 39| 2| struct { \ | | 40| 2| type *head, *tail; \ | | 41| 2| } ------------------ 2742| | 2743| 2| newlist = isc_mem_cget(mctx, new_len, sizeof(*newlist)); ------------------ | | 130| 2| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 2| ({ \ | | | | 33| 2| typeof(a) _c; \ | | | | 34| 2| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 2| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 131| 2| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 2|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 2744| | 2745| | /* 2746| | * Copy current relinking. 2747| | */ 2748| 2| ISC_LIST_FOREACH(*current, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2749| 0| ISC_LIST_INIT(save); ------------------ | | 43| 0| do { \ | | 44| 0| (list).head = NULL; \ | | 45| 0| (list).tail = NULL; \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 0] | | ------------------ ------------------ 2750| 0| ISC_LIST_FOREACH(this->rdata, rdata, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2751| 0| ISC_LIST_UNLINK(this->rdata, rdata, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2752| 0| ISC_LIST_APPEND(save, rdata, link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2753| 0| } 2754| 0| ISC_LIST_FOREACH(save, rdata, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2755| 0| ISC_LIST_UNLINK(save, rdata, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2756| 0| INSIST(rdcount < new_len); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2757| 0| newlist[rdcount] = *rdata; 2758| 0| ISC_LIST_APPEND(this->rdata, &newlist[rdcount], link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2759| 0| rdcount++; 2760| 0| } 2761| 0| } 2762| | 2763| | /* 2764| | * Copy glue relinking. 2765| | */ 2766| 2| ISC_LIST_FOREACH(*glue, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2767| 0| ISC_LIST_INIT(save); ------------------ | | 43| 0| do { \ | | 44| 0| (list).head = NULL; \ | | 45| 0| (list).tail = NULL; \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 0] | | ------------------ ------------------ 2768| 0| ISC_LIST_FOREACH(this->rdata, rdata, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2769| 0| ISC_LIST_UNLINK(this->rdata, rdata, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2770| 0| ISC_LIST_APPEND(save, rdata, link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2771| 0| } 2772| 0| ISC_LIST_FOREACH(save, rdata, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2773| 0| ISC_LIST_UNLINK(save, rdata, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2774| 0| INSIST(rdcount < new_len); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2775| 0| newlist[rdcount] = *rdata; 2776| 0| ISC_LIST_APPEND(this->rdata, &newlist[rdcount], link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2777| 0| rdcount++; 2778| 0| } 2779| 0| } 2780| 2| INSIST(rdcount == old_len || rdcount == 0); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 2, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2781| 2| if (oldlist != NULL) { ------------------ | Branch (2781:6): [True: 0, False: 2] ------------------ 2782| | isc_mem_cput(mctx, oldlist, old_len, sizeof(*oldlist)); ------------------ | | 155| 0| do { \ | | 156| 0| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 157| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 0| (p) = NULL; \ | | 159| 0| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 0] | | ------------------ ------------------ 2783| 0| } 2784| 2| return newlist; 2785| 2|} master.c:grow_rdatalist: 2692| 2| isc_mem_t *mctx) { 2693| 2| dns_rdatalist_t *newlist; 2694| 2| int rdlcount = 0; 2695| 2| ISC_LIST(dns_rdatalist_t) save; ------------------ | | 39| 2| struct { \ | | 40| 2| type *head, *tail; \ | | 41| 2| } ------------------ 2696| | 2697| 2| newlist = isc_mem_cget(mctx, new_len, sizeof(newlist[0])); ------------------ | | 130| 2| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 2| ({ \ | | | | 33| 2| typeof(a) _c; \ | | | | 34| 2| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 2| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 131| 2| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 2|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 2698| | 2699| 2| ISC_LIST_INIT(save); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 2700| 2| ISC_LIST_FOREACH(*current, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2701| 0| ISC_LIST_UNLINK(*current, this, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2702| 0| ISC_LIST_APPEND(save, this, link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2703| 0| } 2704| 2| ISC_LIST_FOREACH(save, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2705| 0| ISC_LIST_UNLINK(save, this, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2706| 0| INSIST(rdlcount < new_len); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2707| 0| newlist[rdlcount] = *this; 2708| 0| ISC_LIST_APPEND(*current, &newlist[rdlcount], link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2709| 0| rdlcount++; 2710| 0| } 2711| | 2712| 2| ISC_LIST_INIT(save); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 2713| 2| ISC_LIST_FOREACH(*glue, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2714| 0| ISC_LIST_UNLINK(*glue, this, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2715| 0| ISC_LIST_APPEND(save, this, link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2716| 0| } 2717| 2| ISC_LIST_FOREACH(save, this, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 2718| 0| ISC_LIST_UNLINK(save, this, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2719| 0| INSIST(rdlcount < new_len); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2720| 0| newlist[rdlcount] = *this; 2721| 0| ISC_LIST_APPEND(*glue, &newlist[rdlcount], link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 2722| 0| rdlcount++; 2723| 0| } 2724| | 2725| 2| INSIST(rdlcount == old_len); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2726| 2| if (oldlist != NULL) { ------------------ | Branch (2726:6): [True: 0, False: 2] ------------------ 2727| | isc_mem_cput(mctx, oldlist, old_len, sizeof(*oldlist)); ------------------ | | 155| 0| do { \ | | 156| 0| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 157| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 0| (p) = NULL; \ | | 159| 0| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 0] | | ------------------ ------------------ 2728| 0| } 2729| 2| return newlist; 2730| 2|} dns_message_create: 696| 1.59k| dns_message_t **msgp) { 697| 1.59k| REQUIRE(mctx != NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 698| 1.59k| REQUIRE(msgp != NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 699| 1.59k| REQUIRE(*msgp == NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 700| 1.59k| REQUIRE(intent == DNS_MESSAGE_INTENTPARSE || ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 701| 1.59k| intent == DNS_MESSAGE_INTENTRENDER); 702| 1.59k| REQUIRE((namepool != NULL && rdspool != NULL) || ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 7.98k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 1.59k] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 703| 1.59k| (namepool == NULL && rdspool == NULL)); 704| | 705| 1.59k| dns_message_t *msg = isc_mem_get(mctx, sizeof(dns_message_t)); ------------------ | | 128| 1.59k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 706| 1.59k| *msg = (dns_message_t){ 707| 1.59k| .from_to_wire = intent, 708| 1.59k| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 1.59k|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 709| 1.59k| .scratchpad = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.59k| { \ | | 22| 1.59k| .head = NULL, \ | | 23| 1.59k| .tail = NULL, \ | | 24| 1.59k| } ------------------ 710| 1.59k| .cleanup = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.59k| { \ | | 22| 1.59k| .head = NULL, \ | | 23| 1.59k| .tail = NULL, \ | | 24| 1.59k| } ------------------ 711| 1.59k| .rdatas = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.59k| { \ | | 22| 1.59k| .head = NULL, \ | | 23| 1.59k| .tail = NULL, \ | | 24| 1.59k| } ------------------ 712| 1.59k| .rdatalists = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.59k| { \ | | 22| 1.59k| .head = NULL, \ | | 23| 1.59k| .tail = NULL, \ | | 24| 1.59k| } ------------------ 713| 1.59k| .freerdata = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.59k| { \ | | 22| 1.59k| .head = NULL, \ | | 23| 1.59k| .tail = NULL, \ | | 24| 1.59k| } ------------------ 714| 1.59k| .freerdatalist = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.59k| { \ | | 22| 1.59k| .head = NULL, \ | | 23| 1.59k| .tail = NULL, \ | | 24| 1.59k| } ------------------ 715| 1.59k| .magic = DNS_MESSAGE_MAGIC, ------------------ | | 147| 1.59k|#define DNS_MESSAGE_MAGIC ISC_MAGIC('M', 'S', 'G', '@') | | ------------------ | | | | 31| 1.59k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 716| 1.59k| .namepool = namepool, 717| 1.59k| .rdspool = rdspool, 718| 1.59k| .free_pools = (namepool == NULL && rdspool == NULL), ------------------ | Branch (718:18): [True: 1.59k, False: 0] | Branch (718:38): [True: 1.59k, False: 0] ------------------ 719| 1.59k| }; 720| | 721| 1.59k| isc_mem_attach(mctx, &msg->mctx); 722| | 723| 1.59k| if (msg->free_pools) { ------------------ | Branch (723:6): [True: 1.59k, False: 0] ------------------ 724| 1.59k| dns_message_createpools(mctx, &msg->namepool, &msg->rdspool); 725| 1.59k| } 726| | 727| 1.59k| msginit(msg); 728| | 729| 7.98k| for (size_t i = 0; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (729:21): [True: 6.38k, False: 1.59k] ------------------ 730| 6.38k| ISC_LIST_INIT(msg->sections[i]); ------------------ | | 43| 6.38k| do { \ | | 44| 6.38k| (list).head = NULL; \ | | 45| 6.38k| (list).tail = NULL; \ | | 46| 6.38k| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 6.38k] | | ------------------ ------------------ 731| 6.38k| } 732| | 733| 1.59k| isc_buffer_t *dynbuf = NULL; 734| 1.59k| isc_buffer_allocate(mctx, &dynbuf, SCRATCHPAD_SIZE); ------------------ | | 124| 1.59k|#define SCRATCHPAD_SIZE 1232 ------------------ 735| 1.59k| ISC_LIST_APPEND(msg->scratchpad, dynbuf, link); ------------------ | | 100| 1.59k| do { \ | | 101| 1.59k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.59k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.59k| do { \ | | | | 89| 1.59k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.59k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.59k| } else { \ | | | | 92| 1.59k| (list).head = (elt); \ | | | | 93| 1.59k| } \ | | | | 94| 1.59k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.59k| (elt)->link.next = NULL; \ | | | | 96| 1.59k| (list).tail = (elt); \ | | | | 97| 1.59k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.59k] | | | | ------------------ | | ------------------ | | 103| 1.59k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.59k] | | ------------------ ------------------ 736| | 737| 1.59k| *msgp = msg; 738| 1.59k|} dns_message_parse: 1579| 1.59k| unsigned int options) { 1580| 1.59k| isc_region_t r; 1581| 1.59k| dns_decompress_t dctx; 1582| 1.59k| isc_result_t result; 1583| 1.59k| uint16_t tmpflags; 1584| 1.59k| isc_buffer_t origsource; 1585| 1.59k| bool seen_problem; 1586| 1.59k| bool ignore_tc; 1587| | 1588| 1.59k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1589| 1.59k| REQUIRE(source != NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1590| 1.59k| REQUIRE(msg->from_to_wire == DNS_MESSAGE_INTENTPARSE); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1591| | 1592| 1.59k| seen_problem = false; 1593| 1.59k| ignore_tc = ((options & DNS_MESSAGEPARSE_IGNORETRUNCATION) != 0); ------------------ | | 209| 1.59k| 0x0008 /*%< truncation errors are \ ------------------ 1594| | 1595| 1.59k| origsource = *source; 1596| | 1597| 1.59k| msg->header_ok = 0; 1598| 1.59k| msg->question_ok = 0; 1599| | 1600| 1.59k| if ((options & DNS_MESSAGEPARSE_CLONEBUFFER) == 0) { ------------------ | | 206| 1.59k| 0x0004 /*%< save a copy of the \ ------------------ | Branch (1600:6): [True: 1.59k, False: 0] ------------------ 1601| 1.59k| isc_buffer_usedregion(&origsource, &msg->saved); 1602| 1.59k| } else { 1603| 0| msg->saved.length = isc_buffer_usedlength(&origsource); ------------------ | | 157| 0|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1604| 0| msg->saved.base = isc_mem_get(msg->mctx, msg->saved.length); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1605| 0| memmove(msg->saved.base, isc_buffer_base(&origsource), ------------------ | | 143| 0|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 1606| 0| msg->saved.length); 1607| 0| msg->free_saved = 1; 1608| 0| } 1609| | 1610| 1.59k| isc_buffer_remainingregion(source, &r); 1611| 1.59k| if (r.length < DNS_MESSAGE_HEADERLEN) { ------------------ | | 145| 1.59k|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ | Branch (1611:6): [True: 0, False: 1.59k] ------------------ 1612| 0| return ISC_R_UNEXPECTEDEND; 1613| 0| } 1614| | 1615| 1.59k| msg->id = isc_buffer_getuint16(source); 1616| 1.59k| tmpflags = isc_buffer_getuint16(source); 1617| 1.59k| msg->opcode = ((tmpflags & DNS_MESSAGE_OPCODE_MASK) >> ------------------ | | 85| 1.59k|#define DNS_MESSAGE_OPCODE_MASK 0x7800U ------------------ 1618| 1.59k| DNS_MESSAGE_OPCODE_SHIFT); ------------------ | | 86| 1.59k|#define DNS_MESSAGE_OPCODE_SHIFT 11 ------------------ 1619| 1.59k| msg->rcode = (dns_rcode_t)(tmpflags & DNS_MESSAGE_RCODE_MASK); ------------------ | | 87| 1.59k|#define DNS_MESSAGE_RCODE_MASK 0x000fU ------------------ 1620| 1.59k| msg->flags = (tmpflags & DNS_MESSAGE_FLAG_MASK); ------------------ | | 88| 1.59k|#define DNS_MESSAGE_FLAG_MASK 0x8ff0U ------------------ 1621| 1.59k| msg->counts[DNS_SECTION_QUESTION] = isc_buffer_getuint16(source); 1622| 1.59k| msg->counts[DNS_SECTION_ANSWER] = isc_buffer_getuint16(source); 1623| 1.59k| msg->counts[DNS_SECTION_AUTHORITY] = isc_buffer_getuint16(source); 1624| 1.59k| msg->counts[DNS_SECTION_ADDITIONAL] = isc_buffer_getuint16(source); 1625| | 1626| 1.59k| msg->header_ok = 1; 1627| 1.59k| msg->state = DNS_SECTION_QUESTION; 1628| | 1629| 1.59k| dctx = DNS_DECOMPRESS_ALWAYS; 1630| | 1631| 1.59k| bool strict_parse = ((options & DNS_MESSAGEPARSE_BESTEFFORT) == 0); ------------------ | | 202| 1.59k| 0x0002 /*%< return a message if a \ ------------------ 1632| 1.59k| isc_result_t early_check_ret = early_sanity_check(msg); 1633| 1.59k| if (strict_parse && (early_check_ret != ISC_R_SUCCESS)) { ------------------ | Branch (1633:6): [True: 1.59k, False: 0] | Branch (1633:22): [True: 7, False: 1.58k] ------------------ 1634| 7| return early_check_ret; 1635| 7| } 1636| | 1637| 1.58k| result = getquestions(source, msg, dctx, options); 1638| | 1639| 1.58k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1639:6): [True: 0, False: 1.58k] | Branch (1639:39): [True: 0, False: 0] ------------------ 1640| 0| goto truncated; 1641| 0| } 1642| 1.58k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1642:6): [True: 0, False: 1.58k] ------------------ 1643| 0| seen_problem = true; 1644| 0| result = ISC_R_SUCCESS; 1645| 0| } 1646| 1.58k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1646:6): [True: 0, False: 1.58k] ------------------ 1647| 0| return result; 1648| 0| } 1649| 1.58k| msg->question_ok = 1; 1650| | 1651| 1.58k| result = getsection(source, msg, dctx, DNS_SECTION_ANSWER, options); 1652| 1.58k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1652:6): [True: 0, False: 1.58k] | Branch (1652:39): [True: 0, False: 0] ------------------ 1653| 0| goto truncated; 1654| 0| } 1655| 1.58k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1655:6): [True: 0, False: 1.58k] ------------------ 1656| 0| seen_problem = true; 1657| 0| result = ISC_R_SUCCESS; 1658| 0| } 1659| 1.58k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1659:6): [True: 0, False: 1.58k] ------------------ 1660| 0| return result; 1661| 0| } 1662| | 1663| 1.58k| result = getsection(source, msg, dctx, DNS_SECTION_AUTHORITY, options); 1664| 1.58k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1664:6): [True: 0, False: 1.58k] | Branch (1664:39): [True: 0, False: 0] ------------------ 1665| 0| goto truncated; 1666| 0| } 1667| 1.58k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1667:6): [True: 0, False: 1.58k] ------------------ 1668| 0| seen_problem = true; 1669| 0| result = ISC_R_SUCCESS; 1670| 0| } 1671| 1.58k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1671:6): [True: 0, False: 1.58k] ------------------ 1672| 0| return result; 1673| 0| } 1674| | 1675| 1.58k| result = getsection(source, msg, dctx, DNS_SECTION_ADDITIONAL, options); 1676| 1.58k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1676:6): [True: 243, False: 1.34k] | Branch (1676:39): [True: 0, False: 243] ------------------ 1677| 0| goto truncated; 1678| 0| } 1679| 1.58k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1679:6): [True: 0, False: 1.58k] ------------------ 1680| 0| seen_problem = true; 1681| 0| result = ISC_R_SUCCESS; 1682| 0| } 1683| 1.58k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1683:6): [True: 457, False: 1.13k] ------------------ 1684| 457| return result; 1685| 457| } 1686| | 1687| 1.13k| isc_buffer_remainingregion(source, &r); 1688| 1.13k| if (r.length != 0) { ------------------ | Branch (1688:6): [True: 0, False: 1.13k] ------------------ 1689| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MESSAGE, 1690| 0| ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1691| 0| "message has %u byte(s) of trailing garbage", 1692| 0| r.length); 1693| 0| } 1694| | 1695| 1.13k|truncated: 1696| | 1697| 1.13k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1697:6): [True: 0, False: 1.13k] | Branch (1697:39): [True: 0, False: 0] ------------------ 1698| 0| return DNS_R_RECOVERABLE; 1699| 0| } 1700| 1.13k| if (seen_problem) { ------------------ | Branch (1700:6): [True: 0, False: 1.13k] ------------------ 1701| 0| return DNS_R_RECOVERABLE; 1702| 0| } 1703| 1.13k| return ISC_R_SUCCESS; 1704| 1.13k|} dns_message_gettempname: 2406| 3.17k|dns_message_gettempname(dns_message_t *msg, dns_name_t **item) { 2407| 3.17k| dns_fixedname_t *fn = NULL; 2408| | 2409| 3.17k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 3.17k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.34k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | ------------------ | | | | 43| 3.17k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2410| 3.17k| REQUIRE(item != NULL && *item == NULL); ------------------ | | 194| 3.17k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.34k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | ------------------ | | | | 43| 3.17k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2411| | 2412| 3.17k| fn = isc_mempool_get(msg->namepool); ------------------ | | 147| 3.17k|#define isc_mempool_get(c) isc__mempool_get((c)_ISC_MEM_FILELINE) ------------------ 2413| 3.17k| *item = dns_fixedname_initname(fn); 2414| 3.17k|} dns_message_gettemprdata: 2417| 208|dns_message_gettemprdata(dns_message_t *msg, dns_rdata_t **item) { 2418| 208| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2419| 208| REQUIRE(item != NULL && *item == NULL); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2420| | 2421| 208| *item = newrdata(msg); 2422| 208|} dns_message_gettemprdataset: 2425| 2.92k|dns_message_gettemprdataset(dns_message_t *msg, dns_rdataset_t **item) { 2426| 2.92k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.84k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2427| 2.92k| REQUIRE(item != NULL && *item == NULL); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.84k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2428| | 2429| 2.92k| *item = isc_mempool_get(msg->rdspool); ------------------ | | 147| 2.92k|#define isc_mempool_get(c) isc__mempool_get((c)_ISC_MEM_FILELINE) ------------------ 2430| 2.92k| dns_rdataset_init(*item); 2431| 2.92k|} dns_message_gettemprdatalist: 2434| 208|dns_message_gettemprdatalist(dns_message_t *msg, dns_rdatalist_t **item) { 2435| 208| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2436| 208| REQUIRE(item != NULL && *item == NULL); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2437| | 2438| 208| *item = newrdatalist(msg); 2439| 208|} dns_message_puttempname: 2442| 3.17k|dns_message_puttempname(dns_message_t *msg, dns_name_t **itemp) { 2443| 3.17k| dns_name_t *item = NULL; 2444| | 2445| 3.17k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 3.17k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.34k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | ------------------ | | | | 43| 3.17k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2446| 3.17k| REQUIRE(itemp != NULL && *itemp != NULL); ------------------ | | 194| 3.17k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.34k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | | Branch (42:11): [True: 3.17k, False: 0] | | | | ------------------ | | | | 43| 3.17k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2447| | 2448| 3.17k| item = *itemp; 2449| 3.17k| *itemp = NULL; 2450| | 2451| 3.17k| REQUIRE(!ISC_LINK_LINKED(item, link)); ------------------ | | 194| 3.17k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.17k, False: 0] | | | | ------------------ | | | | 43| 3.17k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2452| 3.17k| REQUIRE(ISC_LIST_HEAD(item->list) == NULL); ------------------ | | 194| 3.17k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.17k, False: 0] | | | | ------------------ | | | | 43| 3.17k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2453| | 2454| 3.17k| if (item->hashmap != NULL) { ------------------ | Branch (2454:6): [True: 0, False: 3.17k] ------------------ 2455| 0| isc_hashmap_destroy(&item->hashmap); 2456| 0| } 2457| | 2458| | /* 2459| | * we need to check this in case dns_name_dup() was used. 2460| | */ 2461| 3.17k| if (dns_name_dynamic(item)) { ------------------ | Branch (2461:6): [True: 0, False: 3.17k] ------------------ 2462| 0| dns_name_free(item, msg->mctx); 2463| 0| } 2464| | 2465| | /* 2466| | * 'name' is the first field in dns_fixedname_t, so putting 2467| | * back the address of name is the same as putting back 2468| | * the fixedname. 2469| | */ 2470| | isc_mempool_put(msg->namepool, item); ------------------ | | 171| 3.17k| do { \ | | 172| 3.17k| isc__mempool_put((c), (p)_ISC_MEM_FILELINE); \ | | 173| 3.17k| (p) = NULL; \ | | 174| 3.17k| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 3.17k] | | ------------------ ------------------ 2471| 3.17k|} dns_message_puttemprdataset: 2489| 2.92k|dns_message_puttemprdataset(dns_message_t *msg, dns_rdataset_t **item) { 2490| 2.92k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.84k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2491| 2.92k| REQUIRE(item != NULL && *item != NULL); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.84k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2492| | 2493| 2.92k| REQUIRE(!dns_rdataset_isassociated(*item)); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2494| | isc_mempool_put(msg->rdspool, *item); ------------------ | | 171| 2.92k| do { \ | | 172| 2.92k| isc__mempool_put((c), (p)_ISC_MEM_FILELINE); \ | | 173| 2.92k| (p) = NULL; \ | | 174| 2.92k| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 2.92k] | | ------------------ ------------------ 2495| 2.92k|} dns_message_settsigkey: 2679| 289|dns_message_settsigkey(dns_message_t *msg, dns_tsigkey_t *key) { 2680| 289| isc_result_t result; 2681| | 2682| | /* 2683| | * Set the TSIG key for 'msg' 2684| | */ 2685| | 2686| 289| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 289|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 578| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 289, False: 0] | | | | | Branch (42:11): [True: 289, False: 0] | | | | ------------------ | | | | 43| 289| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2687| | 2688| 289| if (key == NULL && msg->tsigkey != NULL) { ------------------ | Branch (2688:6): [True: 0, False: 289] | Branch (2688:21): [True: 0, False: 0] ------------------ 2689| 0| if (msg->sig_reserved != 0) { ------------------ | Branch (2689:7): [True: 0, False: 0] ------------------ 2690| 0| dns_message_renderrelease(msg, msg->sig_reserved); 2691| 0| msg->sig_reserved = 0; 2692| 0| } 2693| 0| dns_tsigkey_detach(&msg->tsigkey); 2694| 0| } 2695| 289| if (key != NULL) { ------------------ | Branch (2695:6): [True: 289, False: 0] ------------------ 2696| 289| REQUIRE(msg->tsigkey == NULL && msg->sig0key == NULL); ------------------ | | 194| 289|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 578| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 289, False: 0] | | | | | Branch (42:11): [True: 289, False: 0] | | | | ------------------ | | | | 43| 289| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2697| 289| dns_tsigkey_attach(key, &msg->tsigkey); 2698| 289| if (msg->from_to_wire == DNS_MESSAGE_INTENTRENDER) { ------------------ | Branch (2698:7): [True: 0, False: 289] ------------------ 2699| 0| msg->sig_reserved = spacefortsig(msg->tsigkey, 0); 2700| 0| result = dns_message_renderreserve(msg, 2701| 0| msg->sig_reserved); 2702| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2702:8): [True: 0, False: 0] ------------------ 2703| 0| dns_tsigkey_detach(&msg->tsigkey); 2704| 0| msg->sig_reserved = 0; 2705| 0| return result; 2706| 0| } 2707| 0| } 2708| 289| } 2709| 289| return ISC_R_SUCCESS; 2710| 289|} dns_message_gettsigkey: 2713| 614|dns_message_gettsigkey(dns_message_t *msg) { 2714| | /* 2715| | * Get the TSIG key for 'msg' 2716| | */ 2717| | 2718| 614| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 614|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.22k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 614, False: 0] | | | | | Branch (42:11): [True: 614, False: 0] | | | | ------------------ | | | | 43| 614| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2719| | 2720| 614| return msg->tsigkey; 2721| 614|} dns_message_setquerytsig: 2724| 208|dns_message_setquerytsig(dns_message_t *msg, isc_buffer_t *querytsig) { 2725| 208| dns_rdata_t *rdata = NULL; 2726| 208| dns_rdatalist_t *list = NULL; 2727| 208| dns_rdataset_t *set = NULL; 2728| 208| isc_buffer_t *buf = NULL; 2729| 208| isc_region_t r; 2730| | 2731| 208| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2732| 208| REQUIRE(msg->querytsig == NULL); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2733| | 2734| 208| if (querytsig == NULL) { ------------------ | Branch (2734:6): [True: 0, False: 208] ------------------ 2735| 0| return; 2736| 0| } 2737| | 2738| 208| dns_message_gettemprdata(msg, &rdata); 2739| | 2740| 208| dns_message_gettemprdatalist(msg, &list); 2741| 208| dns_message_gettemprdataset(msg, &set); 2742| | 2743| 208| isc_buffer_usedregion(querytsig, &r); 2744| 208| isc_buffer_allocate(msg->mctx, &buf, r.length); 2745| 208| isc_buffer_putmem(buf, r.base, r.length); 2746| 208| isc_buffer_usedregion(buf, &r); 2747| 208| dns_rdata_fromregion(rdata, dns_rdataclass_any, dns_rdatatype_tsig, &r); ------------------ | | 34| 208|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ dns_rdata_fromregion(rdata, dns_rdataclass_any, dns_rdatatype_tsig, &r); ------------------ | | 190| 208|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ 2748| 208| dns_message_takebuffer(msg, &buf); 2749| 208| ISC_LIST_APPEND(list->rdata, rdata, link); ------------------ | | 100| 208| do { \ | | 101| 208| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 208| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 208| do { \ | | | | 89| 208| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 208] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 208| } else { \ | | | | 92| 208| (list).head = (elt); \ | | | | 93| 208| } \ | | | | 94| 208| (elt)->link.prev = (list).tail; \ | | | | 95| 208| (elt)->link.next = NULL; \ | | | | 96| 208| (list).tail = (elt); \ | | | | 97| 208| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 208] | | | | ------------------ | | ------------------ | | 103| 208| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 208] | | ------------------ ------------------ 2750| 208| dns_rdatalist_tordataset(list, set); 2751| | 2752| 208| msg->querytsig = set; 2753| 208|} dns_message_takebuffer: 2865| 208|dns_message_takebuffer(dns_message_t *msg, isc_buffer_t **buffer) { 2866| 208| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2867| 208| REQUIRE(buffer != NULL); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2868| 208| REQUIRE(ISC_BUFFER_VALID(*buffer)); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2869| | 2870| 208| ISC_LIST_APPEND(msg->cleanup, *buffer, link); ------------------ | | 100| 208| do { \ | | 101| 208| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 208| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 208| do { \ | | | | 89| 208| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 208] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 208| } else { \ | | | | 92| 208| (list).head = (elt); \ | | | | 93| 208| } \ | | | | 94| 208| (elt)->link.prev = (list).tail; \ | | | | 95| 208| (elt)->link.next = NULL; \ | | | | 96| 208| (list).tail = (elt); \ | | | | 97| 208| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 208] | | | | ------------------ | | ------------------ | | 103| 208| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 208] | | ------------------ ------------------ 2871| | *buffer = NULL; 2872| 208|} dns_message_checksig: 3053| 1.13k|dns_message_checksig(dns_message_t *msg, dns_view_t *view) { 3054| 1.13k| isc_buffer_t msgb; 3055| | 3056| 1.13k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 1.13k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.13k, False: 0] | | | | | Branch (42:11): [True: 1.13k, False: 0] | | | | ------------------ | | | | 43| 1.13k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 3057| | 3058| 1.13k| if (msg->tsigkey == NULL && msg->tsig == NULL && msg->sig0 == NULL) { ------------------ | Branch (3058:6): [True: 843, False: 289] | Branch (3058:30): [True: 518, False: 325] | Branch (3058:51): [True: 77, False: 441] ------------------ 3059| 77| return ISC_R_SUCCESS; 3060| 77| } 3061| | 3062| 1.05k| INSIST(msg->saved.base != NULL); ------------------ | | 198| 1.05k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.05k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.05k, False: 0] | | | | ------------------ | | | | 55| 1.05k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3063| 1.05k| isc_buffer_init(&msgb, msg->saved.base, msg->saved.length); 3064| 1.05k| isc_buffer_add(&msgb, msg->saved.length); 3065| 1.05k| if (msg->tsigkey != NULL || msg->tsig != NULL) { ------------------ | Branch (3065:6): [True: 289, False: 766] | Branch (3065:30): [True: 325, False: 441] ------------------ 3066| |#ifdef SKAN_MSG_DEBUG 3067| | dns_message_dumpsig(msg, "dns_message_checksig#1"); 3068| |#endif /* ifdef SKAN_MSG_DEBUG */ 3069| 614| if (view != NULL) { ------------------ | Branch (3069:7): [True: 429, False: 185] ------------------ 3070| 429| return dns_view_checksig(view, &msgb, msg); 3071| 429| } else { 3072| 185| return dns_tsig_verify(&msgb, msg, NULL, NULL); 3073| 185| } 3074| 614| } else { 3075| 441| dns_rdata_t sigrdata = DNS_RDATA_INIT; ------------------ | | 147| 441| { \ | | 148| 441| .data = NULL, \ | | 149| 441| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 441|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 441| { \ | | | | | | 27| 441| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 441|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 441| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 441|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 441| } | | | | ------------------ | | ------------------ | | 150| 441| } ------------------ 3076| 441| dns_rdata_sig_t sig; 3077| 441| dns_rdataset_t keyset; 3078| 441| isc_result_t result; 3079| 441| uint32_t key_checks, message_checks; 3080| | 3081| 441| result = dns_rdataset_first(msg->sig0); 3082| 441| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 441|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 441| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 441, False: 0] | | | | ------------------ | | | | 55| 441| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3083| 441| dns_rdataset_current(msg->sig0, &sigrdata); 3084| | 3085| | /* 3086| | * This can occur when the message is a dynamic update, since 3087| | * the rdata length checking is relaxed. This should not 3088| | * happen in a well-formed message, since the SIG(0) is only 3089| | * looked for in the additional section, and the dynamic update 3090| | * meta-records are in the prerequisite and update sections. 3091| | */ 3092| 441| if (sigrdata.length == 0) { ------------------ | Branch (3092:7): [True: 0, False: 441] ------------------ 3093| 0| return ISC_R_UNEXPECTEDEND; 3094| 0| } 3095| | 3096| 441| RETERR(dns_rdata_tostruct(&sigrdata, &sig, NULL)); ------------------ | | 272| 441| { \ | | 273| 441| isc_result_t _r = (x); \ | | 274| 441| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 441] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 441| } ------------------ 3097| | 3098| 441| dns_rdataset_init(&keyset); 3099| 441| if (view == NULL) { ------------------ | Branch (3099:7): [True: 69, False: 372] ------------------ 3100| 69| result = DNS_R_KEYUNAUTHORIZED; 3101| 69| goto freesig; 3102| 69| } 3103| 372| result = dns_view_simplefind(view, &sig.signer, 3104| 372| dns_rdatatype_key /* SIG(0) */, 0, ------------------ | | 139| 372|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ 3105| 372| 0, false, &keyset, NULL); 3106| | 3107| 372| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3107:7): [True: 240, False: 132] ------------------ 3108| 240| result = DNS_R_KEYUNAUTHORIZED; 3109| 240| goto freesig; 3110| 240| } else if (keyset.trust < dns_trust_ultimate) { ------------------ | | 380| 132|#define dns_trust_ultimate ((dns_trust_t)dns_trust_ultimate) ------------------ | Branch (3110:14): [True: 0, False: 132] ------------------ 3111| 0| result = DNS_R_KEYUNAUTHORIZED; 3112| 0| goto freesig; 3113| 0| } 3114| 132| result = dns_rdataset_first(&keyset); 3115| 132| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 132|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 132, False: 0] | | | | ------------------ | | | | 55| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3116| | 3117| | /* 3118| | * In order to protect from a possible DoS attack, this function 3119| | * supports limitations on how many keyid checks and how many 3120| | * key checks (message verifications using a matched key) are 3121| | * going to be allowed. 3122| | */ 3123| 132| const uint32_t max_key_checks = 3124| 132| view->sig0key_checks_limit > 0 ------------------ | Branch (3124:4): [True: 0, False: 132] ------------------ 3125| 132| ? view->sig0key_checks_limit 3126| 132| : UINT32_MAX; 3127| 132| const uint32_t max_message_checks = 3128| 132| view->sig0message_checks_limit > 0 ------------------ | Branch (3128:4): [True: 0, False: 132] ------------------ 3129| 132| ? view->sig0message_checks_limit 3130| 132| : UINT32_MAX; 3131| | 3132| 132| for (key_checks = 0, message_checks = 0; 3133| 263| result == ISC_R_SUCCESS && key_checks < max_key_checks && ------------------ | Branch (3133:8): [True: 132, False: 131] | Branch (3133:35): [True: 132, False: 0] ------------------ 3134| 132| message_checks < max_message_checks; ------------------ | Branch (3134:8): [True: 132, False: 0] ------------------ 3135| 132| key_checks++, result = dns_rdataset_next(&keyset)) 3136| 132| { 3137| 132| dns_rdata_t keyrdata = DNS_RDATA_INIT; ------------------ | | 147| 132| { \ | | 148| 132| .data = NULL, \ | | 149| 132| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 132|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 132| { \ | | | | | | 27| 132| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 132|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 132| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 132|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 132| } | | | | ------------------ | | ------------------ | | 150| 132| } ------------------ 3138| 132| dns_rdata_key_t ks; 3139| 132| dst_key_t *key = NULL; 3140| 132| isc_region_t r; 3141| | 3142| 132| dns_rdataset_current(&keyset, &keyrdata); 3143| 132| dns_rdata_tostruct(&keyrdata, &ks, NULL); 3144| | 3145| 132| if (sig.algorithm != ks.algorithm || ------------------ | Branch (3145:8): [True: 13, False: 119] ------------------ 3146| 119| (ks.protocol != DNS_KEYPROTO_DNSSEC && ------------------ | Branch (3146:9): [True: 0, False: 119] ------------------ 3147| 0| ks.protocol != DNS_KEYPROTO_ANY)) ------------------ | Branch (3147:9): [True: 0, False: 0] ------------------ 3148| 13| { 3149| 13| continue; 3150| 13| } 3151| | 3152| 119| dns_rdata_toregion(&keyrdata, &r); 3153| 119| if (dst_region_computeid(&r) != sig.keyid) { ------------------ | Branch (3153:8): [True: 23, False: 96] ------------------ 3154| 23| continue; 3155| 23| } 3156| | 3157| 96| result = dns_dnssec_keyfromrdata(&sig.signer, &keyrdata, 3158| 96| view->mctx, &key); 3159| 96| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3159:8): [True: 0, False: 96] ------------------ 3160| 0| continue; 3161| 0| } 3162| | 3163| 96| result = dns_dnssec_verifymessage(&msgb, msg, key); 3164| 96| dst_key_free(&key); 3165| 96| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3165:8): [True: 1, False: 95] ------------------ 3166| 1| break; 3167| 1| } 3168| 95| message_checks++; 3169| 95| } 3170| 132| if (result == ISC_R_NOMORE) { ------------------ | Branch (3170:7): [True: 131, False: 1] ------------------ 3171| 131| result = DNS_R_KEYUNAUTHORIZED; 3172| 131| } else if (key_checks == max_key_checks) { ------------------ | Branch (3172:14): [True: 0, False: 1] ------------------ 3173| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, 3174| 0| DNS_LOGMODULE_MESSAGE, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 3175| 0| "sig0key-checks-limit reached when " 3176| 0| "trying to check a message signature"); 3177| 0| result = DNS_R_KEYUNAUTHORIZED; 3178| 1| } else if (message_checks == max_message_checks) { ------------------ | Branch (3178:14): [True: 0, False: 1] ------------------ 3179| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, 3180| 0| DNS_LOGMODULE_MESSAGE, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 3181| 0| "sig0message-checks-limit reached when " 3182| 0| "trying to check a message signature"); 3183| 0| result = DNS_R_KEYUNAUTHORIZED; 3184| 0| } 3185| | 3186| 441| freesig: 3187| | dns_rdataset_cleanup(&keyset); ------------------ | | 287| 441| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 441, Folded] | | | Branch (287:26): [True: 132, False: 309] | | ------------------ | | 288| 132| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 132| } ------------------ 3188| 441| dns_rdata_freestruct(&sig); 3189| 441| return result; 3190| 132| } 3191| 1.05k|} dns_message_createpools: 5032| 1.59k| isc_mempool_t **rdspoolp) { 5033| 1.59k| REQUIRE(mctx != NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5034| 1.59k| REQUIRE(namepoolp != NULL && *namepoolp == NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5035| 1.59k| REQUIRE(rdspoolp != NULL && *rdspoolp == NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5036| | 5037| 1.59k| isc_mempool_create(mctx, sizeof(dns_fixedname_t), "dns_fixedname_pool", ------------------ | | 346| 1.59k| isc__mempool_create((c), (s), (n), (mp)_ISC_MEM_FILELINE) ------------------ 5038| 1.59k| namepoolp); 5039| 1.59k| isc_mempool_setfillcount(*namepoolp, NAME_FILLCOUNT); ------------------ | | 125| 1.59k|#define NAME_FILLCOUNT 1024 ------------------ 5040| 1.59k| isc_mempool_setfreemax(*namepoolp, NAME_FREEMAX); ------------------ | | 126| 1.59k|#define NAME_FREEMAX 8 * NAME_FILLCOUNT | | ------------------ | | | | 125| 1.59k|#define NAME_FILLCOUNT 1024 | | ------------------ ------------------ 5041| | 5042| 1.59k| isc_mempool_create(mctx, sizeof(dns_rdataset_t), "dns_rdataset_pool", ------------------ | | 346| 1.59k| isc__mempool_create((c), (s), (n), (mp)_ISC_MEM_FILELINE) ------------------ 5043| 1.59k| rdspoolp); 5044| 1.59k| isc_mempool_setfillcount(*rdspoolp, RDATASET_FILLCOUNT); ------------------ | | 130| 1.59k|#define RDATASET_FILLCOUNT 1024 ------------------ 5045| 1.59k| isc_mempool_setfreemax(*rdspoolp, RDATASET_FREEMAX); ------------------ | | 131| 1.59k|#define RDATASET_FREEMAX 8 * RDATASET_FILLCOUNT | | ------------------ | | | | 130| 1.59k|#define RDATASET_FILLCOUNT 1024 | | ------------------ ------------------ 5046| 1.59k|} dns_message_destroypools: 5049| 1.59k|dns_message_destroypools(isc_mempool_t **namepoolp, isc_mempool_t **rdspoolp) { 5050| 1.59k| REQUIRE(namepoolp != NULL && *namepoolp != NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5051| 1.59k| REQUIRE(rdspoolp != NULL && *rdspoolp != NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5052| | 5053| 1.59k| ENSURE(isc_mempool_getallocated(*namepoolp) == 0); ------------------ | | 196| 1.59k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 49| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 5054| 1.59k| ENSURE(isc_mempool_getallocated(*rdspoolp) == 0); ------------------ | | 196| 1.59k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 49| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 5055| | 5056| 1.59k| isc_mempool_destroy(rdspoolp); ------------------ | | 363| 1.59k|#define isc_mempool_destroy(mp) isc__mempool_destroy((mp)_ISC_MEM_FILELINE) ------------------ 5057| 1.59k| isc_mempool_destroy(namepoolp); ------------------ | | 363| 1.59k|#define isc_mempool_destroy(mp) isc__mempool_destroy((mp)_ISC_MEM_FILELINE) ------------------ 5058| 1.59k|} message.c:msginit: 427| 1.59k|msginit(dns_message_t *m) { 428| 1.59k| msginitheader(m); 429| 1.59k| msginitprivate(m); 430| 1.59k| msginittsig(m); 431| 1.59k| m->header_ok = 0; 432| 1.59k| m->question_ok = 0; 433| 1.59k| m->tcp_continuation = 0; 434| 1.59k| m->verified_sig = 0; 435| 1.59k| m->verify_attempted = 0; 436| 1.59k| m->query.base = NULL; 437| 1.59k| m->query.length = 0; 438| 1.59k| m->free_query = 0; 439| 1.59k| m->saved.base = NULL; 440| 1.59k| m->saved.length = 0; 441| 1.59k| m->free_saved = 0; 442| 1.59k| m->cc_ok = 0; 443| 1.59k| m->cc_bad = 0; 444| 1.59k| m->tkey = 0; 445| 1.59k| m->rdclass_set = 0; 446| 1.59k| m->has_dname = 0; 447| | m->querytsig = NULL; 448| 1.59k| m->indent.string = "\t"; 449| 1.59k| m->indent.count = 0; 450| 1.59k|} message.c:msginitheader: 380| 1.59k|msginitheader(dns_message_t *m) { 381| 1.59k| m->id = 0; 382| 1.59k| m->flags = 0; 383| 1.59k| m->rcode = 0; 384| 1.59k| m->opcode = 0; 385| 1.59k| m->rdclass = 0; 386| 1.59k|} message.c:msginittsig: 411| 1.59k|msginittsig(dns_message_t *m) { 412| 1.59k| m->tsigstatus = dns_rcode_noerror; ------------------ | | 269| 1.59k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 413| 1.59k| m->querytsigstatus = dns_rcode_noerror; ------------------ | | 269| 1.59k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 414| 1.59k| m->tsigkey = NULL; 415| 1.59k| m->tsigctx = NULL; 416| 1.59k| m->sigstart = -1; 417| 1.59k| m->sig0key = NULL; 418| 1.59k| m->sig0status = dns_rcode_noerror; ------------------ | | 269| 1.59k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 419| 1.59k| m->timeadjust = 0; 420| 1.59k|} message.c:msgreset: 542| 1.59k|msgreset(dns_message_t *msg, bool everything) { 543| 1.59k| dns_msgblock_t *msgblock = NULL, *next_msgblock = NULL; 544| 1.59k| isc_buffer_t *dynbuf = NULL, *next_dynbuf = NULL; 545| | 546| 1.59k| msgresetnames(msg, 0); 547| 1.59k| msgresetopt(msg); 548| 1.59k| msgresetsigs(msg, false); 549| 1.59k| msgresetedns(msg); 550| | 551| | /* 552| | * Clean up linked lists. 553| | */ 554| | 555| | /* 556| | * Run through the free lists, and just unlink anything found there. 557| | * The memory isn't lost since these are part of message blocks we 558| | * have allocated. 559| | */ 560| 1.59k| ISC_LIST_FOREACH(msg->freerdata, rdata, link) { ------------------ | | 234| 1.59k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 1.59k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 1.59k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 1.59k] | | ------------------ | | 236| 1.59k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 1.59k] | | ------------------ | | 237| 1.59k| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 561| 0| ISC_LIST_UNLINK(msg->freerdata, rdata, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 562| 0| } 563| 1.59k| ISC_LIST_FOREACH(msg->freerdatalist, rdatalist, link) { ------------------ | | 234| 1.59k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 1.59k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 1.59k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 1.59k] | | ------------------ | | 236| 1.59k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 1.59k] | | ------------------ | | 237| 1.59k| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 564| 0| ISC_LIST_UNLINK(msg->freerdatalist, rdatalist, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 565| 0| } 566| | 567| 1.59k| dynbuf = ISC_LIST_HEAD(msg->scratchpad); ------------------ | | 62| 1.59k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 568| 1.59k| INSIST(dynbuf != NULL); ------------------ | | 198| 1.59k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 55| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 569| 1.59k| if (!everything) { ------------------ | Branch (569:6): [True: 0, False: 1.59k] ------------------ 570| 0| isc_buffer_clear(dynbuf); 571| 0| dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 572| 0| } 573| 3.55k| while (dynbuf != NULL) { ------------------ | Branch (573:9): [True: 1.96k, False: 1.59k] ------------------ 574| 1.96k| next_dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 1.96k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 575| 1.96k| ISC_LIST_UNLINK(msg->scratchpad, dynbuf, link); ------------------ | | 137| 1.96k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.96k| do { \ | | | | 133| 1.96k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.96k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.96k| do { \ | | | | | | 110| 1.96k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 364, False: 1.59k] | | | | | | ------------------ | | | | | | 111| 364| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.59k| } else { \ | | | | | | 113| 1.59k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.59k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.59k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.59k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.59k| } \ | | | | | | 116| 1.96k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.96k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.96k| } else { \ | | | | | | 119| 1.96k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.96k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.96k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.96k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.96k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.96k| } \ | | | | | | 122| 1.96k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.96k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.96k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.96k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.96k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.96k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.96k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.96k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.96k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.96k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.96k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.96k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.96k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.96k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.96k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.96k] | | | | ------------------ | | ------------------ ------------------ 576| 1.96k| isc_buffer_free(&dynbuf); 577| 1.96k| dynbuf = next_dynbuf; 578| 1.96k| } 579| | 580| 1.59k| msgblock = ISC_LIST_HEAD(msg->rdatas); ------------------ | | 62| 1.59k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 581| 1.59k| if (!everything && msgblock != NULL) { ------------------ | Branch (581:6): [True: 0, False: 1.59k] | Branch (581:21): [True: 0, False: 0] ------------------ 582| 0| msgblock_reset(msgblock); 583| 0| msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 584| 0| } 585| 3.18k| while (msgblock != NULL) { ------------------ | Branch (585:9): [True: 1.58k, False: 1.59k] ------------------ 586| 1.58k| next_msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 1.58k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 587| 1.58k| ISC_LIST_UNLINK(msg->rdatas, msgblock, link); ------------------ | | 137| 1.58k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.58k| do { \ | | | | 133| 1.58k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.58k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.58k| do { \ | | | | | | 110| 1.58k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.58k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.58k| } else { \ | | | | | | 113| 1.58k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.58k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.58k| } \ | | | | | | 116| 1.58k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.58k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.58k| } else { \ | | | | | | 119| 1.58k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.58k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.58k| } \ | | | | | | 122| 1.58k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.58k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.58k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.58k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.58k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.58k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.58k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.58k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.58k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.58k] | | | | ------------------ | | ------------------ ------------------ 588| 1.58k| msgblock_free(msg->mctx, msgblock, sizeof(dns_rdata_t)); 589| 1.58k| msgblock = next_msgblock; 590| 1.58k| } 591| | 592| | /* 593| | * rdatalists could be empty. 594| | */ 595| | 596| 1.59k| msgblock = ISC_LIST_HEAD(msg->rdatalists); ------------------ | | 62| 1.59k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 597| 1.59k| if (!everything && msgblock != NULL) { ------------------ | Branch (597:6): [True: 0, False: 1.59k] | Branch (597:21): [True: 0, False: 0] ------------------ 598| 0| msgblock_reset(msgblock); 599| 0| msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 600| 0| } 601| 3.18k| while (msgblock != NULL) { ------------------ | Branch (601:9): [True: 1.58k, False: 1.59k] ------------------ 602| 1.58k| next_msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 1.58k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 603| 1.58k| ISC_LIST_UNLINK(msg->rdatalists, msgblock, link); ------------------ | | 137| 1.58k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.58k| do { \ | | | | 133| 1.58k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.58k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.58k| do { \ | | | | | | 110| 1.58k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.58k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.58k| } else { \ | | | | | | 113| 1.58k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.58k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.58k| } \ | | | | | | 116| 1.58k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.58k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.58k| } else { \ | | | | | | 119| 1.58k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.58k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.58k| } \ | | | | | | 122| 1.58k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.58k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.58k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.58k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.58k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.58k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.58k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.58k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.58k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.58k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.58k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.58k] | | | | ------------------ | | ------------------ ------------------ 604| 1.58k| msgblock_free(msg->mctx, msgblock, sizeof(dns_rdatalist_t)); 605| 1.58k| msgblock = next_msgblock; 606| 1.58k| } 607| | 608| 1.59k| if (msg->tsigkey != NULL) { ------------------ | Branch (608:6): [True: 613, False: 983] ------------------ 609| 613| dns_tsigkey_detach(&msg->tsigkey); 610| 613| msg->tsigkey = NULL; 611| 613| } 612| | 613| 1.59k| if (msg->tsigctx != NULL) { ------------------ | Branch (613:6): [True: 0, False: 1.59k] ------------------ 614| 0| dst_context_destroy(&msg->tsigctx); 615| 0| } 616| | 617| 1.59k| if (msg->query.base != NULL) { ------------------ | Branch (617:6): [True: 0, False: 1.59k] ------------------ 618| 0| if (msg->free_query != 0) { ------------------ | Branch (618:7): [True: 0, False: 0] ------------------ 619| 0| isc_mem_put(msg->mctx, msg->query.base, ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 620| 0| msg->query.length); 621| 0| } 622| 0| msg->query.base = NULL; 623| 0| msg->query.length = 0; 624| 0| } 625| | 626| 1.59k| if (msg->saved.base != NULL) { ------------------ | Branch (626:6): [True: 1.59k, False: 0] ------------------ 627| 1.59k| if (msg->free_saved != 0) { ------------------ | Branch (627:7): [True: 0, False: 1.59k] ------------------ 628| 0| isc_mem_put(msg->mctx, msg->saved.base, ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 629| 0| msg->saved.length); 630| 0| } 631| 1.59k| msg->saved.base = NULL; 632| 1.59k| msg->saved.length = 0; 633| 1.59k| } 634| | 635| | /* 636| | * cleanup the buffer cleanup list 637| | */ 638| 1.59k| dynbuf = ISC_LIST_HEAD(msg->cleanup); ------------------ | | 62| 1.59k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 639| 1.80k| while (dynbuf != NULL) { ------------------ | Branch (639:9): [True: 208, False: 1.59k] ------------------ 640| 208| next_dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 208|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 641| 208| ISC_LIST_UNLINK(msg->cleanup, dynbuf, link); ------------------ | | 137| 208| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 208| do { \ | | | | 133| 208| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 208| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 208| do { \ | | | | | | 110| 208| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 208] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 208| } else { \ | | | | | | 113| 208| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 208| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 208, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 208| (list).tail = (elt)->link.prev; \ | | | | | | 115| 208| } \ | | | | | | 116| 208| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 208] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 208| } else { \ | | | | | | 119| 208| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 208| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 208, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 208| (list).head = (elt)->link.next; \ | | | | | | 121| 208| } \ | | | | | | 122| 208| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 208|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 208| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 208|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 208| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 208| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 208, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 208| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 208| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 208, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 208| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 208] | | | | | | ------------------ | | | | ------------------ | | | | 135| 208| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 208] | | | | ------------------ | | ------------------ ------------------ 642| 208| isc_buffer_free(&dynbuf); 643| 208| dynbuf = next_dynbuf; 644| 208| } 645| | 646| | /* 647| | * Set other bits to normal default values. 648| | */ 649| 1.59k| if (!everything) { ------------------ | Branch (649:6): [True: 0, False: 1.59k] ------------------ 650| 0| msginit(msg); 651| 0| } 652| 1.59k|} message.c:msgblock_free: 285| 3.17k| unsigned int sizeof_type) { 286| 3.17k| unsigned int length; 287| | 288| 3.17k| length = sizeof(dns_msgblock_t) + (sizeof_type * block->count); 289| | 290| | isc_mem_put(mctx, block, length); ------------------ | | 150| 3.17k| do { \ | | 151| 3.17k| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 3.17k| (p) = NULL; \ | | 153| 3.17k| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 3.17k] | | ------------------ ------------------ 291| 3.17k|} message.c:dns__message_destroy: 751| 1.59k|dns__message_destroy(dns_message_t *msg) { 752| 1.59k| REQUIRE(msg != NULL); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.59k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 753| 1.59k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 754| | 755| 1.59k| msgreset(msg, true); 756| | 757| 1.59k| msg->magic = 0; 758| | 759| 1.59k| if (msg->free_pools) { ------------------ | Branch (759:6): [True: 1.59k, False: 0] ------------------ 760| 1.59k| dns_message_destroypools(&msg->namepool, &msg->rdspool); 761| 1.59k| } 762| | 763| | isc_mem_putanddetach(&msg->mctx, msg, sizeof(dns_message_t)); ------------------ | | 161| 1.59k| do { \ | | 162| 1.59k| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 1.59k| (p) = NULL; \ | | 164| 1.59k| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 1.59k] | | ------------------ ------------------ 764| 1.59k|} message.c:early_sanity_check: 1546| 1.59k|early_sanity_check(dns_message_t *msg) { 1547| 1.59k| bool is_unknown_opcode = msg->opcode >= dns_opcode_max; 1548| 1.59k| bool is_query_response = (msg->flags & DNS_MESSAGEFLAG_QR) != 0; 1549| 1.59k| bool no_questions = msg->counts[DNS_SECTION_QUESTION] == 0; 1550| 1.59k| bool many_questions = msg->counts[DNS_SECTION_QUESTION] > 1; 1551| 1.59k| bool has_answer = msg->counts[DNS_SECTION_ANSWER] > 0; 1552| 1.59k| bool has_auth = msg->counts[DNS_SECTION_AUTHORITY] > 0; 1553| | 1554| 1.59k| if (is_unknown_opcode) { ------------------ | Branch (1554:6): [True: 7, False: 1.58k] ------------------ 1555| 7| return DNS_R_NOTIMP; 1556| 1.58k| } else if (many_questions) { ------------------ | Branch (1556:13): [True: 0, False: 1.58k] ------------------ 1557| 0| return DNS_R_FORMERR; 1558| 1.58k| } else if (no_questions && (msg->opcode != dns_opcode_query) && ------------------ | Branch (1558:13): [True: 0, False: 1.58k] | Branch (1558:29): [True: 0, False: 0] ------------------ 1559| 0| (msg->opcode != dns_opcode_status)) ------------------ | Branch (1559:6): [True: 0, False: 0] ------------------ 1560| 0| { 1561| | /* 1562| | * Per RFC9619, the two cases where qdcount == 0 is acceptable 1563| | * are AXFR transfers and cookies, and both have opcode 0. 1564| | * 1565| | * RFC9619 also specifies that msg->opcode == dns_opcode_status 1566| | * is unspecified, so we ignore it. 1567| | */ 1568| 0| return DNS_R_FORMERR; 1569| 1.58k| } else if (msg->opcode == dns_opcode_notify && ------------------ | Branch (1569:13): [True: 239, False: 1.35k] ------------------ 1570| 239| ((is_query_response && has_answer) || has_auth)) ------------------ | Branch (1570:8): [True: 25, False: 214] | Branch (1570:29): [True: 0, False: 25] | Branch (1570:44): [True: 0, False: 239] ------------------ 1571| 0| { 1572| 0| return DNS_R_FORMERR; 1573| 0| } 1574| 1.58k| return ISC_R_SUCCESS; 1575| 1.59k|} message.c:getquestions: 933| 1.58k| unsigned int options) { 934| 1.58k| isc_region_t r; 935| 1.58k| unsigned int count; 936| 1.58k| dns_name_t *name = NULL; 937| 1.58k| dns_rdataset_t *rdataset = NULL; 938| 1.58k| dns_rdatalist_t *rdatalist = NULL; 939| 1.58k| isc_result_t result = ISC_R_SUCCESS; 940| 1.58k| dns_rdatatype_t rdtype; 941| 1.58k| dns_rdataclass_t rdclass; 942| 1.58k| dns_namelist_t *section = &msg->sections[DNS_SECTION_QUESTION]; 943| 1.58k| bool best_effort = ((options & DNS_MESSAGEPARSE_BESTEFFORT) != 0); ------------------ | | 202| 1.58k| 0x0002 /*%< return a message if a \ ------------------ 944| 1.58k| bool seen_problem = false; 945| 1.58k| bool free_name = false; 946| | 947| 1.58k| REQUIRE(msg->counts[DNS_SECTION_QUESTION] <= 1 || best_effort); ------------------ | | 194| 1.58k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.58k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.58k, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 948| | 949| 3.17k| for (count = 0; count < msg->counts[DNS_SECTION_QUESTION]; count++) { ------------------ | Branch (949:18): [True: 1.58k, False: 1.58k] ------------------ 950| 1.58k| name = NULL; 951| 1.58k| dns_message_gettempname(msg, &name); 952| 1.58k| free_name = true; 953| | 954| | /* 955| | * Parse the name out of this packet. 956| | */ 957| 1.58k| isc_buffer_remainingregion(source, &r); 958| 1.58k| isc_buffer_setactive(source, r.length); 959| 1.58k| CHECK(getname(name, source, msg, dctx)); ------------------ | | 251| 1.58k| { \ | | 252| 1.58k| result = (r); \ | | 253| 1.58k| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 1.58k] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 1.58k| } ------------------ 960| | 961| 1.58k| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 1.58k| do { \ | | 101| 1.58k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.58k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.58k| do { \ | | | | 89| 1.58k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.58k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.58k| } else { \ | | | | 92| 1.58k| (list).head = (elt); \ | | | | 93| 1.58k| } \ | | | | 94| 1.58k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.58k| (elt)->link.next = NULL; \ | | | | 96| 1.58k| (list).tail = (elt); \ | | | | 97| 1.58k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.58k] | | | | ------------------ | | ------------------ | | 103| 1.58k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.58k] | | ------------------ ------------------ 962| | 963| 1.58k| free_name = false; 964| | 965| | /* 966| | * Get type and class. 967| | */ 968| 1.58k| isc_buffer_remainingregion(source, &r); 969| 1.58k| if (r.length < 4) { ------------------ | Branch (969:7): [True: 0, False: 1.58k] ------------------ 970| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 971| 0| } 972| 1.58k| rdtype = isc_buffer_getuint16(source); 973| 1.58k| rdclass = isc_buffer_getuint16(source); 974| | 975| | /* 976| | * Notify and update messages need to specify the data class. 977| | */ 978| 1.58k| if ((msg->opcode == dns_opcode_update || ------------------ | Branch (978:8): [True: 258, False: 1.33k] ------------------ 979| 1.33k| msg->opcode == dns_opcode_notify) && ------------------ | Branch (979:8): [True: 239, False: 1.09k] ------------------ 980| 497| (rdclass == dns_rdataclass_none || ------------------ | | 32| 994|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (980:8): [True: 0, False: 497] ------------------ 981| 497| rdclass == dns_rdataclass_any)) ------------------ | | 34| 497|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (981:8): [True: 0, False: 497] ------------------ 982| 0| { 983| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 984| 0| } 985| | 986| | /* 987| | * If this class is different than the one we already read, 988| | * this is an error. 989| | */ 990| 1.58k| if (msg->rdclass_set == 0) { ------------------ | Branch (990:7): [True: 1.58k, False: 0] ------------------ 991| 1.58k| msg->rdclass = rdclass; 992| 1.58k| msg->rdclass_set = 1; 993| 1.58k| } else if (msg->rdclass != rdclass) { ------------------ | Branch (993:14): [True: 0, False: 0] ------------------ 994| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 995| 0| } 996| | 997| | /* 998| | * Is this a TKEY query? 999| | */ 1000| 1.58k| if (rdtype == dns_rdatatype_tkey) { ------------------ | | 189| 1.58k|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1000:7): [True: 0, False: 1.58k] ------------------ 1001| 0| msg->tkey = 1; 1002| 0| } 1003| | 1004| | /* 1005| | * Allocate a new rdatalist. 1006| | */ 1007| 1.58k| rdatalist = newrdatalist(msg); 1008| 1.58k| rdatalist->type = rdtype; 1009| 1.58k| rdatalist->rdclass = rdclass; 1010| 1.58k| rdatalist->covers = dns_rdatatype_none; ------------------ | | 114| 1.58k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1011| | 1012| | /* 1013| | * Convert rdatalist to rdataset, and attach the latter to 1014| | * the name. 1015| | */ 1016| 1.58k| dns_message_gettemprdataset(msg, &rdataset); 1017| 1.58k| dns_rdatalist_tordataset(rdatalist, rdataset); 1018| | 1019| 1.58k| rdataset->attributes.question = true; 1020| | 1021| 1.58k| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 1.58k| do { \ | | 101| 1.58k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.58k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.58k| do { \ | | | | 89| 1.58k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.58k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.58k| } else { \ | | | | 92| 1.58k| (list).head = (elt); \ | | | | 93| 1.58k| } \ | | | | 94| 1.58k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.58k| (elt)->link.next = NULL; \ | | | | 96| 1.58k| (list).tail = (elt); \ | | | | 97| 1.58k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.58k] | | | | ------------------ | | ------------------ | | 103| 1.58k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.58k] | | ------------------ ------------------ 1022| | 1023| 1.58k| rdataset = NULL; 1024| 1.58k| } 1025| | 1026| 1.58k| if (seen_problem) { ------------------ | Branch (1026:6): [True: 0, False: 1.58k] ------------------ 1027| | /* XXX test coverage */ 1028| 0| result = DNS_R_RECOVERABLE; 1029| 0| } 1030| | 1031| 1.58k|cleanup: 1032| 1.58k| if (rdataset != NULL) { ------------------ | Branch (1032:6): [True: 0, False: 1.58k] ------------------ 1033| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 287| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 0] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 1034| 0| dns_message_puttemprdataset(msg, &rdataset); 1035| 0| } 1036| | 1037| 1.58k| if (free_name) { ------------------ | Branch (1037:6): [True: 0, False: 1.58k] ------------------ 1038| 0| dns_message_puttempname(msg, &name); 1039| 0| } 1040| | 1041| 1.58k| return result; 1042| 1.58k|} message.c:getname: 832| 3.17k| dns_decompress_t dctx) { 833| 3.17k| isc_buffer_t *scratch; 834| 3.17k| isc_result_t result; 835| 3.17k| unsigned int tries; 836| | 837| 3.17k| scratch = currentbuffer(msg); 838| | 839| | /* 840| | * First try: use current buffer. 841| | * Second try: allocate a new buffer and use that. 842| | */ 843| 3.17k| tries = 0; 844| 3.17k| while (tries < 2) { ------------------ | Branch (844:9): [True: 3.17k, False: 0] ------------------ 845| 3.17k| result = dns_name_fromwire(name, source, dctx, scratch); 846| | 847| 3.17k| if (result == ISC_R_NOSPACE) { ------------------ | Branch (847:7): [True: 0, False: 3.17k] ------------------ 848| 0| tries++; 849| | 850| 0| newbuffer(msg, SCRATCHPAD_SIZE); ------------------ | | 124| 0|#define SCRATCHPAD_SIZE 1232 ------------------ 851| 0| scratch = currentbuffer(msg); 852| 0| dns_name_reset(name); 853| 3.17k| } else { 854| 3.17k| return result; 855| 3.17k| } 856| 3.17k| } 857| | 858| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 859| 3.17k|} message.c:currentbuffer: 308| 5.11k|currentbuffer(dns_message_t *msg) { 309| 5.11k| isc_buffer_t *dynbuf; 310| | 311| 5.11k| dynbuf = ISC_LIST_TAIL(msg->scratchpad); ------------------ | | 63| 5.11k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 312| 5.11k| INSIST(dynbuf != NULL); ------------------ | | 198| 5.11k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 5.11k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 5.11k, False: 0] | | | | ------------------ | | | | 55| 5.11k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 313| | 314| 5.11k| return dynbuf; 315| 5.11k|} message.c:newbuffer: 299| 364|newbuffer(dns_message_t *msg, unsigned int size) { 300| 364| isc_buffer_t *dynbuf = NULL; 301| | 302| 364| isc_buffer_allocate(msg->mctx, &dynbuf, size); 303| | 304| | ISC_LIST_APPEND(msg->scratchpad, dynbuf, link); ------------------ | | 100| 364| do { \ | | 101| 364| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 364| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 364| do { \ | | | | 89| 364| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 364, False: 0] | | | | ------------------ | | | | 90| 364| (list).tail->link.next = (elt); \ | | | | 91| 364| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 364| (elt)->link.prev = (list).tail; \ | | | | 95| 364| (elt)->link.next = NULL; \ | | | | 96| 364| (list).tail = (elt); \ | | | | 97| 364| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 364] | | | | ------------------ | | ------------------ | | 103| 364| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 364] | | ------------------ ------------------ 305| 364|} message.c:getsection: 1058| 4.76k| dns_section_t sectionid, unsigned int options) { 1059| 4.76k| isc_region_t r; 1060| 4.76k| unsigned int count, rdatalen; 1061| 4.76k| dns_name_t *name = NULL; 1062| 4.76k| dns_name_t *found_name = NULL; 1063| 4.76k| dns_rdataset_t *rdataset = NULL; 1064| 4.76k| dns_rdataset_t *found_rdataset = NULL; 1065| 4.76k| dns_rdatalist_t *rdatalist = NULL; 1066| 4.76k| isc_result_t result = ISC_R_SUCCESS; 1067| 4.76k| dns_rdatatype_t rdtype, covers; 1068| 4.76k| dns_rdataclass_t rdclass; 1069| 4.76k| dns_rdata_t *rdata = NULL; 1070| 4.76k| dns_ttl_t ttl; 1071| 4.76k| dns_namelist_t *section = &msg->sections[sectionid]; 1072| 4.76k| bool free_name = false, seen_problem = false; 1073| 4.76k| bool free_hashmaps = false; 1074| 4.76k| bool preserve_order = ((options & DNS_MESSAGEPARSE_PRESERVEORDER) != 0); ------------------ | | 200| 4.76k|#define DNS_MESSAGEPARSE_PRESERVEORDER 0x0001 /*%< preserve rdata order */ ------------------ 1075| 4.76k| bool best_effort = ((options & DNS_MESSAGEPARSE_BESTEFFORT) != 0); ------------------ | | 202| 4.76k| 0x0002 /*%< return a message if a \ ------------------ 1076| 4.76k| bool isedns, issigzero, istsig; 1077| 4.76k| isc_hashmap_t *name_map = NULL; 1078| | 1079| 4.76k| if (msg->counts[sectionid] > 1) { ------------------ | Branch (1079:6): [True: 0, False: 4.76k] ------------------ 1080| 0| isc_hashmap_create(msg->mctx, 1, &name_map); 1081| 0| } 1082| | 1083| 5.89k| for (count = 0; count < msg->counts[sectionid]; count++) { ------------------ | Branch (1083:18): [True: 1.58k, False: 4.31k] ------------------ 1084| 1.58k| int recstart = source->current; 1085| 1.58k| bool skip_name_search, skip_type_search; 1086| | 1087| 1.58k| skip_name_search = false; 1088| 1.58k| skip_type_search = false; 1089| 1.58k| isedns = false; 1090| 1.58k| issigzero = false; 1091| 1.58k| istsig = false; 1092| 1.58k| found_rdataset = NULL; 1093| | 1094| 1.58k| name = NULL; 1095| 1.58k| dns_message_gettempname(msg, &name); 1096| 1.58k| free_name = true; 1097| | 1098| | /* 1099| | * Parse the name out of this packet. 1100| | */ 1101| 1.58k| isc_buffer_remainingregion(source, &r); 1102| 1.58k| isc_buffer_setactive(source, r.length); 1103| 1.58k| CHECK(getname(name, source, msg, dctx)); ------------------ | | 251| 1.58k| { \ | | 252| 1.58k| result = (r); \ | | 253| 1.58k| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 1.58k] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 1.58k| } ------------------ 1104| | 1105| | /* 1106| | * Get type, class, ttl, and rdatalen. Verify that at least 1107| | * rdatalen bytes remain. (Some of this is deferred to 1108| | * later.) 1109| | */ 1110| 1.58k| isc_buffer_remainingregion(source, &r); 1111| 1.58k| if (r.length < 2 + 2 + 4 + 2) { ------------------ | Branch (1111:7): [True: 0, False: 1.58k] ------------------ 1112| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 1113| 0| } 1114| 1.58k| rdtype = isc_buffer_getuint16(source); 1115| 1.58k| rdclass = isc_buffer_getuint16(source); 1116| | 1117| | /* 1118| | * If there was no question section, we may not yet have 1119| | * established a class. Do so now. 1120| | */ 1121| 1.58k| if (msg->rdclass_set == 0 && ------------------ | Branch (1121:7): [True: 0, False: 1.58k] ------------------ 1122| 0| rdtype != dns_rdatatype_opt && /* class is UDP SIZE */ ------------------ | | 155| 1.58k|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1122:7): [True: 0, False: 0] ------------------ 1123| 0| rdtype != dns_rdatatype_tsig && /* class is ANY */ ------------------ | | 190| 1.58k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1123:7): [True: 0, False: 0] ------------------ 1124| 0| rdtype != dns_rdatatype_tkey) /* class is undefined */ ------------------ | | 189| 0|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1124:7): [True: 0, False: 0] ------------------ 1125| 0| { 1126| 0| msg->rdclass = rdclass; 1127| 0| msg->rdclass_set = 1; 1128| 0| } 1129| | 1130| | /* 1131| | * If this class is different than the one in the question 1132| | * section, bail. 1133| | */ 1134| 1.58k| if (msg->opcode != dns_opcode_update && ------------------ | Branch (1134:7): [True: 1.32k, False: 257] ------------------ 1135| 1.32k| rdtype != dns_rdatatype_tsig && ------------------ | | 190| 2.90k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1135:7): [True: 612, False: 713] ------------------ 1136| 612| rdtype != dns_rdatatype_opt && ------------------ | | 155| 2.19k|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1136:7): [True: 612, False: 0] ------------------ 1137| 612| rdtype != dns_rdatatype_key && /* in a TKEY query */ ------------------ | | 139| 2.19k|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ | Branch (1137:7): [True: 612, False: 0] ------------------ 1138| 612| rdtype != dns_rdatatype_sig && /* SIG(0) */ ------------------ | | 138| 2.19k|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ | Branch (1138:7): [True: 0, False: 612] ------------------ 1139| 0| rdtype != dns_rdatatype_tkey && /* Win2000 TKEY */ ------------------ | | 189| 1.58k|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1139:7): [True: 0, False: 0] ------------------ 1140| 0| msg->rdclass != dns_rdataclass_any && ------------------ | | 34| 1.58k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1140:7): [True: 0, False: 0] ------------------ 1141| 0| msg->rdclass != rdclass) ------------------ | Branch (1141:7): [True: 0, False: 0] ------------------ 1142| 0| { 1143| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1144| 0| } 1145| | 1146| | /* 1147| | * If this is not a TKEY query/response then the KEY 1148| | * record's class needs to match. 1149| | */ 1150| 1.58k| if (msg->opcode != dns_opcode_update && !msg->tkey && ------------------ | Branch (1150:7): [True: 1.32k, False: 257] | Branch (1150:43): [True: 1.32k, False: 0] ------------------ 1151| 1.32k| rdtype == dns_rdatatype_key && ------------------ | | 139| 2.90k|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ | Branch (1151:7): [True: 0, False: 1.32k] ------------------ 1152| 0| msg->rdclass != dns_rdataclass_any && ------------------ | | 34| 1.58k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1152:7): [True: 0, False: 0] ------------------ 1153| 0| msg->rdclass != rdclass) ------------------ | Branch (1153:7): [True: 0, False: 0] ------------------ 1154| 0| { 1155| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1156| 0| } 1157| | 1158| | /* 1159| | * Special type handling for TSIG, OPT, and TKEY. 1160| | */ 1161| 1.58k| if (rdtype == dns_rdatatype_tsig) { ------------------ | | 190| 1.58k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1161:7): [True: 929, False: 653] ------------------ 1162| | /* 1163| | * If it is a tsig, verify that it is in the 1164| | * additional data section. 1165| | */ 1166| 929| if (sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1166:8): [True: 0, False: 929] ------------------ 1167| 929| rdclass != dns_rdataclass_any || ------------------ | | 34| 1.85k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1167:8): [True: 0, False: 929] ------------------ 1168| 929| count != msg->counts[sectionid] - 1) ------------------ | Branch (1168:8): [True: 0, False: 929] ------------------ 1169| 0| { 1170| 0| DO_ERROR(DNS_R_BADTSIG); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1171| 929| } else { 1172| 929| skip_name_search = true; 1173| 929| skip_type_search = true; 1174| 929| istsig = true; 1175| 929| } 1176| 929| } else if (rdtype == dns_rdatatype_opt) { ------------------ | | 155| 653|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1176:14): [True: 0, False: 653] ------------------ 1177| | /* 1178| | * The name of an OPT record must be ".", it 1179| | * must be in the additional data section, and 1180| | * it must be the first OPT we've seen. 1181| | */ 1182| 0| if (!dns_name_equal(dns_rootname, name) || ------------------ | Branch (1182:8): [True: 0, False: 0] ------------------ 1183| 0| sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1183:8): [True: 0, False: 0] ------------------ 1184| 0| msg->opt != NULL) ------------------ | Branch (1184:8): [True: 0, False: 0] ------------------ 1185| 0| { 1186| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1187| 0| } else { 1188| 0| skip_name_search = true; 1189| 0| skip_type_search = true; 1190| 0| isedns = true; 1191| 0| } 1192| 653| } else if (rdtype == dns_rdatatype_tkey) { ------------------ | | 189| 653|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1192:14): [True: 0, False: 653] ------------------ 1193| | /* 1194| | * A TKEY must be in the additional section if this 1195| | * is a query, and the answer section if this is a 1196| | * response. Unless it's a Win2000 client. 1197| | * 1198| | * Its class is ignored. 1199| | */ 1200| 0| dns_section_t tkeysection; 1201| | 1202| 0| if ((msg->flags & DNS_MESSAGEFLAG_QR) == 0) { ------------------ | Branch (1202:8): [True: 0, False: 0] ------------------ 1203| 0| tkeysection = DNS_SECTION_ADDITIONAL; 1204| 0| } else { 1205| 0| tkeysection = DNS_SECTION_ANSWER; 1206| 0| } 1207| 0| if (sectionid != tkeysection && ------------------ | Branch (1207:8): [True: 0, False: 0] ------------------ 1208| 0| sectionid != DNS_SECTION_ANSWER) ------------------ | Branch (1208:8): [True: 0, False: 0] ------------------ 1209| 0| { 1210| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1211| 0| } 1212| 0| } 1213| | 1214| | /* 1215| | * ... now get ttl and rdatalen, and check buffer. 1216| | */ 1217| 1.58k| ttl = isc_buffer_getuint32(source); 1218| 1.58k| rdatalen = isc_buffer_getuint16(source); 1219| 1.58k| r.length -= (2 + 2 + 4 + 2); 1220| 1.58k| if (r.length < rdatalen) { ------------------ | Branch (1220:7): [True: 0, False: 1.58k] ------------------ 1221| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 1222| 0| } 1223| | 1224| | /* 1225| | * Read the rdata from the wire format. Interpret the 1226| | * rdata according to its actual class, even if it had a 1227| | * DynDNS meta-class in the packet (unless this is a TSIG). 1228| | * Then put the meta-class back into the finished rdata. 1229| | */ 1230| 1.58k| rdata = newrdata(msg); 1231| 1.58k| if (msg->opcode == dns_opcode_update && ------------------ | Branch (1231:7): [True: 257, False: 1.32k] ------------------ 1232| 257| update(sectionid, rdclass)) ------------------ | Branch (1232:7): [True: 0, False: 257] ------------------ 1233| 0| { 1234| 0| if (rdatalen != 0) { ------------------ | Branch (1234:8): [True: 0, False: 0] ------------------ 1235| 0| CLEANUP(DNS_R_FORMERR); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 1236| 0| } 1237| | /* 1238| | * When the rdata is empty, the data pointer is 1239| | * never dereferenced, but it must still be non-NULL. 1240| | * Casting 1 rather than "" avoids warnings about 1241| | * discarding the const attribute of a string, 1242| | * for compilers that would warn about such things. 1243| | */ 1244| 0| rdata->data = (unsigned char *)1; 1245| 0| rdata->length = 0; 1246| 0| rdata->rdclass = rdclass; 1247| 0| rdata->type = rdtype; 1248| 0| rdata->flags = DNS_RDATA_UPDATE; ------------------ | | 166| 0|#define DNS_RDATA_UPDATE 0x0001 /*%< update pseudo record. */ ------------------ 1249| 0| result = ISC_R_SUCCESS; 1250| 1.58k| } else if (rdclass == dns_rdataclass_none && ------------------ | | 32| 3.16k|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (1250:14): [True: 0, False: 1.58k] ------------------ 1251| 0| msg->opcode == dns_opcode_update && ------------------ | Branch (1251:7): [True: 0, False: 0] ------------------ 1252| 0| sectionid == DNS_SECTION_UPDATE) ------------------ | | 186| 0|#define DNS_SECTION_UPDATE DNS_SECTION_AUTHORITY ------------------ | Branch (1252:7): [True: 0, False: 0] ------------------ 1253| 0| { 1254| 0| result = getrdata(source, msg, dctx, msg->rdclass, 1255| 0| rdtype, rdatalen, rdata); 1256| 1.58k| } else { 1257| 1.58k| result = getrdata(source, msg, dctx, rdclass, rdtype, 1258| 1.58k| rdatalen, rdata); 1259| 1.58k| } 1260| 1.58k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1260:7): [True: 457, False: 1.12k] ------------------ 1261| 457| goto cleanup; 1262| 457| } 1263| 1.12k| rdata->rdclass = rdclass; 1264| 1.12k| if (rdtype == dns_rdatatype_rrsig && rdata->flags == 0) { ------------------ | | 160| 2.25k|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1264:7): [True: 0, False: 1.12k] | Branch (1264:40): [True: 0, False: 0] ------------------ 1265| 0| covers = dns_rdata_covers(rdata); 1266| | /* A signature can only cover a real rdata type */ 1267| 0| if (covers == dns_rdatatype_none || ------------------ | | 114| 0|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1267:8): [True: 0, False: 0] ------------------ 1268| 0| dns_rdatatype_ismeta(covers)) ------------------ | Branch (1268:8): [True: 0, False: 0] ------------------ 1269| 0| { 1270| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1271| 0| } 1272| 1.12k| } else if (rdtype == dns_rdatatype_sig /* SIG(0) */ && ------------------ | | 138| 2.25k|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ | Branch (1272:14): [True: 550, False: 575] ------------------ 1273| 550| rdata->flags == 0) ------------------ | Branch (1273:7): [True: 550, False: 0] ------------------ 1274| 550| { 1275| 550| covers = dns_rdata_covers(rdata); 1276| 550| if (covers == dns_rdatatype_none) { ------------------ | | 114| 550|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1276:8): [True: 443, False: 107] ------------------ 1277| 443| if (sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1277:9): [True: 0, False: 443] ------------------ 1278| 443| count != msg->counts[sectionid] - 1 || ------------------ | Branch (1278:9): [True: 0, False: 443] ------------------ 1279| 443| !dns_name_equal(name, dns_rootname)) ------------------ | Branch (1279:9): [True: 0, False: 443] ------------------ 1280| 0| { 1281| 0| DO_ERROR(DNS_R_BADSIG0); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1282| 443| } else { 1283| 443| skip_name_search = true; 1284| 443| skip_type_search = true; 1285| 443| issigzero = true; 1286| 443| } 1287| 443| } else { 1288| 107| covers = dns_rdatatype_none; ------------------ | | 114| 107|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1289| 107| } 1290| 575| } else { 1291| 575| covers = dns_rdatatype_none; ------------------ | | 114| 575|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1292| 575| } 1293| | 1294| | /* 1295| | * Check the ownername of NSEC3 records 1296| | */ 1297| 1.12k| if (rdtype == dns_rdatatype_nsec3 && ------------------ | | 164| 2.25k|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1297:7): [True: 0, False: 1.12k] ------------------ 1298| 0| !dns_rdata_checkowner(name, msg->rdclass, rdtype, false)) ------------------ | Branch (1298:7): [True: 0, False: 0] ------------------ 1299| 0| { 1300| 0| CLEANUP(DNS_R_BADOWNERNAME); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 1301| 0| } 1302| | 1303| | /* 1304| | * If we are doing a dynamic update or this is a meta-type, 1305| | * don't bother searching for a name, just append this one 1306| | * to the end of the message. 1307| | */ 1308| 1.12k| if (preserve_order || msg->opcode == dns_opcode_update || ------------------ | Branch (1308:7): [True: 0, False: 1.12k] | Branch (1308:25): [True: 157, False: 968] ------------------ 1309| 968| skip_name_search) ------------------ | Branch (1309:7): [True: 873, False: 95] ------------------ 1310| 1.03k| { 1311| 1.03k| if (!isedns && !istsig && !issigzero) { ------------------ | Branch (1311:8): [True: 1.03k, False: 0] | Branch (1311:19): [True: 455, False: 575] | Branch (1311:30): [True: 12, False: 443] ------------------ 1312| 12| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 12| do { \ | | 101| 12| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 12| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 12| do { \ | | | | 89| 12| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 12] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 12| } else { \ | | | | 92| 12| (list).head = (elt); \ | | | | 93| 12| } \ | | | | 94| 12| (elt)->link.prev = (list).tail; \ | | | | 95| 12| (elt)->link.next = NULL; \ | | | | 96| 12| (list).tail = (elt); \ | | | | 97| 12| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 12] | | | | ------------------ | | ------------------ | | 103| 12| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 12] | | ------------------ ------------------ 1313| 12| free_name = false; 1314| 12| } 1315| 1.03k| } else { 1316| 95| if (name_map == NULL) { ------------------ | Branch (1316:8): [True: 95, False: 0] ------------------ 1317| 95| result = ISC_R_SUCCESS; 1318| 95| goto skip_name_check; 1319| 95| } 1320| | 1321| | /* 1322| | * Run through the section, looking to see if this name 1323| | * is already there. If it is found, put back the 1324| | * allocated name since we no longer need it, and set 1325| | * our name pointer to point to the name we found. 1326| | */ 1327| 0| result = isc_hashmap_add(name_map, dns_name_hash(name), 1328| 0| name_match, name, name, 1329| 0| (void **)&found_name); 1330| | 1331| | /* 1332| | * If it is a new name, append to the section. 1333| | */ 1334| 95| skip_name_check: 1335| 95| switch (result) { 1336| 95| case ISC_R_SUCCESS: ------------------ | Branch (1336:4): [True: 95, False: 0] ------------------ 1337| 95| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 95| do { \ | | 101| 95| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 95| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 95| do { \ | | | | 89| 95| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 95] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 95| } else { \ | | | | 92| 95| (list).head = (elt); \ | | | | 93| 95| } \ | | | | 94| 95| (elt)->link.prev = (list).tail; \ | | | | 95| 95| (elt)->link.next = NULL; \ | | | | 96| 95| (list).tail = (elt); \ | | | | 97| 95| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 95] | | | | ------------------ | | ------------------ | | 103| 95| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 95] | | ------------------ ------------------ 1338| 95| break; 1339| 0| case ISC_R_EXISTS: ------------------ | Branch (1339:4): [True: 0, False: 95] ------------------ 1340| 0| dns_message_puttempname(msg, &name); 1341| 0| name = found_name; 1342| 0| found_name = NULL; 1343| 0| break; 1344| 0| default: ------------------ | Branch (1344:4): [True: 0, False: 95] ------------------ 1345| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1346| 95| } 1347| 95| free_name = false; 1348| 95| } 1349| | 1350| 1.12k| rdatalist = newrdatalist(msg); 1351| 1.12k| rdatalist->type = rdtype; 1352| 1.12k| rdatalist->covers = covers; 1353| 1.12k| rdatalist->rdclass = rdclass; 1354| 1.12k| rdatalist->ttl = ttl; 1355| | 1356| 1.12k| dns_message_gettemprdataset(msg, &rdataset); 1357| 1.12k| dns_rdatalist_tordataset(rdatalist, rdataset); 1358| 1.12k| dns_rdataset_setownercase(rdataset, name); 1359| 1.12k| rdatalist = NULL; 1360| | 1361| | /* 1362| | * Search name for the particular type and class. 1363| | * Skip this stage if in update mode or this is a meta-type. 1364| | */ 1365| 1.12k| if (isedns || istsig || issigzero) { ------------------ | Branch (1365:7): [True: 0, False: 1.12k] | Branch (1365:17): [True: 575, False: 550] | Branch (1365:27): [True: 443, False: 107] ------------------ 1366| | /* Skip adding the rdataset to the tables */ 1367| 1.01k| } else if (preserve_order || msg->opcode == dns_opcode_update || ------------------ | Branch (1367:14): [True: 0, False: 107] | Branch (1367:32): [True: 12, False: 95] ------------------ 1368| 95| skip_type_search) ------------------ | Branch (1368:7): [True: 0, False: 95] ------------------ 1369| 12| { 1370| 12| result = ISC_R_SUCCESS; 1371| | 1372| 12| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 12| do { \ | | 101| 12| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 12| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 12| do { \ | | | | 89| 12| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 12] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 12| } else { \ | | | | 92| 12| (list).head = (elt); \ | | | | 93| 12| } \ | | | | 94| 12| (elt)->link.prev = (list).tail; \ | | | | 95| 12| (elt)->link.next = NULL; \ | | | | 96| 12| (list).tail = (elt); \ | | | | 97| 12| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 12] | | | | ------------------ | | ------------------ | | 103| 12| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 12] | | ------------------ ------------------ 1373| 95| } else { 1374| | /* 1375| | * If this is a type that can only occur in 1376| | * the question section, fail. 1377| | */ 1378| 95| if (dns_rdatatype_questiononly(rdtype)) { ------------------ | Branch (1378:8): [True: 0, False: 95] ------------------ 1379| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1380| 0| } 1381| | 1382| 95| if (ISC_LIST_EMPTY(name->list)) { ------------------ | | 64| 95|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (64:30): [True: 95, False: 0] | | ------------------ ------------------ 1383| 95| result = ISC_R_SUCCESS; 1384| 95| goto skip_rds_check; 1385| 95| } 1386| | 1387| 0| if (name->hashmap == NULL) { ------------------ | Branch (1387:8): [True: 0, False: 0] ------------------ 1388| 0| isc_hashmap_create(msg->mctx, 1, 1389| 0| &name->hashmap); 1390| 0| free_hashmaps = true; 1391| | 1392| 0| INSIST(ISC_LIST_HEAD(name->list) == ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1393| 0| ISC_LIST_TAIL(name->list)); 1394| | 1395| 0| dns_rdataset_t *old_rdataset = 1396| 0| ISC_LIST_HEAD(name->list); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1397| | 1398| 0| result = isc_hashmap_add( 1399| 0| name->hashmap, rds_hash(old_rdataset), 1400| 0| rds_match, old_rdataset, old_rdataset, 1401| 0| NULL); 1402| | 1403| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1404| 0| } 1405| | 1406| 0| result = isc_hashmap_add( 1407| 0| name->hashmap, rds_hash(rdataset), rds_match, 1408| 0| rdataset, rdataset, (void **)&found_rdataset); 1409| | 1410| | /* 1411| | * If we found an rdataset that matches, we need to 1412| | * append this rdata to that set. If we did not, we 1413| | * need to create a new rdatalist, store the important 1414| | * bits there, convert it to an rdataset, and link the 1415| | * latter to the name. Yuck. When appending, make 1416| | * certain that the type isn't a singleton type, such as 1417| | * SOA or CNAME. 1418| | * 1419| | * Note that this check will be bypassed when preserving 1420| | * order, the opcode is an update, or the type search is 1421| | * skipped. 1422| | */ 1423| 95| skip_rds_check: 1424| 95| switch (result) { 1425| 0| case ISC_R_EXISTS: ------------------ | Branch (1425:4): [True: 0, False: 95] ------------------ 1426| | /* Free the rdataset we used as the key */ 1427| 0| dns__message_putassociatedrdataset(msg, 1428| 0| &rdataset); 1429| 0| result = ISC_R_SUCCESS; 1430| 0| rdataset = found_rdataset; 1431| | 1432| 0| if (!dns_rdatatype_issingleton(rdtype)) { ------------------ | Branch (1432:9): [True: 0, False: 0] ------------------ 1433| 0| break; 1434| 0| } 1435| | 1436| 0| dns_rdatalist_fromrdataset(rdataset, 1437| 0| &rdatalist); 1438| 0| dns_rdata_t *first = 1439| 0| ISC_LIST_HEAD(rdatalist->rdata); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1440| 0| INSIST(first != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1441| 0| if (dns_rdata_compare(rdata, first) != 0) { ------------------ | Branch (1441:9): [True: 0, False: 0] ------------------ 1442| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 913| 0| do { \ | | 914| 0| if (best_effort) { \ | | ------------------ | | | Branch (914:7): [True: 0, False: 0] | | ------------------ | | 915| 0| seen_problem = true; \ | | 916| 0| } else { \ | | 917| 0| result = r; \ | | 918| 0| goto cleanup; \ | | 919| 0| } \ | | 920| 0| } while (0) | | ------------------ | | | Branch (920:11): [Folded, False: 0] | | ------------------ ------------------ 1443| 0| } 1444| 0| break; 1445| 95| case ISC_R_SUCCESS: ------------------ | Branch (1445:4): [True: 95, False: 0] ------------------ 1446| 95| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 95| do { \ | | 101| 95| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 95| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 95| do { \ | | | | 89| 95| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 95] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 95| } else { \ | | | | 92| 95| (list).head = (elt); \ | | | | 93| 95| } \ | | | | 94| 95| (elt)->link.prev = (list).tail; \ | | | | 95| 95| (elt)->link.next = NULL; \ | | | | 96| 95| (list).tail = (elt); \ | | | | 97| 95| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 95] | | | | ------------------ | | ------------------ | | 103| 95| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 95] | | ------------------ ------------------ 1447| 95| break; 1448| 0| default: ------------------ | Branch (1448:4): [True: 0, False: 95] ------------------ 1449| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1450| 95| } 1451| 95| } 1452| | 1453| | /* 1454| | * Minimize TTLs. 1455| | * 1456| | * Section 5.2 of RFC2181 says we should drop 1457| | * nonauthoritative rrsets where the TTLs differ, but we 1458| | * currently treat them the as if they were authoritative and 1459| | * minimize them. 1460| | */ 1461| 1.12k| if (ttl != rdataset->ttl) { ------------------ | Branch (1461:7): [True: 0, False: 1.12k] ------------------ 1462| 0| rdataset->attributes.ttladjusted = true; 1463| 0| if (ttl < rdataset->ttl) { ------------------ | Branch (1463:8): [True: 0, False: 0] ------------------ 1464| 0| rdataset->ttl = ttl; 1465| 0| } 1466| 0| } 1467| | 1468| | /* Append this rdata to the rdataset. */ 1469| 1.12k| dns_rdatalist_fromrdataset(rdataset, &rdatalist); 1470| 1.12k| ISC_LIST_APPEND(rdatalist->rdata, rdata, link); ------------------ | | 100| 1.12k| do { \ | | 101| 1.12k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.12k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.12k| do { \ | | | | 89| 1.12k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.12k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.12k| } else { \ | | | | 92| 1.12k| (list).head = (elt); \ | | | | 93| 1.12k| } \ | | | | 94| 1.12k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.12k| (elt)->link.next = NULL; \ | | | | 96| 1.12k| (list).tail = (elt); \ | | | | 97| 1.12k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.12k] | | | | ------------------ | | ------------------ | | 103| 1.12k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.12k] | | ------------------ ------------------ 1471| | 1472| | /* 1473| | * If this is an OPT, SIG(0) or TSIG record, remember it. 1474| | * Also, set the extended rcode for TSIG. 1475| | * 1476| | * Note msg->opt, msg->sig0 and msg->tsig will only be 1477| | * already set if best-effort parsing is enabled otherwise 1478| | * there will only be at most one of each. 1479| | */ 1480| 1.12k| if (isedns) { ------------------ | Branch (1480:7): [True: 0, False: 1.12k] ------------------ 1481| 0| dns_rcode_t ercode; 1482| | 1483| 0| msg->opt = rdataset; 1484| 0| ercode = (dns_rcode_t)((msg->opt->ttl & 1485| 0| DNS_MESSAGE_EDNSRCODE_MASK) >> ------------------ | | 89| 0|#define DNS_MESSAGE_EDNSRCODE_MASK 0xff000000U ------------------ 1486| 0| 20); 1487| 0| msg->rcode |= ercode; 1488| 0| dns_message_puttempname(msg, &name); 1489| 0| free_name = false; 1490| 1.12k| } else if (issigzero) { ------------------ | Branch (1490:14): [True: 443, False: 682] ------------------ 1491| 443| msg->sig0 = rdataset; 1492| 443| msg->sig0name = name; 1493| 443| msg->sigstart = recstart; 1494| 443| free_name = false; 1495| 682| } else if (istsig) { ------------------ | Branch (1495:14): [True: 575, False: 107] ------------------ 1496| 575| msg->tsig = rdataset; 1497| 575| msg->tsigname = name; 1498| 575| msg->sigstart = recstart; 1499| | /* 1500| | * Windows doesn't like TSIG names to be compressed. 1501| | */ 1502| 575| msg->tsigname->attributes.nocompress = true; 1503| 575| free_name = false; 1504| 575| } else if (rdtype == dns_rdatatype_dname && ------------------ | | 153| 214|#define dns_rdatatype_dname ((dns_rdatatype_t)dns_rdatatype_dname) ------------------ | Branch (1504:14): [True: 0, False: 107] ------------------ 1505| 0| sectionid == DNS_SECTION_ANSWER && ------------------ | Branch (1505:7): [True: 0, False: 0] ------------------ 1506| 0| msg->opcode == dns_opcode_query) ------------------ | Branch (1506:7): [True: 0, False: 0] ------------------ 1507| 0| { 1508| 0| msg->has_dname = 1; 1509| 0| } 1510| 1.12k| rdataset = NULL; 1511| | 1512| 1.12k| if (seen_problem) { ------------------ | Branch (1512:7): [True: 0, False: 1.12k] ------------------ 1513| 0| if (free_name) { ------------------ | Branch (1513:8): [True: 0, False: 0] ------------------ 1514| | /* XXX test coverage */ 1515| 0| dns_message_puttempname(msg, &name); 1516| 0| } 1517| 0| free_name = false; 1518| 0| } 1519| 1.12k| INSIST(!free_name); ------------------ | | 198| 1.12k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.12k, False: 0] | | | | ------------------ | | | | 55| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1520| 1.12k| } 1521| | 1522| 4.31k| if (seen_problem) { ------------------ | Branch (1522:6): [True: 0, False: 4.31k] ------------------ 1523| 0| result = DNS_R_RECOVERABLE; 1524| 0| } 1525| | 1526| 4.76k|cleanup: 1527| 4.76k| if (rdataset != NULL && rdataset != found_rdataset) { ------------------ | Branch (1527:6): [True: 0, False: 4.76k] | Branch (1527:26): [True: 0, False: 0] ------------------ 1528| 0| dns__message_putassociatedrdataset(msg, &rdataset); 1529| 0| } 1530| 4.76k| if (free_name) { ------------------ | Branch (1530:6): [True: 457, False: 4.31k] ------------------ 1531| 457| dns_message_puttempname(msg, &name); 1532| 457| } 1533| | 1534| 4.76k| if (free_hashmaps) { ------------------ | Branch (1534:6): [True: 0, False: 4.76k] ------------------ 1535| 0| cleanup_name_hashmaps(section); 1536| 0| } 1537| | 1538| 4.76k| if (name_map != NULL) { ------------------ | Branch (1538:6): [True: 0, False: 4.76k] ------------------ 1539| 0| isc_hashmap_destroy(&name_map); 1540| 0| } 1541| | 1542| 4.76k| return result; 1543| 4.31k|} message.c:update: 1045| 257|update(dns_section_t section, dns_rdataclass_t rdclass) { 1046| 257| if (section == DNS_SECTION_PREREQUISITE) { ------------------ | | 185| 257|#define DNS_SECTION_PREREQUISITE DNS_SECTION_ANSWER ------------------ | Branch (1046:6): [True: 0, False: 257] ------------------ 1047| 0| return rdclass == dns_rdataclass_any || ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1047:10): [True: 0, False: 0] ------------------ 1048| 0| rdclass == dns_rdataclass_none; ------------------ | | 32| 0|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (1048:10): [True: 0, False: 0] ------------------ 1049| 0| } 1050| 257| if (section == DNS_SECTION_UPDATE) { ------------------ | | 186| 257|#define DNS_SECTION_UPDATE DNS_SECTION_AUTHORITY ------------------ | Branch (1050:6): [True: 0, False: 257] ------------------ 1051| 0| return rdclass == dns_rdataclass_any; ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ 1052| 0| } 1053| 257| return false; 1054| 257|} message.c:getrdata: 864| 1.58k| unsigned int rdatalen, dns_rdata_t *rdata) { 865| 1.58k| isc_buffer_t *scratch; 866| 1.58k| isc_result_t result; 867| 1.58k| unsigned int tries; 868| 1.58k| unsigned int trysize; 869| | 870| 1.58k| scratch = currentbuffer(msg); 871| | 872| 1.58k| isc_buffer_setactive(source, rdatalen); 873| | 874| | /* 875| | * First try: use current buffer. 876| | * Second try: allocate a new buffer of size 877| | * max(SCRATCHPAD_SIZE, 2 * compressed_rdatalen) 878| | * (the data will fit if it was not more than 50% compressed) 879| | * Subsequent tries: double buffer size on each try. 880| | */ 881| 1.58k| tries = 0; 882| 1.58k| trysize = 0; 883| | /* XXX possibly change this to a while (tries < 2) loop */ 884| 1.94k| for (;;) { 885| 1.94k| result = dns_rdata_fromwire(rdata, rdclass, rdtype, source, 886| 1.94k| dctx, scratch); 887| | 888| 1.94k| if (result == ISC_R_NOSPACE) { ------------------ | Branch (888:7): [True: 364, False: 1.58k] ------------------ 889| 364| if (tries == 0) { ------------------ | Branch (889:8): [True: 364, False: 0] ------------------ 890| 364| trysize = 2 * rdatalen; 891| 364| if (trysize < SCRATCHPAD_SIZE) { ------------------ | | 124| 364|#define SCRATCHPAD_SIZE 1232 ------------------ | Branch (891:9): [True: 0, False: 364] ------------------ 892| 0| trysize = SCRATCHPAD_SIZE; ------------------ | | 124| 0|#define SCRATCHPAD_SIZE 1232 ------------------ 893| 0| } 894| 364| } else { 895| 0| INSIST(trysize != 0); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 896| 0| if (trysize >= 65535) { ------------------ | Branch (896:9): [True: 0, False: 0] ------------------ 897| 0| return ISC_R_NOSPACE; 898| 0| } 899| | /* XXX DNS_R_RRTOOLONG? */ 900| 0| trysize *= 2; 901| 0| } 902| 364| tries++; 903| 364| newbuffer(msg, trysize); 904| | 905| 364| scratch = currentbuffer(msg); 906| 1.58k| } else { 907| 1.58k| return result; 908| 1.58k| } 909| 1.94k| } 910| 1.58k|} message.c:msgresetnames: 461| 1.59k|msgresetnames(dns_message_t *msg, unsigned int first_section) { 462| | /* Clean up name lists. */ 463| 7.98k| for (size_t i = first_section; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (463:33): [True: 6.38k, False: 1.59k] ------------------ 464| 6.38k| ISC_LIST_FOREACH(msg->sections[i], name, link) { ------------------ | | 234| 6.38k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 6.38k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 6.38k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 1.69k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 1.69k, False: 4.68k] | | ------------------ | | 236| 8.08k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 1.69k, False: 6.38k] | | ------------------ | | 237| 6.38k| elt = elt##_next, \ | | 238| 1.69k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 1.69k] | | ------------------ ------------------ 465| | ISC_LIST_UNLINK(msg->sections[i], name, link); ------------------ | | 137| 1.69k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.69k| do { \ | | | | 133| 1.69k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.69k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.69k| do { \ | | | | | | 110| 1.69k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.69k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.69k| } else { \ | | | | | | 113| 1.69k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.69k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.69k| } \ | | | | | | 116| 1.69k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.69k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.69k| } else { \ | | | | | | 119| 1.69k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.69k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.69k| } \ | | | | | | 122| 1.69k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.69k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.69k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.69k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.69k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.69k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.69k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.69k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.69k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.69k] | | | | ------------------ | | ------------------ ------------------ 466| 1.69k| msgresetname(msg, name); 467| 1.69k| dns_message_puttempname(msg, &name); 468| 1.69k| } 469| 6.38k| } 470| 1.59k|} message.c:msgresetname: 453| 1.69k|msgresetname(dns_message_t *msg, dns_name_t *name) { 454| 1.69k| ISC_LIST_FOREACH(name->list, rds, link) { ------------------ | | 234| 1.69k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 1.69k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 1.69k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 1.69k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 1.69k, False: 0] | | ------------------ | | 236| 3.39k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 1.69k, False: 1.69k] | | ------------------ | | 237| 1.69k| elt = elt##_next, \ | | 238| 1.69k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 1.69k] | | ------------------ ------------------ 455| | ISC_LIST_UNLINK(name->list, rds, link); ------------------ | | 137| 1.69k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.69k| do { \ | | | | 133| 1.69k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.69k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.69k| do { \ | | | | | | 110| 1.69k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.69k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.69k| } else { \ | | | | | | 113| 1.69k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.69k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.69k| } \ | | | | | | 116| 1.69k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.69k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.69k| } else { \ | | | | | | 119| 1.69k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.69k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.69k| } \ | | | | | | 122| 1.69k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.69k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.69k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.69k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.69k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.69k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.69k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.69k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.69k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.69k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.69k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.69k] | | | | ------------------ | | ------------------ ------------------ 456| 1.69k| dns__message_putassociatedrdataset(msg, &rds); 457| 1.69k| } 458| 1.69k|} message.c:newrdata: 323| 1.79k|newrdata(dns_message_t *msg) { 324| 1.79k| dns_msgblock_t *msgblock; 325| 1.79k| dns_rdata_t *rdata; 326| | 327| 1.79k| rdata = ISC_LIST_HEAD(msg->freerdata); ------------------ | | 62| 1.79k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 328| 1.79k| if (rdata != NULL) { ------------------ | Branch (328:6): [True: 0, False: 1.79k] ------------------ 329| 0| ISC_LIST_UNLINK(msg->freerdata, rdata, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 330| 0| dns_rdata_reset(rdata); 331| 0| return rdata; 332| 0| } 333| | 334| 1.79k| msgblock = ISC_LIST_TAIL(msg->rdatas); ------------------ | | 63| 1.79k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 335| 1.79k| rdata = msgblock_get(msgblock, dns_rdata_t); ------------------ | | 191| 1.79k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 336| 1.79k| if (rdata == NULL) { ------------------ | Branch (336:6): [True: 1.58k, False: 206] ------------------ 337| 1.58k| msgblock = msgblock_allocate(msg->mctx, sizeof(dns_rdata_t), 338| 1.58k| RDATA_COUNT); ------------------ | | 128| 1.58k|#define RDATA_COUNT 8 ------------------ 339| 1.58k| ISC_LIST_APPEND(msg->rdatas, msgblock, link); ------------------ | | 100| 1.58k| do { \ | | 101| 1.58k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.58k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.58k| do { \ | | | | 89| 1.58k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.58k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.58k| } else { \ | | | | 92| 1.58k| (list).head = (elt); \ | | | | 93| 1.58k| } \ | | | | 94| 1.58k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.58k| (elt)->link.next = NULL; \ | | | | 96| 1.58k| (list).tail = (elt); \ | | | | 97| 1.58k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.58k] | | | | ------------------ | | ------------------ | | 103| 1.58k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.58k] | | ------------------ ------------------ 340| | 341| 1.58k| rdata = msgblock_get(msgblock, dns_rdata_t); ------------------ | | 191| 1.58k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 342| 1.58k| } 343| | 344| 1.79k| dns_rdata_init(rdata); 345| 1.79k| return rdata; 346| 1.79k|} message.c:msgblock_internalget: 260| 7.88k|msgblock_internalget(dns_msgblock_t *block, unsigned int sizeof_type) { 261| 7.88k| void *ptr; 262| | 263| 7.88k| if (block == NULL || block->remaining == 0) { ------------------ | Branch (263:6): [True: 3.17k, False: 4.71k] | Branch (263:23): [True: 0, False: 4.71k] ------------------ 264| 3.17k| return NULL; 265| 3.17k| } 266| | 267| 4.71k| block->remaining--; 268| | 269| 4.71k| ptr = (((unsigned char *)block) + sizeof(dns_msgblock_t) + 270| 4.71k| (sizeof_type * block->remaining)); 271| | 272| 4.71k| return ptr; 273| 7.88k|} message.c:msgblock_allocate: 239| 3.17k| unsigned int count) { 240| 3.17k| dns_msgblock_t *block; 241| 3.17k| unsigned int length; 242| | 243| 3.17k| length = sizeof(dns_msgblock_t) + (sizeof_type * count); 244| | 245| 3.17k| block = isc_mem_get(mctx, length); ------------------ | | 128| 3.17k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 246| | 247| 3.17k| block->count = count; 248| 3.17k| block->remaining = count; 249| | 250| 3.17k| ISC_LINK_INIT(block, link); ------------------ | | 57| 3.17k|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 3.17k| do { \ | | | | 54| 3.17k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 3.17k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 3.17k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 3.17k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 3.17k| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 3.17k] | | | | ------------------ | | ------------------ ------------------ 251| | 252| 3.17k| return block; 253| 3.17k|} message.c:newrdatalist: 354| 2.92k|newrdatalist(dns_message_t *msg) { 355| 2.92k| dns_msgblock_t *msgblock; 356| 2.92k| dns_rdatalist_t *rdatalist; 357| | 358| 2.92k| rdatalist = ISC_LIST_HEAD(msg->freerdatalist); ------------------ | | 62| 2.92k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 359| 2.92k| if (rdatalist != NULL) { ------------------ | Branch (359:6): [True: 0, False: 2.92k] ------------------ 360| 0| ISC_LIST_UNLINK(msg->freerdatalist, rdatalist, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 361| 0| dns_rdatalist_init(rdatalist); 362| 0| goto out; 363| 0| } 364| | 365| 2.92k| msgblock = ISC_LIST_TAIL(msg->rdatalists); ------------------ | | 63| 2.92k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 366| 2.92k| rdatalist = msgblock_get(msgblock, dns_rdatalist_t); ------------------ | | 191| 2.92k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 367| 2.92k| if (rdatalist == NULL) { ------------------ | Branch (367:6): [True: 1.58k, False: 1.33k] ------------------ 368| 1.58k| msgblock = msgblock_allocate(msg->mctx, sizeof(dns_rdatalist_t), 369| 1.58k| RDATALIST_COUNT); ------------------ | | 129| 1.58k|#define RDATALIST_COUNT 8 ------------------ 370| 1.58k| ISC_LIST_APPEND(msg->rdatalists, msgblock, link); ------------------ | | 100| 1.58k| do { \ | | 101| 1.58k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.58k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.58k| do { \ | | | | 89| 1.58k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.58k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.58k| } else { \ | | | | 92| 1.58k| (list).head = (elt); \ | | | | 93| 1.58k| } \ | | | | 94| 1.58k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.58k| (elt)->link.next = NULL; \ | | | | 96| 1.58k| (list).tail = (elt); \ | | | | 97| 1.58k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.58k] | | | | ------------------ | | ------------------ | | 103| 1.58k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.58k] | | ------------------ ------------------ 371| | 372| 1.58k| rdatalist = msgblock_get(msgblock, dns_rdatalist_t); ------------------ | | 191| 1.58k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 373| 1.58k| } 374| 2.92k|out: 375| 2.92k| dns_rdatalist_init(rdatalist); 376| 2.92k| return rdatalist; 377| 2.92k|} message.c:dns__message_putassociatedrdataset: 2483| 2.92k|dns__message_putassociatedrdataset(dns_message_t *msg, dns_rdataset_t **item) { 2484| 2.92k| dns_rdataset_disassociate(*item); ------------------ | | 291| 2.92k| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 2485| 2.92k| dns_message_puttemprdataset(msg, item); 2486| 2.92k|} message.c:msgresetopt: 473| 1.59k|msgresetopt(dns_message_t *msg) { 474| 1.59k| if (msg->opt != NULL) { ------------------ | Branch (474:6): [True: 0, False: 1.59k] ------------------ 475| 0| if (msg->opt_reserved > 0) { ------------------ | Branch (475:7): [True: 0, False: 0] ------------------ 476| 0| dns_message_renderrelease(msg, msg->opt_reserved); 477| 0| msg->opt_reserved = 0; 478| 0| } 479| 0| dns__message_putassociatedrdataset(msg, &msg->opt); 480| | msg->opt = NULL; 481| 0| msg->cc_ok = 0; 482| 0| msg->cc_bad = 0; 483| 0| } 484| 1.59k|} message.c:msgresetsigs: 487| 1.59k|msgresetsigs(dns_message_t *msg, bool replying) { 488| 1.59k| if (msg->sig_reserved > 0) { ------------------ | Branch (488:6): [True: 0, False: 1.59k] ------------------ 489| 0| dns_message_renderrelease(msg, msg->sig_reserved); 490| 0| msg->sig_reserved = 0; 491| 0| } 492| 1.59k| if (msg->tsig != NULL) { ------------------ | Branch (492:6): [True: 575, False: 1.02k] ------------------ 493| 575| INSIST(dns_rdataset_isassociated(msg->tsig)); ------------------ | | 198| 575|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 575| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 575, False: 0] | | | | ------------------ | | | | 55| 575| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 494| 575| INSIST(msg->namepool != NULL); ------------------ | | 198| 575|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 575| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 575, False: 0] | | | | ------------------ | | | | 55| 575| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 495| 575| if (replying) { ------------------ | Branch (495:7): [True: 0, False: 575] ------------------ 496| 0| INSIST(msg->querytsig == NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 497| 0| msg->querytsig = msg->tsig; 498| 575| } else { 499| 575| dns__message_putassociatedrdataset(msg, &msg->tsig); 500| 575| if (msg->querytsig != NULL) { ------------------ | Branch (500:8): [True: 167, False: 408] ------------------ 501| 167| dns__message_putassociatedrdataset( 502| 167| msg, &msg->querytsig); 503| 167| } 504| 575| } 505| 575| dns_message_puttempname(msg, &msg->tsigname); 506| 575| msg->tsig = NULL; 507| 1.02k| } else if (msg->querytsig != NULL && !replying) { ------------------ | Branch (507:13): [True: 41, False: 980] | Branch (507:39): [True: 41, False: 0] ------------------ 508| 41| dns__message_putassociatedrdataset(msg, &msg->querytsig); 509| 41| msg->querytsig = NULL; 510| 41| } 511| 1.59k| if (msg->sig0 != NULL) { ------------------ | Branch (511:6): [True: 443, False: 1.15k] ------------------ 512| 443| dns__message_putassociatedrdataset(msg, &msg->sig0); 513| 443| msg->sig0 = NULL; 514| 443| } 515| 1.59k| if (msg->sig0name != NULL) { ------------------ | Branch (515:6): [True: 443, False: 1.15k] ------------------ 516| 443| dns_message_puttempname(msg, &msg->sig0name); 517| 443| } 518| 1.59k|} message.c:msginitprivate: 389| 1.59k|msginitprivate(dns_message_t *m) { 390| 1.59k| unsigned int i; 391| | 392| 7.98k| for (i = 0; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (392:14): [True: 6.38k, False: 1.59k] ------------------ 393| 6.38k| m->cursors[i] = NULL; 394| 6.38k| m->counts[i] = 0; 395| 6.38k| } 396| 1.59k| m->opt = NULL; 397| 1.59k| m->sig0 = NULL; 398| 1.59k| m->sig0name = NULL; 399| 1.59k| m->tsig = NULL; 400| 1.59k| m->tsigname = NULL; 401| 1.59k| m->state = DNS_SECTION_ANY; /* indicate nothing parsed or rendered */ 402| 1.59k| m->opt_reserved = 0; 403| 1.59k| m->sig_reserved = 0; 404| 1.59k| m->reserved = 0; 405| 1.59k| m->padding = 0; 406| 1.59k| m->padding_off = 0; 407| | m->buffer = NULL; 408| 1.59k|} message.c:msgresetedns: 521| 1.59k|msgresetedns(dns_message_t *msg) { 522| 1.59k| if (msg->edns.opts != NULL) { ------------------ | Branch (522:6): [True: 0, False: 1.59k] ------------------ 523| 0| INSIST(msg->edns.maxopts != 0); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 524| 0| for (size_t i = 0; i < msg->edns.count; i++) { ------------------ | Branch (524:22): [True: 0, False: 0] ------------------ 525| 0| if (msg->edns.opts[i].value != NULL) { ------------------ | Branch (525:8): [True: 0, False: 0] ------------------ 526| 0| isc_mem_put(msg->mctx, msg->edns.opts[i].value, ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 527| 0| msg->edns.opts[i].length); 528| 0| } 529| 0| } 530| | isc_mem_cput(msg->mctx, msg->edns.opts, ------------------ | | 155| 0| do { \ | | 156| 0| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 157| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 0| (p) = NULL; \ | | 159| 0| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 0] | | ------------------ ------------------ 531| 0| (size_t)msg->edns.maxopts, sizeof(dns_ednsopt_t)); 532| 0| } 533| 1.59k| msg->edns.maxopts = 0; 534| 1.59k| msg->edns.count = 0; 535| 1.59k|} dns_name_hasbuffer: 119| 209|dns_name_hasbuffer(const dns_name_t *name) { 120| | /* 121| | * Does 'name' have a dedicated buffer? 122| | */ 123| | 124| 209| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 125| | 126| 209| if (name->buffer != NULL) { ------------------ | Branch (126:6): [True: 209, False: 0] ------------------ 127| 209| return true; 128| 209| } 129| | 130| 0| return false; 131| 209|} dns_name_isabsolute: 134| 110|dns_name_isabsolute(const dns_name_t *name) { 135| | /* 136| | * Does 'name' end in the root label? 137| | */ 138| | 139| 110| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 110|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 220| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 110, False: 0] | | | | | Branch (42:11): [True: 110, False: 0] | | | | ------------------ | | | | 43| 110| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 140| | 141| 110| return name->attributes.absolute; 142| 110|} dns_name_iswildcard: 258| 6|dns_name_iswildcard(const dns_name_t *name) { 259| 6| unsigned char *ndata; 260| | 261| | /* 262| | * Is 'name' a wildcard name? 263| | */ 264| | 265| 6| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 266| 6| REQUIRE(name->length > 0); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 267| | 268| 6| if (name->length >= 2) { ------------------ | Branch (268:6): [True: 6, False: 0] ------------------ 269| 6| ndata = name->ndata; 270| 6| if (ndata[0] == 1 && ndata[1] == '*') { ------------------ | Branch (270:7): [True: 0, False: 6] | Branch (270:24): [True: 0, False: 0] ------------------ 271| 0| return true; 272| 0| } 273| 6| } 274| | 275| 6| return false; 276| 6|} dns_name_hash: 314| 623|dns_name_hash(const dns_name_t *name) { 315| 623| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 623|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 623, False: 0] | | | | | Branch (42:11): [True: 623, False: 0] | | | | ------------------ | | | | 43| 623| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 316| | 317| | return isc_hash32(name->ndata, name->length, false); 318| 623|} dns_name_fullcompare: 322| 8| int *orderp, unsigned int *nlabelsp) { 323| 8| unsigned int l1, l2, l, count1, count2, count, nlabels; 324| 8| int cdiff, ldiff, diff; 325| 8| unsigned char *label1, *label2; 326| 8| dns_offsets_t offsets1, offsets2; 327| 8| dns_namereln_t namereln = dns_namereln_none; 328| | 329| | /* 330| | * Determine the relative ordering under the DNSSEC order relation of 331| | * 'name1' and 'name2', and also determine the hierarchical 332| | * relationship of the names. 333| | * 334| | * Note: It makes no sense for one of the names to be relative and the 335| | * other absolute. If both names are relative, then to be meaningfully 336| | * compared the caller must ensure that they are both relative to the 337| | * same domain. 338| | */ 339| | 340| 8| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 341| 8| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 342| 8| REQUIRE(orderp != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 343| 8| REQUIRE(nlabelsp != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 344| | /* 345| | * Either name1 is absolute and name2 is absolute, or neither is. 346| | */ 347| 8| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 348| | 349| 8| if (name1 == name2) { ------------------ | Branch (349:6): [True: 0, False: 8] ------------------ 350| 0| *orderp = 0; 351| 0| *nlabelsp = dns_name_countlabels(name1); 352| | 353| 0| return dns_namereln_equal; 354| 0| } 355| | 356| 8| l1 = dns_name_offsets(name1, offsets1); 357| 8| l2 = dns_name_offsets(name2, offsets2); 358| | 359| 8| nlabels = 0; 360| 8| if (l2 > l1) { ------------------ | Branch (360:6): [True: 2, False: 6] ------------------ 361| 2| l = l1; 362| 2| ldiff = 0 - (l2 - l1); 363| 6| } else { 364| 6| l = l2; 365| 6| ldiff = l1 - l2; 366| 6| } 367| | 368| 22| while (l-- > 0) { ------------------ | Branch (368:9): [True: 14, False: 8] ------------------ 369| 14| l1--; 370| 14| l2--; 371| 14| label1 = &name1->ndata[offsets1[l1]]; 372| 14| label2 = &name2->ndata[offsets2[l2]]; 373| 14| count1 = *label1++; 374| 14| count2 = *label2++; 375| | 376| 14| cdiff = (int)count1 - (int)count2; 377| 14| if (cdiff < 0) { ------------------ | Branch (377:7): [True: 0, False: 14] ------------------ 378| 0| count = count1; 379| 14| } else { 380| 14| count = count2; 381| 14| } 382| | 383| 14| diff = isc_ascii_lowercmp(label1, label2, count); 384| 14| if (diff != 0) { ------------------ | Branch (384:7): [True: 0, False: 14] ------------------ 385| 0| *orderp = diff; 386| 0| goto done; 387| 0| } 388| | 389| 14| if (cdiff != 0) { ------------------ | Branch (389:7): [True: 0, False: 14] ------------------ 390| 0| *orderp = cdiff; 391| 0| goto done; 392| 0| } 393| 14| nlabels++; 394| 14| } 395| | 396| 8| *orderp = ldiff; 397| 8| if (ldiff < 0) { ------------------ | Branch (397:6): [True: 2, False: 6] ------------------ 398| 2| namereln = dns_namereln_contains; 399| 6| } else if (ldiff > 0) { ------------------ | Branch (399:13): [True: 0, False: 6] ------------------ 400| 0| namereln = dns_namereln_subdomain; 401| 6| } else { 402| 6| namereln = dns_namereln_equal; 403| 6| } 404| 8| *nlabelsp = nlabels; 405| 8| return namereln; 406| | 407| 0|done: 408| 0| *nlabelsp = nlabels; 409| 0| if (nlabels > 0) { ------------------ | Branch (409:6): [True: 0, False: 0] ------------------ 410| 0| namereln = dns_namereln_commonancestor; 411| 0| } 412| | 413| 0| return namereln; 414| 8|} dns_name_equal: 437| 4.79k|dns_name_equal(const dns_name_t *name1, const dns_name_t *name2) { 438| 4.79k| unsigned int length; 439| | 440| | /* 441| | * Are 'name1' and 'name2' equal? 442| | * 443| | * Note: It makes no sense for one of the names to be relative and the 444| | * other absolute. If both names are relative, then to be meaningfully 445| | * compared the caller must ensure that they are both relative to the 446| | * same domain. 447| | */ 448| | 449| 4.79k| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 194| 4.79k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.58k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.79k, False: 0] | | | | | Branch (42:11): [True: 4.79k, False: 0] | | | | ------------------ | | | | 43| 4.79k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 450| 4.79k| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 194| 4.79k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.58k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.79k, False: 0] | | | | | Branch (42:11): [True: 4.79k, False: 0] | | | | ------------------ | | | | 43| 4.79k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 451| | /* 452| | * Either name1 is absolute and name2 is absolute, or neither is. 453| | */ 454| 4.79k| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 194| 4.79k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.79k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.79k, False: 0] | | | | ------------------ | | | | 43| 4.79k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 455| | 456| 4.79k| if (name1 == name2) { ------------------ | Branch (456:6): [True: 0, False: 4.79k] ------------------ 457| 0| return true; 458| 0| } 459| | 460| 4.79k| length = name1->length; 461| 4.79k| if (length != name2->length) { ------------------ | Branch (461:6): [True: 3.39k, False: 1.39k] ------------------ 462| 3.39k| return false; 463| 3.39k| } 464| | 465| | /* label lengths are < 64 so tolower() does not affect them */ 466| 1.39k| return isc_ascii_lowerequal(name1->ndata, name2->ndata, length); 467| 4.79k|} dns_name_caseequal: 470| 4|dns_name_caseequal(const dns_name_t *name1, const dns_name_t *name2) { 471| | /* 472| | * Are 'name1' and 'name2' equal? 473| | * 474| | * Note: It makes no sense for one of the names to be relative and the 475| | * other absolute. If both names are relative, then to be meaningfully 476| | * compared the caller must ensure that they are both relative to the 477| | * same domain. 478| | */ 479| | 480| 4| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 481| 4| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 482| | /* 483| | * Either name1 is absolute and name2 is absolute, or neither is. 484| | */ 485| 4| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 486| | 487| 4| if (name1->length != name2->length) { ------------------ | Branch (487:6): [True: 0, False: 4] ------------------ 488| 0| return false; 489| 0| } 490| | 491| 4| if (memcmp(name1->ndata, name2->ndata, name1->length) != 0) { ------------------ | Branch (491:6): [True: 0, False: 4] ------------------ 492| 0| return false; 493| 0| } 494| | 495| 4| return true; 496| 4|} dns_name_issubdomain: 517| 8|dns_name_issubdomain(const dns_name_t *name1, const dns_name_t *name2) { 518| 8| int order; 519| 8| unsigned int nlabels; 520| 8| dns_namereln_t namereln; 521| | 522| | /* 523| | * Is 'name1' a subdomain of 'name2'? 524| | * 525| | * Note: It makes no sense for one of the names to be relative and the 526| | * other absolute. If both names are relative, then to be meaningfully 527| | * compared the caller must ensure that they are both relative to the 528| | * same domain. 529| | */ 530| | 531| 8| namereln = dns_name_fullcompare(name1, name2, &order, &nlabels); 532| 8| if (namereln == dns_namereln_subdomain || ------------------ | Branch (532:6): [True: 0, False: 8] ------------------ 533| 8| namereln == dns_namereln_equal) ------------------ | Branch (533:6): [True: 6, False: 2] ------------------ 534| 6| { 535| 6| return true; 536| 6| } 537| | 538| 2| return false; 539| 8|} dns_name_clone: 639| 1.59k|dns_name_clone(const dns_name_t *source, dns_name_t *target) { 640| | /* 641| | * Make 'target' refer to the same name as 'source'. 642| | */ 643| | 644| 1.59k| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 645| 1.59k| REQUIRE(DNS_NAME_VALID(target)); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 646| 1.59k| REQUIRE(DNS_NAME_BINDABLE(target)); ------------------ | | 194| 1.59k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | | Branch (42:11): [True: 1.59k, False: 0] | | | | ------------------ | | | | 43| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 647| | 648| 1.59k| target->ndata = source->ndata; 649| 1.59k| target->length = source->length; 650| 1.59k| target->attributes = source->attributes; 651| 1.59k| target->attributes.readonly = false; 652| | target->attributes.dynamic = false; 653| 1.59k|} dns_name_fromregion: 656| 1.28k|dns_name_fromregion(dns_name_t *name, const isc_region_t *r) { 657| 1.28k| size_t length; 658| 1.28k| isc_region_t r2 = { .base = NULL, .length = 0 }; 659| | 660| | /* 661| | * Make 'name' refer to region 'r'. 662| | */ 663| | 664| 1.28k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 665| 1.28k| REQUIRE(r != NULL); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.28k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 666| 1.28k| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 667| | 668| 1.28k| name->ndata = r->base; 669| 1.28k| if (name->buffer != NULL) { ------------------ | Branch (669:6): [True: 4, False: 1.28k] ------------------ 670| 4| isc_buffer_clear(name->buffer); 671| 4| isc_buffer_availableregion(name->buffer, &r2); 672| 4| length = (r->length < r2.length) ? r->length : r2.length; ------------------ | Branch (672:12): [True: 4, False: 0] ------------------ 673| 4| if (length > DNS_NAME_MAXWIRE) { ------------------ | | 190| 4|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (673:7): [True: 0, False: 4] ------------------ 674| 0| length = DNS_NAME_MAXWIRE; ------------------ | | 190| 0|#define DNS_NAME_MAXWIRE 255 ------------------ 675| 0| } 676| 1.28k| } else { 677| 1.28k| length = (r->length <= DNS_NAME_MAXWIRE) ? r->length ------------------ | | 190| 1.28k|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (677:12): [True: 956, False: 325] ------------------ 678| 1.28k| : DNS_NAME_MAXWIRE; ------------------ | | 190| 1.60k|#define DNS_NAME_MAXWIRE 255 ------------------ 679| 1.28k| } 680| | 681| 1.28k| name->attributes.absolute = false; 682| | 683| 1.28k| if (length > 0) { ------------------ | Branch (683:6): [True: 1.28k, False: 0] ------------------ 684| 1.28k| size_t offset = 0; 685| 1.28k| uint8_t nlabels = 0; 686| 12.1k| while (offset != length) { ------------------ | Branch (686:10): [True: 12.1k, False: 0] ------------------ 687| 12.1k| uint8_t count; 688| | 689| 12.1k| INSIST(nlabels < DNS_NAME_MAXLABELS); ------------------ | | 198| 12.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 12.1k, False: 0] | | | | ------------------ | | | | 55| 12.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 690| 12.1k| nlabels++; 691| | 692| 12.1k| count = name->ndata[offset]; 693| 12.1k| INSIST(count <= DNS_NAME_LABELLEN); ------------------ | | 198| 12.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 12.1k, False: 0] | | | | ------------------ | | | | 55| 12.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 694| | 695| 12.1k| offset += count + 1; 696| 12.1k| INSIST(offset <= length); ------------------ | | 198| 12.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 12.1k, False: 0] | | | | ------------------ | | | | 55| 12.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 697| | 698| 12.1k| if (count == 0) { ------------------ | Branch (698:8): [True: 1.28k, False: 10.8k] ------------------ 699| 1.28k| name->attributes.absolute = true; 700| 1.28k| break; 701| 1.28k| } 702| 12.1k| } 703| 1.28k| name->length = offset; 704| 1.28k| } 705| | 706| 1.28k| if (name->buffer != NULL) { ------------------ | Branch (706:6): [True: 4, False: 1.28k] ------------------ 707| | /* 708| | * name->length has been updated by set_offsets to the actual 709| | * length of the name data so we can now copy the actual name 710| | * data and not anything after it. 711| | */ 712| 4| if (name->length > 0) { ------------------ | Branch (712:7): [True: 4, False: 0] ------------------ 713| 4| memmove(r2.base, r->base, name->length); 714| 4| } 715| 4| name->ndata = r2.base; 716| 4| isc_buffer_add(name->buffer, name->length); 717| 4| } 718| 1.28k|} dns_name_fromtext: 966| 16| const dns_name_t *origin, unsigned int options) { 967| 16| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 968| 16| REQUIRE(ISC_BUFFER_VALID(name->buffer)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 969| | 970| 16| isc_buffer_clear(name->buffer); 971| 16| return convert_text(source, origin, options, name, name->buffer); 972| 16|} dns_name_totext: 976| 10| isc_buffer_t *target) { 977| 10| isc_result_t result; 978| 10| unsigned char *ndata = NULL; 979| 10| unsigned int nlen; 980| 10| unsigned int labels; 981| 10| bool saw_root = false; 982| 10| unsigned int oused; 983| 10| bool omit_final_dot = ((options & DNS_NAME_OMITFINALDOT) != 0); ------------------ | | 883| 10|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 984| 10| bool first = true; 985| | 986| | /* 987| | * This function assumes the name is in proper uncompressed 988| | * wire format. 989| | */ 990| 10| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 991| 10| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 992| | 993| 10| oused = target->used; 994| | 995| 10| ndata = name->ndata; 996| 10| nlen = name->length; 997| 10| labels = dns_name_countlabels(name); 998| | 999| 10| if (labels == 0 && nlen == 0) { ------------------ | Branch (999:6): [True: 0, False: 10] | Branch (999:21): [True: 0, False: 0] ------------------ 1000| | /* 1001| | * Special handling for an empty name. 1002| | */ 1003| 0| omit_final_dot = true; 1004| 0| CHECK(isc_buffer_reserve(target, 1)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 1005| 0| isc_buffer_putuint8(target, '@'); 1006| | 1007| | /* 1008| | * Skip the while() loop. 1009| | */ 1010| 0| nlen = 0; 1011| 10| } else if (nlen == 1 && labels == 1 && *ndata == '\0') { ------------------ | Branch (1011:13): [True: 0, False: 10] | Branch (1011:26): [True: 0, False: 0] | Branch (1011:41): [True: 0, False: 0] ------------------ 1012| | /* 1013| | * Special handling for the root label. 1014| | */ 1015| 0| saw_root = true; 1016| 0| omit_final_dot = false; 1017| | 1018| | /* 1019| | * Skip the while() loop. 1020| | */ 1021| 0| nlen = 0; 1022| 0| } 1023| | 1024| 20| while (labels > 0 && nlen > 0) { ------------------ | Branch (1024:9): [True: 20, False: 0] | Branch (1024:23): [True: 20, False: 0] ------------------ 1025| 20| unsigned int count = *ndata++; 1026| 20| labels--; 1027| 20| nlen--; 1028| 20| if (count == 0) { ------------------ | Branch (1028:7): [True: 10, False: 10] ------------------ 1029| 10| saw_root = true; 1030| 10| break; 1031| 10| } else if (!first) { ------------------ | Branch (1031:14): [True: 0, False: 10] ------------------ 1032| 0| CHECK(isc_buffer_reserve(target, 1)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 1033| 0| isc_buffer_putuint8(target, '.'); 1034| 0| } 1035| 10| first = false; 1036| | 1037| 10| if (count <= DNS_NAME_LABELLEN) { ------------------ | | 192| 10|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (1037:7): [True: 10, False: 0] ------------------ 1038| 10| unsigned char c; 1039| | 1040| 10| INSIST(nlen >= count); ------------------ | | 198| 10|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 10, False: 0] | | | | ------------------ | | | | 55| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1041| | 1042| 80| while (count > 0) { ------------------ | Branch (1042:11): [True: 70, False: 10] ------------------ 1043| 70| uint32_t value; 1044| | 1045| 70| c = *ndata; 1046| 70| switch (c) { 1047| | /* Special modifiers in zone files. */ 1048| 0| case 0x40: /* '@' */ ------------------ | Branch (1048:5): [True: 0, False: 70] ------------------ 1049| 0| case 0x24: /* '$' */ ------------------ | Branch (1049:5): [True: 0, False: 70] ------------------ 1050| 0| if ((options & DNS_NAME_PRINCIPAL) != 0) ------------------ | | 884| 0|#define DNS_NAME_PRINCIPAL 0x02U /* do not escape $ and @ */ ------------------ | Branch (1050:10): [True: 0, False: 0] ------------------ 1051| 0| { 1052| 0| goto no_escape; 1053| 0| } 1054| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 1055| 0| case 0x22: /* '"' */ ------------------ | Branch (1055:5): [True: 0, False: 70] ------------------ 1056| 0| case 0x28: /* '(' */ ------------------ | Branch (1056:5): [True: 0, False: 70] ------------------ 1057| 0| case 0x29: /* ')' */ ------------------ | Branch (1057:5): [True: 0, False: 70] ------------------ 1058| 0| case 0x2E: /* '.' */ ------------------ | Branch (1058:5): [True: 0, False: 70] ------------------ 1059| 0| case 0x3B: /* ';' */ ------------------ | Branch (1059:5): [True: 0, False: 70] ------------------ 1060| 0| case 0x5C: /* '\\' */ ------------------ | Branch (1060:5): [True: 0, False: 70] ------------------ 1061| 0| value = '\\' << 8 | c; 1062| 0| CHECK(isc_buffer_reserve(target, 2)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 1063| 0| isc_buffer_putuint16(target, value); 1064| 0| ndata++; 1065| 0| nlen--; 1066| 0| break; 1067| 0| no_escape: 1068| 70| default: ------------------ | Branch (1068:5): [True: 70, False: 0] ------------------ 1069| 70| if (c > 0x20 && c < 0x7f) { ------------------ | Branch (1069:10): [True: 70, False: 0] | Branch (1069:22): [True: 70, False: 0] ------------------ 1070| 70| CHECK(isc_buffer_reserve(target, ------------------ | | 251| 70| { \ | | 252| 70| result = (r); \ | | 253| 70| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 70] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 70| } ------------------ 1071| 70| 1)); 1072| 70| isc_buffer_putuint8(target, c); 1073| 70| ndata++; 1074| 70| nlen--; 1075| 70| } else { 1076| 0| value = 0x5c << 24; 1077| 0| value |= (0x30 + 1078| 0| ((c / 100) % 10)) 1079| 0| << 16; 1080| 0| value |= 1081| 0| (0x30 + ((c / 10) % 10)) 1082| 0| << 8; 1083| 0| value |= 0x30 + (c % 10); 1084| 0| CHECK(isc_buffer_reserve(target, ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 1085| 0| 4)); 1086| 0| isc_buffer_putuint32(target, 1087| 0| value); 1088| 0| ndata++; 1089| 0| nlen--; 1090| 0| } 1091| 70| } 1092| 70| count--; 1093| 70| } 1094| 10| } else { 1095| 0| FATAL_ERROR("Unexpected label type %02x", count); ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1096| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1097| 0| } 1098| 10| } 1099| | 1100| 10| if (saw_root && !omit_final_dot) { ------------------ | Branch (1100:6): [True: 10, False: 0] | Branch (1100:18): [True: 0, False: 10] ------------------ 1101| 0| CHECK(isc_buffer_reserve(target, 1)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 1102| 0| isc_buffer_putuint8(target, '.'); 1103| 0| } 1104| | 1105| 10| if (isc_buffer_availablelength(target) > 1) { ------------------ | | 161| 10|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1105:6): [True: 10, False: 0] ------------------ 1106| 10| uint8_t *p = isc_buffer_used(target); ------------------ | | 149| 10| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1107| 10| *p = 0; 1108| 10| } 1109| | 1110| 10| if (totext_filter_proc != NULL) { ------------------ | Branch (1110:6): [True: 0, False: 10] ------------------ 1111| 0| return (totext_filter_proc)(target, oused); 1112| 0| } 1113| | 1114| 10| return ISC_R_SUCCESS; 1115| | 1116| 0|cleanup: 1117| 0| return result; 1118| 10|} dns_name_downcase: 1236| 327|dns_name_downcase(const dns_name_t *source, dns_name_t *name) { 1237| | /* 1238| | * Downcase 'source'. 1239| | */ 1240| | 1241| 327| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 194| 327|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 654| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 327, False: 0] | | | | | Branch (42:11): [True: 327, False: 0] | | | | ------------------ | | | | 43| 327| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1242| 327| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 327|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 654| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 327, False: 0] | | | | | Branch (42:11): [True: 327, False: 0] | | | | ------------------ | | | | 43| 327| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1243| | 1244| 327| if (source == name) { ------------------ | Branch (1244:6): [True: 325, False: 2] ------------------ 1245| 325| REQUIRE(!name->attributes.readonly); ------------------ | | 194| 325|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 325| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 325, False: 0] | | | | ------------------ | | | | 43| 325| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1246| 325| isc_ascii_lowercopy(name->ndata, source->ndata, source->length); 1247| 325| return ISC_R_SUCCESS; 1248| 325| } 1249| | 1250| 2| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1251| 2| REQUIRE(ISC_BUFFER_VALID(name->buffer)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1252| | 1253| 2| isc_buffer_clear(name->buffer); 1254| 2| name->ndata = (uint8_t *)name->buffer->base + name->buffer->used; 1255| | 1256| | /* label lengths are < 64 so tolower() does not affect them */ 1257| 2| isc_ascii_lowercopy(name->ndata, source->ndata, source->length); 1258| | 1259| 2| name->length = source->length; 1260| 2| name->attributes = (struct dns_name_attrs){ 1261| 2| .absolute = source->attributes.absolute 1262| 2| }; 1263| 2| isc_buffer_add(name->buffer, name->length); 1264| | 1265| 2| return ISC_R_SUCCESS; 1266| 327|} dns_name_fromwire: 1270| 5.26k| const dns_decompress_t dctx, isc_buffer_t *target) { 1271| | /* 1272| | * Copy the name at source into target, decompressing it. 1273| | * 1274| | * *** WARNING *** 1275| | * 1276| | * dns_name_fromwire() deals with raw network data. An error in this 1277| | * routine could result in the failure or hijacking of the server. 1278| | * 1279| | * The description of name compression in RFC 1035 section 4.1.4 is 1280| | * subtle wrt certain edge cases. The first important sentence is: 1281| | * 1282| | * > In this scheme, an entire domain name or a list of labels at the 1283| | * > end of a domain name is replaced with a pointer to a prior 1284| | * > occurrence of the same name. 1285| | * 1286| | * The key word is "prior". This says that compression pointers must 1287| | * point strictly earlier in the message (before our "marker" variable), 1288| | * which is enough to prevent DoS attacks due to compression loops. 1289| | * 1290| | * The next important sentence is: 1291| | * 1292| | * > If a domain name is contained in a part of the message subject to a 1293| | * > length field (such as the RDATA section of an RR), and compression 1294| | * > is used, the length of the compressed name is used in the length 1295| | * > calculation, rather than the length of the expanded name. 1296| | * 1297| | * When decompressing, this means that the amount of the source buffer 1298| | * that we consumed (which is checked wrt the container's length field) 1299| | * is the length of the compressed name. A compressed name is defined as 1300| | * a sequence of labels ending with the root label or a compression 1301| | * pointer, that is, the segment of the name that dns_name_fromwire() 1302| | * examines first. 1303| | * 1304| | * This matters when handling names that play dirty tricks, like: 1305| | * 1306| | * +---+---+---+---+---+---+ 1307| | * | 4 | 1 |'a'|192| 0 | 0 | 1308| | * +---+---+---+---+---+---+ 1309| | * 1310| | * We start at octet 1. There is an ordinary single character label "a", 1311| | * followed by a compression pointer that refers back to octet zero. 1312| | * Here there is a label of length 4, which weirdly re-uses the octets 1313| | * we already examined as the data for the label. It is followed by the 1314| | * root label, 1315| | * 1316| | * The specification says that the compressed name ends after the first 1317| | * zero octet (after the compression pointer) not the second zero octet, 1318| | * even though the second octet is later in the message. This shows the 1319| | * correct way to set our "consumed" variable. 1320| | */ 1321| | 1322| 5.26k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 5.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.26k, False: 0] | | | | | Branch (42:11): [True: 5.26k, False: 0] | | | | ------------------ | | | | 43| 5.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1323| 5.26k| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 194| 5.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.26k, False: 0] | | | | | Branch (42:11): [True: 5.26k, False: 0] | | | | ------------------ | | | | 43| 5.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1324| 5.26k| REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) || ------------------ | | 194| 5.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 26.6k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.10k, False: 0] | | | | | Branch (42:11): [True: 5.10k, False: 0] | | | | | Branch (42:11): [True: 5.10k, False: 160] | | | | | Branch (42:11): [True: 160, False: 0] | | | | | Branch (42:11): [True: 160, False: 0] | | | | | Branch (42:11): [True: 160, False: 0] | | | | ------------------ | | | | 43| 5.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1325| 5.26k| (target == NULL && ISC_BUFFER_VALID(name->buffer))); 1326| | 1327| 5.26k| if (target == NULL && name->buffer != NULL) { ------------------ | Branch (1327:6): [True: 160, False: 5.10k] | Branch (1327:24): [True: 160, False: 0] ------------------ 1328| 160| target = name->buffer; 1329| 160| isc_buffer_clear(target); 1330| 160| } 1331| | 1332| 5.26k| uint8_t *const name_buf = isc_buffer_used(target); ------------------ | | 149| 5.26k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1333| 5.26k| const uint32_t name_max = ISC_MIN(DNS_NAME_MAXWIRE, ------------------ | | 73| 5.26k|#define ISC_MIN(a, b) ((a) < (b) ? (a) : (b)) | | ------------------ | | | Branch (73:24): [True: 5.10k, False: 160] | | ------------------ ------------------ 1334| 5.26k| isc_buffer_availablelength(target)); 1335| 5.26k| uint32_t name_len = 0; 1336| | 1337| | /* 1338| | * After chasing a compression pointer, these variables refer to the 1339| | * source buffer as follows: 1340| | * 1341| | * sb --- mr --- cr --- st --- cd --- sm 1342| | * 1343| | * sb = source_buf (const) 1344| | * mr = marker 1345| | * cr = cursor 1346| | * st = start (const) 1347| | * cd = consumed 1348| | * sm = source_max (const) 1349| | * 1350| | * The marker hops backwards for each pointer. 1351| | * The cursor steps forwards for each label. 1352| | * The amount of the source we consumed is set once. 1353| | */ 1354| 5.26k| const uint8_t *const source_buf = isc_buffer_base(source); ------------------ | | 143| 5.26k|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 1355| 5.26k| const uint8_t *const source_max = isc_buffer_used(source); ------------------ | | 149| 5.26k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1356| 5.26k| const uint8_t *const start = isc_buffer_current(source); ------------------ | | 145| 5.26k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1357| 5.26k| const uint8_t *marker = start; 1358| 5.26k| const uint8_t *cursor = start; 1359| 5.26k| const uint8_t *consumed = NULL; 1360| | 1361| | /* 1362| | * One iteration per label. 1363| | */ 1364| 40.3k| while (cursor < source_max) { ------------------ | Branch (1364:9): [True: 40.3k, False: 21] ------------------ 1365| 40.3k| const uint8_t label_len = *cursor++; 1366| 40.3k| if (label_len <= DNS_NAME_LABELLEN) { ------------------ | | 192| 40.3k|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (1366:7): [True: 39.4k, False: 918] ------------------ 1367| | /* 1368| | * Normal label: record its offset, and check bounds on 1369| | * the name length, which also ensures we don't overrun 1370| | * the offsets array. Don't touch any source bytes yet! 1371| | * The source bounds check will happen when we loop. 1372| | */ 1373| | /* and then a step to the ri-i-i-i-i-ight */ 1374| 39.4k| cursor += label_len; 1375| 39.4k| name_len += label_len + 1; 1376| 39.4k| if (name_len > name_max) { ------------------ | Branch (1376:8): [True: 8, False: 39.4k] ------------------ 1377| 8| return name_max == DNS_NAME_MAXWIRE ------------------ | | 190| 8|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (1377:12): [True: 8, False: 0] ------------------ 1378| 8| ? DNS_R_NAMETOOLONG 1379| 8| : ISC_R_NOSPACE; 1380| 39.4k| } else if (label_len == 0) { ------------------ | Branch (1380:15): [True: 5.20k, False: 34.2k] ------------------ 1381| 5.20k| goto root_label; 1382| 5.20k| } 1383| 39.4k| } else if (label_len < 192) { ------------------ | Branch (1383:14): [True: 18, False: 900] ------------------ 1384| 18| return DNS_R_BADLABELTYPE; 1385| 900| } else if (!dns_decompress_getpermitted(dctx)) { ------------------ | Branch (1385:14): [True: 2, False: 898] ------------------ 1386| 2| return DNS_R_DISALLOWED; 1387| 898| } else if (cursor < source_max) { ------------------ | Branch (1387:14): [True: 896, False: 2] ------------------ 1388| | /* 1389| | * Compression pointer. Ensure it does not loop. 1390| | * 1391| | * Copy multiple labels in one go, to make the most of 1392| | * memmove() performance. Start at the marker and finish 1393| | * just before the pointer's hi+lo bytes, before the 1394| | * cursor. Bounds were already checked. 1395| | */ 1396| 896| const uint32_t hi = label_len & 0x3F; 1397| 896| const uint32_t lo = *cursor++; 1398| 896| const uint8_t *pointer = source_buf + (256 * hi + lo); 1399| 896| if (pointer >= marker) { ------------------ | Branch (1399:8): [True: 13, False: 883] ------------------ 1400| 13| return DNS_R_BADPOINTER; 1401| 13| } 1402| 883| const uint32_t copy_len = (cursor - 2) - marker; 1403| 883| uint8_t *const dest = name_buf + name_len - copy_len; 1404| 883| memmove(dest, marker, copy_len); 1405| 883| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1405:15): [True: 191, False: 692] ------------------ 1406| | /* it's just a jump to the left */ 1407| 883| cursor = marker = pointer; 1408| 883| } 1409| 40.3k| } 1410| 21| return ISC_R_UNEXPECTEDEND; 1411| 5.20k|root_label:; 1412| | /* 1413| | * Copy labels almost like we do for compression pointers, 1414| | * from the marker up to and including the root label. 1415| | */ 1416| 5.20k| const uint32_t copy_len = cursor - marker; 1417| 5.20k| memmove(name_buf + name_len - copy_len, marker, copy_len); 1418| 5.20k| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1418:13): [True: 668, False: 4.53k] ------------------ 1419| 5.20k| isc_buffer_forward(source, consumed - start); 1420| | 1421| 5.20k| name->attributes.absolute = true; 1422| 5.20k| name->ndata = name_buf; 1423| 5.20k| name->length = name_len; 1424| 5.20k| isc_buffer_add(target, name_len); 1425| | 1426| 5.20k| return ISC_R_SUCCESS; 1427| 5.26k|} dns_name_towire: 1431| 6| isc_buffer_t *target) { 1432| 6| bool compress, multi; 1433| 6| unsigned int here; 1434| 6| unsigned int prefix_length; 1435| 6| unsigned int suffix_coff; 1436| | 1437| | /* 1438| | * Convert 'name' into wire format, compressing it as specified by the 1439| | * compression context 'cctx' (or without compressing if 'cctx' 1440| | * is NULL), and storing the result in 'target'. 1441| | */ 1442| | 1443| 6| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1444| 6| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1445| | 1446| 6| if (cctx == NULL) { ------------------ | Branch (1446:6): [True: 6, False: 0] ------------------ 1447| 6| if (isc_buffer_availablelength(target) < name->length) { ------------------ | | 161| 6|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1447:7): [True: 0, False: 6] ------------------ 1448| 0| return ISC_R_NOSPACE; 1449| 0| } 1450| 6| memmove(isc_buffer_used(target), name->ndata, name->length); ------------------ | | 149| 6| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1451| 6| isc_buffer_add(target, name->length); 1452| 6| return ISC_R_SUCCESS; 1453| 6| } 1454| | 1455| 0| compress = !name->attributes.nocompress && ------------------ | Branch (1455:13): [True: 0, False: 0] ------------------ 1456| 0| dns_compress_getpermitted(cctx); ------------------ | Branch (1456:6): [True: 0, False: 0] ------------------ 1457| 0| multi = compress && dns_compress_getmultiuse(cctx); ------------------ | Branch (1457:10): [True: 0, False: 0] | Branch (1457:22): [True: 0, False: 0] ------------------ 1458| | 1459| | /* 1460| | * Write a compression pointer directly if the caller passed us 1461| | * a pointer to this name's offset that we saved previously. 1462| | */ 1463| 0| if (multi && cctx->coff < 0x4000) { ------------------ | Branch (1463:6): [True: 0, False: 0] | Branch (1463:15): [True: 0, False: 0] ------------------ 1464| 0| if (isc_buffer_availablelength(target) < 2) { ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1464:7): [True: 0, False: 0] ------------------ 1465| 0| return ISC_R_NOSPACE; 1466| 0| } 1467| 0| isc_buffer_putuint16(target, cctx->coff | 0xc000); 1468| 0| return ISC_R_SUCCESS; 1469| 0| } 1470| | 1471| | /* 1472| | * Always add the name to the compression context; if compression 1473| | * is off, reset the return values before writing the name. 1474| | */ 1475| 0| prefix_length = name->length; 1476| 0| suffix_coff = 0; 1477| 0| dns_compress_name(cctx, target, name, &prefix_length, &suffix_coff); 1478| 0| if (!compress) { ------------------ | Branch (1478:6): [True: 0, False: 0] ------------------ 1479| 0| prefix_length = name->length; 1480| 0| suffix_coff = 0; 1481| 0| } 1482| | 1483| | /* 1484| | * Return this name's compression offset for use next time, provided 1485| | * it isn't too short for compression to help (i.e. it's the root) 1486| | */ 1487| 0| here = isc_buffer_usedlength(target); ------------------ | | 157| 0|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1488| 0| if (multi && here < 0x4000 && prefix_length > 1) { ------------------ | Branch (1488:6): [True: 0, False: 0] | Branch (1488:15): [True: 0, False: 0] | Branch (1488:32): [True: 0, False: 0] ------------------ 1489| 0| cctx->coff = (uint16_t)here; 1490| 0| } 1491| | 1492| 0| if (prefix_length > 0) { ------------------ | Branch (1492:6): [True: 0, False: 0] ------------------ 1493| 0| if (isc_buffer_availablelength(target) < prefix_length) { ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1493:7): [True: 0, False: 0] ------------------ 1494| 0| return ISC_R_NOSPACE; 1495| 0| } 1496| 0| memmove(isc_buffer_used(target), name->ndata, prefix_length); ------------------ | | 149| 0| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1497| 0| isc_buffer_add(target, prefix_length); 1498| 0| } 1499| | 1500| 0| if (suffix_coff > 0) { ------------------ | Branch (1500:6): [True: 0, False: 0] ------------------ 1501| 0| if (multi && prefix_length == 0) { ------------------ | Branch (1501:7): [True: 0, False: 0] | Branch (1501:16): [True: 0, False: 0] ------------------ 1502| 0| cctx->coff = suffix_coff; 1503| 0| } 1504| 0| if (isc_buffer_availablelength(target) < 2) { ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1504:7): [True: 0, False: 0] ------------------ 1505| 0| return ISC_R_NOSPACE; 1506| 0| } 1507| 0| isc_buffer_putuint16(target, suffix_coff | 0xc000); 1508| 0| } 1509| | 1510| 0| return ISC_R_SUCCESS; 1511| 0|} dns_name_dup: 1600| 110|dns_name_dup(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) { 1601| | /* 1602| | * Make 'target' a dynamically allocated copy of 'source'. 1603| | */ 1604| | 1605| 110| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 194| 110|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 220| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 110, False: 0] | | | | | Branch (42:11): [True: 110, False: 0] | | | | ------------------ | | | | 43| 110| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1606| 110| REQUIRE(source->length > 0); ------------------ | | 194| 110|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 110| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 110, False: 0] | | | | ------------------ | | | | 43| 110| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1607| 110| REQUIRE(DNS_NAME_VALID(target)); ------------------ | | 194| 110|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 220| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 110, False: 0] | | | | | Branch (42:11): [True: 110, False: 0] | | | | ------------------ | | | | 43| 110| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1608| 110| REQUIRE(DNS_NAME_BINDABLE(target)); ------------------ | | 194| 110|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 220| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 110, False: 0] | | | | | Branch (42:11): [True: 110, False: 0] | | | | ------------------ | | | | 43| 110| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1609| | 1610| 110| target->ndata = isc_mem_get(mctx, source->length); ------------------ | | 128| 110|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1611| | 1612| 110| memmove(target->ndata, source->ndata, source->length); 1613| | 1614| 110| target->length = source->length; 1615| | target->attributes = (struct dns_name_attrs){ .dynamic = true }; 1616| 110| target->attributes.absolute = source->attributes.absolute; 1617| 110|} dns_name_free: 1620| 96|dns_name_free(dns_name_t *name, isc_mem_t *mctx) { 1621| 96| size_t size; 1622| | 1623| | /* 1624| | * Free 'name'. 1625| | */ 1626| | 1627| 96| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 96, False: 0] | | | | | Branch (42:11): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1628| 96| REQUIRE(name->attributes.dynamic); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1629| | 1630| 96| size = name->length; 1631| | isc_mem_put(mctx, name->ndata, size); ------------------ | | 150| 96| do { \ | | 151| 96| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 96| (p) = NULL; \ | | 153| 96| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 96] | | ------------------ ------------------ 1632| 96| dns_name_invalidate(name); 1633| 96|} dns_name_dynamic: 1670| 3.18k|dns_name_dynamic(const dns_name_t *name) { 1671| 3.18k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 3.18k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.36k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.18k, False: 0] | | | | | Branch (42:11): [True: 3.18k, False: 0] | | | | ------------------ | | | | 43| 3.18k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1672| | 1673| | /* 1674| | * Returns whether there is dynamic memory associated with this name. 1675| | */ 1676| | 1677| 3.18k| return name->attributes.dynamic; 1678| 3.18k|} dns_name_fromstring: 1767| 4| isc_mem_t *mctx) { 1768| 4| isc_buffer_t buf; 1769| 4| dns_fixedname_t fn; 1770| 4| dns_name_t *name; 1771| | 1772| 4| REQUIRE(src != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1773| | 1774| 4| isc_buffer_constinit(&buf, src, strlen(src)); ------------------ | | 557| 4| do { \ | | 558| 4| union { \ | | 559| 4| void *_var; \ | | 560| 4| const void *_const; \ | | 561| 4| } _deconst; \ | | 562| 4| _deconst._const = (_d); \ | | 563| 4| isc_buffer_init((_b), _deconst._var, (_l)); \ | | 564| 4| } while (0) | | ------------------ | | | Branch (564:11): [Folded, False: 4] | | ------------------ ------------------ 1775| 4| isc_buffer_add(&buf, strlen(src)); 1776| 4| if (DNS_NAME_BINDABLE(target) && target->buffer != NULL) { ------------------ | | 129| 8| (!name->attributes.readonly && !name->attributes.dynamic) | | ------------------ | | | Branch (129:3): [True: 4, False: 0] | | | Branch (129:33): [True: 4, False: 0] | | ------------------ ------------------ | Branch (1776:35): [True: 4, False: 0] ------------------ 1777| 4| name = target; 1778| 4| } else { 1779| 0| name = dns_fixedname_initname(&fn); 1780| 0| } 1781| | 1782| 4| RETERR(dns_name_fromtext(name, &buf, origin, options)); ------------------ | | 272| 4| { \ | | 273| 4| isc_result_t _r = (x); \ | | 274| 4| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 4] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 4| } ------------------ 1783| | 1784| 4| if (name != target) { ------------------ | Branch (1784:6): [True: 0, False: 4] ------------------ 1785| 0| dns_name_dup(name, mctx, target); 1786| 0| } 1787| | 1788| 4| return ISC_R_SUCCESS; 1789| 4|} dns_name_copy: 1792| 534|dns_name_copy(const dns_name_t *source, dns_name_t *dest) { 1793| 534| isc_buffer_t *target = NULL; 1794| 534| unsigned char *ndata = NULL; 1795| | 1796| 534| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 194| 534|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.06k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 534, False: 0] | | | | | Branch (42:11): [True: 534, False: 0] | | | | ------------------ | | | | 43| 534| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1797| 534| REQUIRE(DNS_NAME_VALID(dest)); ------------------ | | 194| 534|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.06k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 534, False: 0] | | | | | Branch (42:11): [True: 534, False: 0] | | | | ------------------ | | | | 43| 534| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1798| 534| REQUIRE(DNS_NAME_BINDABLE(dest)); ------------------ | | 194| 534|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.06k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 534, False: 0] | | | | | Branch (42:11): [True: 534, False: 0] | | | | ------------------ | | | | 43| 534| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1799| | 1800| 534| target = dest->buffer; 1801| | 1802| 534| REQUIRE(target != NULL); ------------------ | | 194| 534|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 534| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 534, False: 0] | | | | ------------------ | | | | 43| 534| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1803| 534| REQUIRE(target->length >= source->length); ------------------ | | 194| 534|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 534| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 534, False: 0] | | | | ------------------ | | | | 43| 534| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1804| | 1805| 534| isc_buffer_clear(target); 1806| | 1807| 534| ndata = (unsigned char *)target->base; 1808| 534| dest->ndata = target->base; 1809| | 1810| 534| if (source->length != 0) { ------------------ | Branch (1810:6): [True: 534, False: 0] ------------------ 1811| 534| memmove(ndata, source->ndata, source->length); 1812| 534| } 1813| | 1814| 534| dest->ndata = ndata; 1815| 534| dest->length = source->length; 1816| 534| dest->attributes.absolute = source->attributes.absolute; 1817| | 1818| 534| isc_buffer_add(target, dest->length); 1819| 534|} dns_name_offsets: 2091| 1.44k|dns_name_offsets(const dns_name_t *name, dns_offsets_t offsets) { 2092| 1.44k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 1.44k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.44k, False: 0] | | | | | Branch (42:11): [True: 1.44k, False: 0] | | | | ------------------ | | | | 43| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2093| 1.44k| unsigned int offset, count, length, nlabels; 2094| 1.44k| unsigned char *ndata; 2095| | 2096| 1.44k| ndata = name->ndata; 2097| 1.44k| length = name->length; 2098| 1.44k| offset = 0; 2099| 1.44k| nlabels = 0; 2100| 16.1k| while (offset != length) { ------------------ | Branch (2100:9): [True: 16.1k, False: 0] ------------------ 2101| 16.1k| INSIST(nlabels < DNS_NAME_MAXLABELS); ------------------ | | 198| 16.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 16.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 16.1k, False: 0] | | | | ------------------ | | | | 55| 16.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2102| 16.1k| if (offsets != NULL) { ------------------ | Branch (2102:7): [True: 16.0k, False: 44] ------------------ 2103| 16.0k| offsets[nlabels] = offset; 2104| 16.0k| } 2105| 16.1k| nlabels++; 2106| 16.1k| count = *ndata; 2107| 16.1k| INSIST(count <= DNS_NAME_LABELLEN); ------------------ | | 198| 16.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 16.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 16.1k, False: 0] | | | | ------------------ | | | | 55| 16.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2108| 16.1k| offset += count + 1; 2109| 16.1k| ndata += count + 1; 2110| 16.1k| INSIST(offset <= length); ------------------ | | 198| 16.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 16.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 16.1k, False: 0] | | | | ------------------ | | | | 55| 16.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2111| 16.1k| if (count == 0) { ------------------ | Branch (2111:7): [True: 1.44k, False: 14.6k] ------------------ 2112| | /* Final root label */ 2113| 1.44k| break; 2114| 1.44k| } 2115| 16.1k| } 2116| 1.44k| INSIST(offset == name->length); ------------------ | | 198| 1.44k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.44k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.44k, False: 0] | | | | ------------------ | | | | 55| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2117| | 2118| 1.44k| return nlabels; 2119| 1.44k|} name.c:convert_text: 722| 16| unsigned int options, dns_name_t *name, isc_buffer_t *target) { 723| 16| unsigned char *ndata = NULL, *label = NULL; 724| 16| char *tdata = NULL; 725| 16| char c; 726| 16| ft_state state; 727| 16| unsigned int value = 0, count = 0; 728| 16| unsigned int n1 = 0, n2 = 0; 729| 16| unsigned int tlen, nrem, nused, digits = 0, labels, tused; 730| 16| bool done; 731| 16| bool downcase; 732| | 733| 16| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 734| 16| REQUIRE(ISC_BUFFER_VALID(source)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 735| 16| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 736| | 737| 16| downcase = ((options & DNS_NAME_DOWNCASE) != 0); ------------------ | | 134| 16|#define DNS_NAME_DOWNCASE 0x0001 ------------------ 738| | 739| 16| if (target == NULL && name->buffer != NULL) { ------------------ | Branch (739:6): [True: 0, False: 16] | Branch (739:24): [True: 0, False: 0] ------------------ 740| 0| target = name->buffer; 741| 0| isc_buffer_clear(target); 742| 0| } 743| | 744| 16| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 745| | 746| | /* 747| | * Set up the state machine. 748| | */ 749| 16| tdata = (char *)source->base + source->current; 750| 16| tlen = isc_buffer_remaininglength(source); ------------------ | | 159| 16|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 751| 16| tused = 0; 752| 16| ndata = isc_buffer_used(target); ------------------ | | 149| 16| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 753| 16| nrem = isc_buffer_availablelength(target); ------------------ | | 161| 16|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 754| 16| if (nrem > DNS_NAME_MAXWIRE) { ------------------ | | 190| 16|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (754:6): [True: 0, False: 16] ------------------ 755| 0| nrem = DNS_NAME_MAXWIRE; ------------------ | | 190| 0|#define DNS_NAME_MAXWIRE 255 ------------------ 756| 0| } 757| 16| nused = 0; 758| 16| labels = 0; 759| 16| done = false; 760| 16| state = ft_init; 761| | 762| 100| while (nrem > 0 && tlen > 0 && !done) { ------------------ | Branch (762:9): [True: 100, False: 0] | Branch (762:21): [True: 84, False: 16] | Branch (762:33): [True: 84, False: 0] ------------------ 763| 84| c = *tdata++; 764| 84| tlen--; 765| 84| tused++; 766| | 767| 84| switch (state) { 768| 16| case ft_init: ------------------ | Branch (768:3): [True: 16, False: 68] ------------------ 769| | /* 770| | * Is this the root name? 771| | */ 772| 16| if (c == '.') { ------------------ | Branch (772:8): [True: 6, False: 10] ------------------ 773| 6| if (tlen != 0) { ------------------ | Branch (773:9): [True: 0, False: 6] ------------------ 774| 0| return DNS_R_EMPTYLABEL; 775| 0| } 776| 6| labels++; 777| 6| *ndata++ = 0; 778| 6| nrem--; 779| 6| nused++; 780| 6| done = true; 781| 6| break; 782| 6| } 783| 10| if (c == '@' && tlen == 0) { ------------------ | Branch (783:8): [True: 0, False: 10] | Branch (783:20): [True: 0, False: 0] ------------------ 784| 0| state = ft_at; 785| 0| break; 786| 0| } 787| | 788| 10| FALLTHROUGH; ------------------ | | 101| 10|#define FALLTHROUGH [[fallthrough]] ------------------ 789| 10| case ft_start: ------------------ | Branch (789:3): [True: 0, False: 84] ------------------ 790| 10| label = ndata; 791| 10| ndata++; 792| 10| nrem--; 793| 10| nused++; 794| 10| count = 0; 795| 10| if (c == '\\') { ------------------ | Branch (795:8): [True: 0, False: 10] ------------------ 796| 0| state = ft_initialescape; 797| 0| break; 798| 0| } 799| 10| state = ft_ordinary; 800| 10| if (nrem == 0) { ------------------ | Branch (800:8): [True: 0, False: 10] ------------------ 801| 0| return ISC_R_NOSPACE; 802| 0| } 803| 10| FALLTHROUGH; ------------------ | | 101| 10|#define FALLTHROUGH [[fallthrough]] ------------------ 804| 78| case ft_ordinary: ------------------ | Branch (804:3): [True: 68, False: 16] ------------------ 805| 78| if (c == '.') { ------------------ | Branch (805:8): [True: 6, False: 72] ------------------ 806| 6| if (count == 0) { ------------------ | Branch (806:9): [True: 0, False: 6] ------------------ 807| 0| return DNS_R_EMPTYLABEL; 808| 0| } 809| 6| *label = count; 810| 6| labels++; 811| 6| INSIST(labels < DNS_NAME_MAXLABELS); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 812| 6| if (tlen == 0) { ------------------ | Branch (812:9): [True: 6, False: 0] ------------------ 813| 6| labels++; 814| 6| *ndata++ = 0; 815| 6| nrem--; 816| 6| nused++; 817| 6| done = true; 818| 6| } 819| 6| state = ft_start; 820| 72| } else if (c == '\\') { ------------------ | Branch (820:15): [True: 0, False: 72] ------------------ 821| 0| state = ft_escape; 822| 72| } else { 823| 72| if (count >= DNS_NAME_LABELLEN) { ------------------ | | 192| 72|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (823:9): [True: 0, False: 72] ------------------ 824| 0| return DNS_R_LABELTOOLONG; 825| 0| } 826| 72| count++; 827| 72| if (downcase) { ------------------ | Branch (827:9): [True: 0, False: 72] ------------------ 828| 0| c = isc_ascii_tolower(c); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 829| 0| } 830| 72| *ndata++ = c; 831| 72| nrem--; 832| 72| nused++; 833| 72| } 834| 78| break; 835| 78| case ft_initialescape: ------------------ | Branch (835:3): [True: 0, False: 84] ------------------ 836| 0| if (c == '[') { ------------------ | Branch (836:8): [True: 0, False: 0] ------------------ 837| | /* 838| | * This looks like a bitstring label, which 839| | * was deprecated. Intentionally drop it. 840| | */ 841| 0| return DNS_R_BADLABELTYPE; 842| 0| } 843| 0| state = ft_escape; 844| 0| POST(state); ------------------ | | 70| 0|#define POST(x) (void)(x) ------------------ 845| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 846| 0| case ft_escape: ------------------ | Branch (846:3): [True: 0, False: 84] ------------------ 847| 0| if (!isdigit((unsigned char)c)) { ------------------ | Branch (847:8): [True: 0, False: 0] ------------------ 848| 0| if (count >= DNS_NAME_LABELLEN) { ------------------ | | 192| 0|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (848:9): [True: 0, False: 0] ------------------ 849| 0| return DNS_R_LABELTOOLONG; 850| 0| } 851| 0| count++; 852| 0| if (downcase) { ------------------ | Branch (852:9): [True: 0, False: 0] ------------------ 853| 0| c = isc_ascii_tolower(c); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 854| 0| } 855| 0| *ndata++ = c; 856| 0| nrem--; 857| 0| nused++; 858| 0| state = ft_ordinary; 859| 0| break; 860| 0| } 861| 0| digits = 0; 862| 0| value = 0; 863| 0| state = ft_escdecimal; 864| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 865| 0| case ft_escdecimal: ------------------ | Branch (865:3): [True: 0, False: 84] ------------------ 866| 0| if (!isdigit((unsigned char)c)) { ------------------ | Branch (866:8): [True: 0, False: 0] ------------------ 867| 0| return DNS_R_BADESCAPE; 868| 0| } 869| 0| value = 10 * value + c - '0'; 870| 0| digits++; 871| 0| if (digits == 3) { ------------------ | Branch (871:8): [True: 0, False: 0] ------------------ 872| 0| if (value > 255) { ------------------ | Branch (872:9): [True: 0, False: 0] ------------------ 873| 0| return DNS_R_BADESCAPE; 874| 0| } 875| 0| if (count >= DNS_NAME_LABELLEN) { ------------------ | | 192| 0|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (875:9): [True: 0, False: 0] ------------------ 876| 0| return DNS_R_LABELTOOLONG; 877| 0| } 878| 0| count++; 879| 0| if (downcase) { ------------------ | Branch (879:9): [True: 0, False: 0] ------------------ 880| 0| value = isc_ascii_tolower(value); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 881| 0| } 882| 0| *ndata++ = value; 883| 0| nrem--; 884| 0| nused++; 885| 0| state = ft_ordinary; 886| 0| } 887| 0| break; 888| 0| default: ------------------ | Branch (888:3): [True: 0, False: 84] ------------------ 889| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 890| | /* Does not return. */ 891| 84| } 892| 84| } 893| | 894| 16| if (!done) { ------------------ | Branch (894:6): [True: 4, False: 12] ------------------ 895| 4| if (nrem == 0) { ------------------ | Branch (895:7): [True: 0, False: 4] ------------------ 896| 0| return ISC_R_NOSPACE; 897| 0| } 898| 4| INSIST(tlen == 0); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 899| 4| if (state != ft_ordinary && state != ft_at) { ------------------ | Branch (899:7): [True: 0, False: 4] | Branch (899:31): [True: 0, False: 0] ------------------ 900| 0| return ISC_R_UNEXPECTEDEND; 901| 0| } 902| 4| if (state == ft_ordinary) { ------------------ | Branch (902:7): [True: 4, False: 0] ------------------ 903| 4| INSIST(count != 0); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 904| 4| INSIST(label != NULL); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 905| 4| *label = count; 906| 4| labels++; 907| 4| INSIST(labels < DNS_NAME_MAXLABELS); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 908| 4| } 909| 4| if (origin != NULL) { ------------------ | Branch (909:7): [True: 4, False: 0] ------------------ 910| 4| if (nrem < origin->length) { ------------------ | Branch (910:8): [True: 0, False: 4] ------------------ 911| 0| return ISC_R_NOSPACE; 912| 0| } 913| 4| label = origin->ndata; 914| 4| n1 = origin->length; 915| 4| nrem -= n1; 916| 4| POST(nrem); ------------------ | | 70| 4|#define POST(x) (void)(x) ------------------ 917| 8| while (n1 > 0) { ------------------ | Branch (917:11): [True: 4, False: 4] ------------------ 918| 4| n2 = *label++; 919| 4| INSIST(n2 <= DNS_NAME_LABELLEN); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 920| 4| *ndata++ = n2; 921| 4| n1 -= n2 + 1; 922| 4| nused += n2 + 1; 923| 4| while (n2 > 0) { ------------------ | Branch (923:12): [True: 0, False: 4] ------------------ 924| 0| c = *label++; 925| 0| if (downcase) { ------------------ | Branch (925:10): [True: 0, False: 0] ------------------ 926| 0| c = isc_ascii_tolower(c); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 927| 0| } 928| 0| *ndata++ = c; 929| 0| n2--; 930| 0| } 931| 4| labels++; 932| 4| if (n1 > 0) { ------------------ | Branch (932:9): [True: 0, False: 4] ------------------ 933| 0| INSIST(labels < DNS_NAME_MAXLABELS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 934| 0| } 935| 4| } 936| 4| if (origin->attributes.absolute) { ------------------ | Branch (936:8): [True: 4, False: 0] ------------------ 937| 4| name->attributes.absolute = true; 938| 4| } 939| 4| } 940| 12| } else { 941| 12| name->attributes.absolute = true; 942| 12| } 943| | 944| 16| name->ndata = (unsigned char *)target->base + target->used; 945| 16| name->length = nused; 946| | 947| 16| isc_buffer_forward(source, tused); 948| 16| isc_buffer_add(target, name->length); 949| | 950| 16| return ISC_R_SUCCESS; 951| 16|} dns_nametree_create: 84| 2| dns_nametree_t **ntp) { 85| 2| dns_nametree_t *nametree = NULL; 86| | 87| 2| REQUIRE(ntp != NULL && *ntp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 88| | 89| 2| nametree = isc_mem_get(mctx, sizeof(*nametree)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 90| 2| *nametree = (dns_nametree_t){ 91| 2| .magic = NAMETREE_MAGIC, ------------------ | | 29| 2|#define NAMETREE_MAGIC ISC_MAGIC('N', 'T', 'r', 'e') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 92| 2| .type = type, 93| 2| }; 94| 2| isc_mem_attach(mctx, &nametree->mctx); 95| 2| isc_refcount_init(&nametree->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 96| | 97| 2| if (name != NULL) { ------------------ | Branch (97:6): [True: 2, False: 0] ------------------ 98| 2| strlcpy(nametree->name, name, sizeof(nametree->name)); 99| 2| } 100| | 101| 2| dns_qpmulti_create(mctx, &qpmethods, nametree, &nametree->table); 102| 2| *ntp = nametree; 103| 2|} dns_nametree_add: 147| 2| uint32_t value) { 148| 2| isc_result_t result; 149| 2| dns_qp_t *qp = NULL; 150| 2| uint32_t size, pos, mask, count = 0; 151| 2| dns_ntnode_t *old = NULL, *new = NULL; 152| | 153| 2| REQUIRE(VALID_NAMETREE(nametree)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 154| 2| REQUIRE(name != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 155| | 156| 2| dns_qpmulti_write(nametree->table, &qp); 157| | 158| 2| switch (nametree->type) { 159| 0| case DNS_NAMETREE_BOOL: ------------------ | Branch (159:2): [True: 0, False: 2] ------------------ 160| 0| new = newnode(nametree->mctx, name); 161| 0| new->set = value; 162| 0| break; 163| | 164| 2| case DNS_NAMETREE_COUNT: ------------------ | Branch (164:2): [True: 2, False: 0] ------------------ 165| 2| new = newnode(nametree->mctx, name); 166| 2| new->set = true; 167| 2| result = dns_qp_deletename(qp, name, DNS_DBNAMESPACE_NORMAL, 168| 2| (void **)&old, &count); 169| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (169:7): [True: 0, False: 2] ------------------ 170| 0| count += 1; 171| 0| } 172| 2| break; 173| | 174| 0| case DNS_NAMETREE_BITS: ------------------ | Branch (174:2): [True: 0, False: 2] ------------------ 175| 0| result = dns_qp_getname(qp, name, DNS_DBNAMESPACE_NORMAL, 176| 0| (void **)&old, NULL); 177| 0| if (result == ISC_R_SUCCESS && matchbit(old->bits, value)) { ------------------ | Branch (177:7): [True: 0, False: 0] | Branch (177:34): [True: 0, False: 0] ------------------ 178| 0| goto out; 179| 0| } 180| | 181| 0| size = pos = value / 8 + 2; 182| 0| mask = 1 << (value % 8); 183| | 184| 0| if (old != NULL && old->bits[0] > pos) { ------------------ | Branch (184:7): [True: 0, False: 0] | Branch (184:22): [True: 0, False: 0] ------------------ 185| 0| size = old->bits[0]; 186| 0| } 187| | 188| 0| new = newnode(nametree->mctx, name); 189| 0| new->bits = isc_mem_cget(nametree->mctx, size, sizeof(char)); ------------------ | | 130| 0| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 131| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 190| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (190:7): [True: 0, False: 0] ------------------ 191| 0| memmove(new->bits, old->bits, old->bits[0]); 192| 0| result = dns_qp_deletename( 193| 0| qp, name, DNS_DBNAMESPACE_NORMAL, NULL, NULL); 194| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 195| 0| } 196| | 197| 0| new->bits[pos - 1] |= mask; 198| 0| new->bits[0] = size; 199| 0| break; 200| 0| default: ------------------ | Branch (200:2): [True: 0, False: 2] ------------------ 201| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 202| 2| } 203| | 204| 2| result = dns_qp_insert(qp, new, count); 205| | /* 206| | * We detach the node here, so any dns_qp_deletename() will 207| | * destroy the node directly. 208| | */ 209| 2| dns_ntnode_detach(&new); 210| | 211| 2|out: 212| 2| dns_qp_compact(qp, DNS_QPGC_MAYBE); 213| 2| dns_qpmulti_commit(nametree->table, &qp); 214| 2| return result; 215| 2|} nametree.c:qp_attach: 311| 2| uint32_t ival ISC_ATTR_UNUSED) { 312| 2| dns_ntnode_t *ntnode = pval; 313| 2| dns_ntnode_ref(ntnode); 314| 2|} nametree.c:qp_makekey: 325| 2| uint32_t ival ISC_ATTR_UNUSED) { 326| 2| dns_ntnode_t *ntnode = pval; 327| 2| return dns_qpkey_fromname(key, &ntnode->name, DNS_DBNAMESPACE_NORMAL); 328| 2|} nametree.c:newnode: 121| 2|newnode(isc_mem_t *mctx, const dns_name_t *name) { 122| 2| dns_ntnode_t *node = isc_mem_get(mctx, sizeof(*node)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 123| 2| *node = (dns_ntnode_t){ 124| 2| .name = DNS_NAME_INITEMPTY, ------------------ | | 183| 2| { .magic = DNS_NAME_MAGIC, \ | | ------------------ | | | | 121| 2|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | | | ------------------ | | | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 184| 2| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 2| { \ | | | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 2| } | | | | ------------------ | | ------------------ | | 185| 2| .list = ISC_LIST_INITIALIZER } | | ------------------ | | | | 21| 2| { \ | | | | 22| 2| .head = NULL, \ | | | | 23| 2| .tail = NULL, \ | | | | 24| 2| } | | ------------------ ------------------ 125| 2| }; 126| 2| isc_mem_attach(mctx, &node->mctx); 127| 2| isc_refcount_init(&node->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 128| | 129| 2| dns_name_dup(name, mctx, &node->name); 130| | 131| 2| return node; 132| 2|} dns_notifyctx_init: 44| 4|dns_notifyctx_init(dns_notifyctx_t *nctx, dns_rdatatype_t type) { 45| 4| dns_notifyctx_t ctx = { 46| 4| .type = type, 47| 4| .notifytype = dns_notifytype_yes, 48| 4| .notifydelay = 5, 49| 4| .notifies = ISC_LIST_INITIALIZER, ------------------ | | 21| 4| { \ | | 22| 4| .head = NULL, \ | | 23| 4| .tail = NULL, \ | | 24| 4| } ------------------ 50| 4| }; 51| 4| isc_sockaddr_any(&ctx.notifysrc4); 52| 4| isc_sockaddr_any6(&ctx.notifysrc6); 53| | 54| 4| *nctx = ctx; 55| 4|} dst__openssl_keypair_destroy: 148| 96|dst__openssl_keypair_destroy(dst_key_t *key) { 149| 96| if (key->keydata.pkeypair.priv != key->keydata.pkeypair.pub) { ------------------ | Branch (149:6): [True: 96, False: 0] ------------------ 150| 96| EVP_PKEY_free(key->keydata.pkeypair.priv); 151| 96| } 152| 96| EVP_PKEY_free(key->keydata.pkeypair.pub); 153| 96| key->keydata.pkeypair.pub = NULL; 154| | key->keydata.pkeypair.priv = NULL; 155| 96|} dst__opensslecdsa_init: 668| 4|dst__opensslecdsa_init(dst_func_t **funcp) { 669| 4| REQUIRE(funcp != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 670| | 671| 4| if (*funcp == NULL) { ------------------ | Branch (671:6): [True: 4, False: 0] ------------------ 672| 4| *funcp = &opensslecdsa_functions; 673| 4| } 674| 4|} dst__openssleddsa_init: 644| 4|dst__openssleddsa_init(dst_func_t **funcp, unsigned char algorithm) { 645| 4| REQUIRE(funcp != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 646| | 647| 4| if (*funcp == NULL) { ------------------ | Branch (647:6): [True: 4, False: 0] ------------------ 648| 4| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (648:7): [True: 4, False: 0] ------------------ 649| 4| *funcp = &openssleddsa_functions; 650| 4| } 651| 4| } 652| 4|} openssleddsa_link.c:check_algorithm: 584| 4|check_algorithm(unsigned char algorithm) { 585| 4| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 586| 4| EVP_PKEY *pkey = NULL; 587| 4| const eddsa_alginfo_t *alginfo = NULL; 588| 4| const unsigned char *key = NULL; 589| 4| const unsigned char *sig = NULL; 590| 4| const unsigned char test[] = "test"; 591| 4| isc_result_t result = ISC_R_SUCCESS; 592| 4| size_t key_len, sig_len; 593| | 594| 4| if (evp_md_ctx == NULL) { ------------------ | Branch (594:6): [True: 0, False: 4] ------------------ 595| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 596| 0| } 597| | 598| 4| switch (algorithm) { 599| 0|#if HAVE_OPENSSL_ED448 600| 2| case DST_ALG_ED448: ------------------ | Branch (600:2): [True: 2, False: 2] ------------------ 601| 2| sig = ed448_sig; 602| 2| sig_len = sizeof(ed448_sig) - 1; 603| 2| key = ed448_pub; 604| 2| key_len = sizeof(ed448_pub) - 1; 605| 2| alginfo = openssleddsa_alg_info(algorithm); 606| 2| break; 607| 0|#endif /* HAVE_OPENSSL_ED448 */ 608| 2| case DST_ALG_ED25519: ------------------ | Branch (608:2): [True: 2, False: 2] ------------------ 609| 2| sig = ed25519_sig; 610| 2| sig_len = sizeof(ed25519_sig) - 1; 611| 2| key = ed25519_pub; 612| 2| key_len = sizeof(ed25519_pub) - 1; 613| 2| alginfo = openssleddsa_alg_info(algorithm); 614| 2| break; 615| 0| default: ------------------ | Branch (615:2): [True: 0, False: 4] ------------------ 616| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 617| 4| } 618| | 619| 4| INSIST(alginfo != NULL); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 620| 4| CHECK(raw_key_to_ossl(alginfo, 0, key, &key_len, &pkey)); ------------------ | | 251| 4| { \ | | 252| 4| result = (r); \ | | 253| 4| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 4] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 4| } ------------------ 621| | 622| | /* 623| | * Check that we can verify the signature. 624| | */ 625| 4| if (EVP_DigestVerifyInit(evp_md_ctx, NULL, NULL, NULL, pkey) != 1 || ------------------ | Branch (625:6): [True: 0, False: 4] ------------------ 626| 4| EVP_DigestVerify(evp_md_ctx, sig, sig_len, test, ------------------ | Branch (626:6): [True: 0, False: 4] ------------------ 627| 4| sizeof(test) - 1) != 1) 628| 0| { 629| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 630| 0| } 631| | 632| 4|cleanup: 633| 4| if (pkey != NULL) { ------------------ | Branch (633:6): [True: 4, False: 0] ------------------ 634| 4| EVP_PKEY_free(pkey); 635| 4| } 636| 4| if (evp_md_ctx != NULL) { ------------------ | Branch (636:6): [True: 4, False: 0] ------------------ 637| | EVP_MD_CTX_destroy(evp_md_ctx); 638| 4| } 639| 4| ERR_clear_error(); 640| 4| return result; 641| 4|} openssleddsa_link.c:openssleddsa_alg_info: 54| 4|openssleddsa_alg_info(unsigned int key_alg) { 55| 4| if (key_alg == DST_ALG_ED25519) { ------------------ | Branch (55:6): [True: 2, False: 2] ------------------ 56| 2| static const eddsa_alginfo_t ed25519_alginfo = { 57| 2| .pkey_type = EVP_PKEY_ED25519, 58| 2| .nid = NID_ED25519, 59| 2| .key_size = DNS_KEY_ED25519SIZE, ------------------ | | 74| 2|#define DNS_KEY_ED25519SIZE 32 ------------------ 60| 2| .sig_size = DNS_SIG_ED25519SIZE, ------------------ | | 75| 2|#define DNS_SIG_ED25519SIZE 64 ------------------ 61| 2| }; 62| 2| return &ed25519_alginfo; 63| 2| } 64| 2|#if HAVE_OPENSSL_ED448 65| 2| if (key_alg == DST_ALG_ED448) { ------------------ | Branch (65:6): [True: 2, False: 0] ------------------ 66| 2| static const eddsa_alginfo_t ed448_alginfo = { 67| 2| .pkey_type = EVP_PKEY_ED448, 68| 2| .nid = NID_ED448, 69| 2| .key_size = DNS_KEY_ED448SIZE, ------------------ | | 77| 2|#define DNS_KEY_ED448SIZE 57 ------------------ 70| 2| .sig_size = DNS_SIG_ED448SIZE, ------------------ | | 78| 2|#define DNS_SIG_ED448SIZE 114 ------------------ 71| 2| }; 72| 2| return &ed448_alginfo; 73| 2| } 74| 0|#endif /* HAVE_OPENSSL_ED448 */ 75| 0| return NULL; 76| 2|} openssleddsa_link.c:raw_key_to_ossl: 80| 4| const unsigned char *key, size_t *key_len, EVP_PKEY **pkey) { 81| 4| isc_result_t result; 82| 4| int pkey_type = alginfo->pkey_type; 83| 4| size_t len = alginfo->key_size; 84| | 85| 4| result = (private ? DST_R_INVALIDPRIVATEKEY : DST_R_INVALIDPUBLICKEY); ------------------ | Branch (85:12): [True: 0, False: 4] ------------------ 86| 4| if (*key_len < len) { ------------------ | Branch (86:6): [True: 0, False: 4] ------------------ 87| 0| return result; 88| 0| } 89| | 90| 4| if (private) { ------------------ | Branch (90:6): [True: 0, False: 4] ------------------ 91| 0| *pkey = EVP_PKEY_new_raw_private_key(pkey_type, NULL, key, len); 92| 4| } else { 93| 4| *pkey = EVP_PKEY_new_raw_public_key(pkey_type, NULL, key, len); 94| 4| } 95| 4| if (*pkey == NULL) { ------------------ | Branch (95:6): [True: 0, False: 4] ------------------ 96| 0| return dst__openssl_toresult(result); ------------------ | | 28| 0| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 0| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 0| __FILE__, __LINE__) ------------------ 97| 0| } 98| | 99| 4| *key_len = len; 100| 4| return ISC_R_SUCCESS; 101| 4|} dst__opensslrsa_init: 921| 12|dst__opensslrsa_init(dst_func_t **funcp, unsigned short algorithm) { 922| 12| REQUIRE(funcp != NULL); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 923| | 924| 12| if (*funcp == NULL) { ------------------ | Branch (924:6): [True: 12, False: 0] ------------------ 925| 12| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (925:7): [True: 12, False: 0] ------------------ 926| 12| *funcp = &opensslrsa_functions; 927| 12| } 928| 12| } 929| 12|} opensslrsa_link.c:check_algorithm: 861| 12|check_algorithm(unsigned short algorithm) { 862| 12| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 863| 12| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 864| 12| EVP_PKEY *pkey = NULL; 865| 12| const EVP_MD *type = NULL; 866| 12| const unsigned char *sig = NULL; 867| 12| isc_result_t result = ISC_R_SUCCESS; 868| 12| size_t len; 869| | 870| 12| switch (algorithm) { 871| 2| case DST_ALG_RSASHA1: ------------------ | Branch (871:2): [True: 2, False: 10] ------------------ 872| 4| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (872:2): [True: 2, False: 10] ------------------ 873| 4| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 874| 4| sig = sha1_sig; 875| 4| len = sizeof(sha1_sig) - 1; 876| 4| break; 877| 2| case DST_ALG_RSASHA256: ------------------ | Branch (877:2): [True: 2, False: 10] ------------------ 878| 4| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (878:2): [True: 2, False: 10] ------------------ 879| 4| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 880| 4| sig = sha256_sig; 881| 4| len = sizeof(sha256_sig) - 1; 882| 4| break; 883| 2| case DST_ALG_RSASHA512: ------------------ | Branch (883:2): [True: 2, False: 10] ------------------ 884| 4| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (884:2): [True: 2, False: 10] ------------------ 885| 4| type = isc__crypto_md[ISC_MD_SHA512]; 886| 4| sig = sha512_sig; 887| 4| len = sizeof(sha512_sig) - 1; 888| 4| break; 889| 0| default: ------------------ | Branch (889:2): [True: 0, False: 12] ------------------ 890| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 891| 12| } 892| | 893| | /* 894| | * Construct pkey. 895| | */ 896| 12| c.e = BN_bin2bn(e_bytes, sizeof(e_bytes) - 1, NULL); 897| 12| c.n = BN_bin2bn(n_bytes, sizeof(n_bytes) - 1, NULL); 898| | 899| 12| result = isc_ossl_wrap_load_rsa_public_from_components(&c, &pkey); 900| 12| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 12|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 12, False: 0] | | | | ------------------ | | | | 55| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 901| | 902| | /* 903| | * Check that we can verify the signature. 904| | */ 905| 12| if (EVP_DigestInit_ex(evp_md_ctx, type, NULL) != 1 || ------------------ | Branch (905:6): [True: 0, False: 12] ------------------ 906| 12| EVP_DigestUpdate(evp_md_ctx, "test", 4) != 1 || ------------------ | Branch (906:6): [True: 0, False: 12] ------------------ 907| 12| EVP_VerifyFinal(evp_md_ctx, sig, len, pkey) != 1) ------------------ | Branch (907:6): [True: 0, False: 12] ------------------ 908| 0| { 909| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 910| 0| } 911| | 912| 12|cleanup: 913| 12| isc_ossl_wrap_rsa_components_cleanup(&c); 914| 12| EVP_PKEY_free(pkey); 915| | EVP_MD_CTX_destroy(evp_md_ctx); 916| 12| ERR_clear_error(); 917| 12| return result; 918| 12|} opensslrsa_link.c:opensslrsa_createctx: 63| 19|opensslrsa_createctx(dst_key_t *key, dst_context_t *dctx) { 64| 19| EVP_MD_CTX *evp_md_ctx; 65| 19| const EVP_MD *type = NULL; 66| | 67| 19| UNUSED(key); ------------------ | | 65| 19|#define UNUSED(x) (void)(x) ------------------ 68| 19| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 194| 19|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 19, False: 0] | | | | | Branch (42:11): [True: 19, False: 0] | | | | ------------------ | | | | 43| 19| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 69| 19| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 194| 19|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 19| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 19, False: 0] | | | | ------------------ | | | | 43| 19| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 70| | 71| | /* 72| | * Reject incorrect RSA key lengths. 73| | */ 74| 19| switch (dctx->key->key_alg) { 75| 0| case DST_ALG_RSASHA1: ------------------ | Branch (75:2): [True: 0, False: 19] ------------------ 76| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (76:2): [True: 0, False: 19] ------------------ 77| | /* From RFC 3110 */ 78| 0| if (dctx->key->key_size > 4096) { ------------------ | Branch (78:7): [True: 0, False: 0] ------------------ 79| 0| return ISC_R_FAILURE; 80| 0| } 81| 0| break; 82| 19| case DST_ALG_RSASHA256: ------------------ | Branch (82:2): [True: 19, False: 0] ------------------ 83| 19| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (83:2): [True: 0, False: 19] ------------------ 84| | /* From RFC 5702 */ 85| 19| if (dctx->key->key_size < 512 || dctx->key->key_size > 4096) { ------------------ | Branch (85:7): [True: 0, False: 19] | Branch (85:36): [True: 0, False: 19] ------------------ 86| 0| return ISC_R_FAILURE; 87| 0| } 88| 19| break; 89| 19| case DST_ALG_RSASHA512: ------------------ | Branch (89:2): [True: 0, False: 19] ------------------ 90| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (90:2): [True: 0, False: 19] ------------------ 91| | /* From RFC 5702 */ 92| 0| if (dctx->key->key_size < 1024 || dctx->key->key_size > 4096) { ------------------ | Branch (92:7): [True: 0, False: 0] | Branch (92:37): [True: 0, False: 0] ------------------ 93| 0| return ISC_R_FAILURE; 94| 0| } 95| 0| break; 96| 0| default: ------------------ | Branch (96:2): [True: 0, False: 19] ------------------ 97| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 98| 19| } 99| | 100| 19| evp_md_ctx = EVP_MD_CTX_create(); 101| 19| if (evp_md_ctx == NULL) { ------------------ | Branch (101:6): [True: 0, False: 19] ------------------ 102| 0| return dst__openssl_toresult(ISC_R_NOMEMORY); ------------------ | | 28| 0| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 0| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 0| __FILE__, __LINE__) ------------------ 103| 0| } 104| | 105| 19| switch (dctx->key->key_alg) { 106| 0| case DST_ALG_RSASHA1: ------------------ | Branch (106:2): [True: 0, False: 19] ------------------ 107| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (107:2): [True: 0, False: 19] ------------------ 108| 0| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 109| 0| break; 110| 19| case DST_ALG_RSASHA256: ------------------ | Branch (110:2): [True: 19, False: 0] ------------------ 111| 19| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (111:2): [True: 0, False: 19] ------------------ 112| 19| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 113| 19| break; 114| 0| case DST_ALG_RSASHA512: ------------------ | Branch (114:2): [True: 0, False: 19] ------------------ 115| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (115:2): [True: 0, False: 19] ------------------ 116| 0| type = isc__crypto_md[ISC_MD_SHA512]; 117| 0| break; 118| 0| default: ------------------ | Branch (118:2): [True: 0, False: 19] ------------------ 119| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 120| 19| } 121| | 122| 19| if (!EVP_DigestInit_ex(evp_md_ctx, type, NULL)) { ------------------ | Branch (122:6): [True: 0, False: 19] ------------------ 123| 0| EVP_MD_CTX_destroy(evp_md_ctx); 124| 0| return dst__openssl_toresult3( ------------------ | | 36| 0| isc__ossl_wrap_logged_toresult(category, DNS_LOGMODULE_CRYPTO, \ | | 37| 0| funcname, fallback, __FILE__, __LINE__) ------------------ 125| 0| dctx->category, "EVP_DigestInit_ex", ISC_R_FAILURE); 126| 0| } 127| 19| dctx->ctxdata.evp_md_ctx = evp_md_ctx; 128| | 129| 19| return ISC_R_SUCCESS; 130| 19|} opensslrsa_link.c:opensslrsa_valid_key_alg: 48| 210|opensslrsa_valid_key_alg(unsigned int key_alg) { 49| 210| switch (key_alg) { 50| 0| case DST_ALG_RSASHA1: ------------------ | Branch (50:2): [True: 0, False: 210] ------------------ 51| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (51:2): [True: 0, False: 210] ------------------ 52| 210| case DST_ALG_RSASHA256: ------------------ | Branch (52:2): [True: 210, False: 0] ------------------ 53| 210| case DST_ALG_RSASHA512: ------------------ | Branch (53:2): [True: 0, False: 210] ------------------ 54| 210| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (54:2): [True: 0, False: 210] ------------------ 55| 210| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (55:2): [True: 0, False: 210] ------------------ 56| 210| return true; 57| 0| default: ------------------ | Branch (57:2): [True: 0, False: 210] ------------------ 58| | return false; 59| 210| } 60| 210|} opensslrsa_link.c:opensslrsa_destroyctx: 133| 19|opensslrsa_destroyctx(dst_context_t *dctx) { 134| 19| EVP_MD_CTX *evp_md_ctx = NULL; 135| | 136| 19| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 194| 19|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 19, False: 0] | | | | | Branch (42:11): [True: 19, False: 0] | | | | ------------------ | | | | 43| 19| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 137| 19| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 194| 19|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 19| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 19, False: 0] | | | | ------------------ | | | | 43| 19| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 138| | 139| 19| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 140| | 141| 19| if (evp_md_ctx != NULL) { ------------------ | Branch (141:6): [True: 19, False: 0] ------------------ 142| 19| EVP_MD_CTX_destroy(evp_md_ctx); 143| | dctx->ctxdata.evp_md_ctx = NULL; 144| 19| } 145| 19|} opensslrsa_link.c:opensslrsa_adddata: 148| 57|opensslrsa_adddata(dst_context_t *dctx, const isc_region_t *data) { 149| 57| EVP_MD_CTX *evp_md_ctx = NULL; 150| | 151| 57| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 194| 57|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 114| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 57, False: 0] | | | | | Branch (42:11): [True: 57, False: 0] | | | | ------------------ | | | | 43| 57| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 152| 57| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 194| 57|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 57| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 57, False: 0] | | | | ------------------ | | | | 43| 57| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 153| | 154| 57| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 155| | 156| 57| if (!EVP_DigestUpdate(evp_md_ctx, data->base, data->length)) { ------------------ | Branch (156:6): [True: 0, False: 57] ------------------ 157| 0| return dst__openssl_toresult3( ------------------ | | 36| 0| isc__ossl_wrap_logged_toresult(category, DNS_LOGMODULE_CRYPTO, \ | | 37| 0| funcname, fallback, __FILE__, __LINE__) ------------------ 158| 0| dctx->category, "EVP_DigestUpdate", ISC_R_FAILURE); 159| 0| } 160| 57| return ISC_R_SUCCESS; 161| 57|} opensslrsa_link.c:opensslrsa_verify: 221| 19|opensslrsa_verify(dst_context_t *dctx, const isc_region_t *sig) { 222| 19| dst_key_t *key = NULL; 223| 19| int status = 0; 224| 19| EVP_MD_CTX *evp_md_ctx = NULL; 225| 19| EVP_PKEY *pkey = NULL; 226| 19| const unsigned char *base = sig->base; 227| 19| unsigned int length = sig->length; 228| | 229| 19| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 194| 19|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 19, False: 0] | | | | | Branch (42:11): [True: 19, False: 0] | | | | ------------------ | | | | 43| 19| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 230| 19| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 194| 19|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 19| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 19, False: 0] | | | | ------------------ | | | | 43| 19| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 231| | 232| 19| key = dctx->key; 233| 19| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 234| 19| pkey = key->keydata.pkeypair.pub; 235| | 236| 19| if (!isc_ossl_wrap_rsa_key_bits_leq(pkey, OPENSSLRSA_MAX_MODULUS_BITS)) ------------------ | | 36| 19|#define OPENSSLRSA_MAX_MODULUS_BITS 4096 ------------------ | Branch (236:6): [True: 0, False: 19] ------------------ 237| 0| { 238| 0| return DST_R_VERIFYFAILURE; 239| 0| } 240| | 241| | /* 242| | * Check identifying OID in front of public key material. 243| | */ 244| 19| switch (key->key_alg) { ------------------ | Branch (244:10): [True: 0, False: 19] ------------------ 245| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (245:2): [True: 0, False: 19] ------------------ 246| 0| if (length < sizeof(oid_rsasha256) || ------------------ | Branch (246:7): [True: 0, False: 0] ------------------ 247| 0| memcmp(base, oid_rsasha256, sizeof(oid_rsasha256)) != 0) ------------------ | Branch (247:7): [True: 0, False: 0] ------------------ 248| 0| { 249| 0| return DST_R_VERIFYFAILURE; 250| 0| } 251| 0| base += sizeof(oid_rsasha256); 252| 0| length -= sizeof(oid_rsasha256); 253| 0| break; 254| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (254:2): [True: 0, False: 19] ------------------ 255| 0| if (length < sizeof(oid_rsasha512) || ------------------ | Branch (255:7): [True: 0, False: 0] ------------------ 256| 0| memcmp(base, oid_rsasha512, sizeof(oid_rsasha512)) != 0) ------------------ | Branch (256:7): [True: 0, False: 0] ------------------ 257| 0| { 258| 0| return DST_R_VERIFYFAILURE; 259| 0| } 260| 0| base += sizeof(oid_rsasha512); 261| 0| length -= sizeof(oid_rsasha512); 262| 0| break; 263| 19| } 264| | 265| 19| status = EVP_VerifyFinal(evp_md_ctx, base, length, pkey); 266| 19| switch (status) { 267| 1| case 1: ------------------ | Branch (267:2): [True: 1, False: 18] ------------------ 268| 1| return ISC_R_SUCCESS; 269| 18| case 0: ------------------ | Branch (269:2): [True: 18, False: 1] ------------------ 270| 18| return dst__openssl_toresult(DST_R_VERIFYFAILURE); ------------------ | | 28| 18| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 18| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 18| __FILE__, __LINE__) ------------------ 271| 0| default: ------------------ | Branch (271:2): [True: 0, False: 19] ------------------ 272| 0| return dst__openssl_toresult3(dctx->category, "EVP_VerifyFinal", ------------------ | | 36| 0| isc__ossl_wrap_logged_toresult(category, DNS_LOGMODULE_CRYPTO, \ | | 37| 0| funcname, fallback, __FILE__, __LINE__) ------------------ 273| 19| DST_R_VERIFYFAILURE); 274| 19| } 275| 19|} opensslrsa_link.c:opensslrsa_fromdns: 401| 96|opensslrsa_fromdns(dst_key_t *key, isc_buffer_t *data) { 402| 96| isc_result_t result; 403| 96| isc_region_t r; 404| 96| unsigned int e_bytes; 405| 96| unsigned int length; 406| 96| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 407| | 408| 96| REQUIRE(opensslrsa_valid_key_alg(key->key_alg)); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 409| | 410| 96| isc_buffer_remainingregion(data, &r); 411| 96| if (r.length == 0) { ------------------ | Branch (411:6): [True: 0, False: 96] ------------------ 412| 0| CLEANUP(ISC_R_SUCCESS); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 413| 0| } 414| | 415| | /* 416| | * Check identifying OID in front of public key material. 417| | */ 418| 96| switch (key->key_alg) { ------------------ | Branch (418:10): [True: 0, False: 96] ------------------ 419| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (419:2): [True: 0, False: 96] ------------------ 420| 0| if (r.length < sizeof(oid_rsasha256) || ------------------ | Branch (420:7): [True: 0, False: 0] ------------------ 421| 0| memcmp(r.base, oid_rsasha256, sizeof(oid_rsasha256)) != 0) ------------------ | Branch (421:7): [True: 0, False: 0] ------------------ 422| 0| { 423| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 424| 0| } 425| 0| isc_region_consume(&r, sizeof(oid_rsasha256)); ------------------ | | 50| 0| do { \ | | 51| 0| isc_region_t *_r = (r); \ | | 52| 0| unsigned int _l = (l); \ | | 53| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 0| _r->base += _l; \ | | 55| 0| _r->length -= _l; \ | | 56| 0| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 0] | | ------------------ ------------------ 426| 0| isc_buffer_forward(data, sizeof(oid_rsasha256)); 427| 0| break; 428| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (428:2): [True: 0, False: 96] ------------------ 429| 0| if (r.length < sizeof(oid_rsasha512) || ------------------ | Branch (429:7): [True: 0, False: 0] ------------------ 430| 0| memcmp(r.base, oid_rsasha512, sizeof(oid_rsasha512)) != 0) ------------------ | Branch (430:7): [True: 0, False: 0] ------------------ 431| 0| { 432| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 433| 0| } 434| 0| isc_region_consume(&r, sizeof(oid_rsasha512)); ------------------ | | 50| 0| do { \ | | 51| 0| isc_region_t *_r = (r); \ | | 52| 0| unsigned int _l = (l); \ | | 53| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 0| _r->base += _l; \ | | 55| 0| _r->length -= _l; \ | | 56| 0| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 0] | | ------------------ ------------------ 435| 0| isc_buffer_forward(data, sizeof(oid_rsasha512)); 436| 0| break; 437| 96| } 438| | 439| 96| length = r.length; 440| 96| if (r.length < 1) { ------------------ | Branch (440:6): [True: 0, False: 96] ------------------ 441| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 442| 0| } 443| | 444| 96| e_bytes = *r.base; 445| 96| isc_region_consume(&r, 1); ------------------ | | 50| 96| do { \ | | 51| 96| isc_region_t *_r = (r); \ | | 52| 96| unsigned int _l = (l); \ | | 53| 96| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 96| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 96, False: 0] | | | | | | ------------------ | | | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 96| _r->base += _l; \ | | 55| 96| _r->length -= _l; \ | | 56| 96| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 96] | | ------------------ ------------------ 446| | 447| 96| if (e_bytes == 0) { ------------------ | Branch (447:6): [True: 0, False: 96] ------------------ 448| 0| if (r.length < 2) { ------------------ | Branch (448:7): [True: 0, False: 0] ------------------ 449| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 450| 0| } 451| 0| e_bytes = (*r.base) << 8; 452| 0| isc_region_consume(&r, 1); ------------------ | | 50| 0| do { \ | | 51| 0| isc_region_t *_r = (r); \ | | 52| 0| unsigned int _l = (l); \ | | 53| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 0| _r->base += _l; \ | | 55| 0| _r->length -= _l; \ | | 56| 0| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 0] | | ------------------ ------------------ 453| 0| e_bytes += *r.base; 454| 0| isc_region_consume(&r, 1); ------------------ | | 50| 0| do { \ | | 51| 0| isc_region_t *_r = (r); \ | | 52| 0| unsigned int _l = (l); \ | | 53| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 0| _r->base += _l; \ | | 55| 0| _r->length -= _l; \ | | 56| 0| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 0] | | ------------------ ------------------ 455| 0| } 456| | 457| 96| if (r.length < e_bytes) { ------------------ | Branch (457:6): [True: 0, False: 96] ------------------ 458| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 459| 0| } 460| 96| c.e = BN_bin2bn(r.base, e_bytes, NULL); 461| 96| isc_region_consume(&r, e_bytes); ------------------ | | 50| 96| do { \ | | 51| 96| isc_region_t *_r = (r); \ | | 52| 96| unsigned int _l = (l); \ | | 53| 96| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 96|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 96| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 96, False: 0] | | | | | | ------------------ | | | | | | 55| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 96| _r->base += _l; \ | | 55| 96| _r->length -= _l; \ | | 56| 96| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 96] | | ------------------ ------------------ 462| 96| c.n = BN_bin2bn(r.base, r.length, NULL); 463| 96| if (c.e == NULL || c.n == NULL) { ------------------ | Branch (463:6): [True: 0, False: 96] | Branch (463:21): [True: 0, False: 96] ------------------ 464| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 465| 0| } 466| 96| if (BN_num_bits(c.e) > RSA_MAX_PUBEXP_BITS) { ------------------ | | 28| 96|#define RSA_MAX_PUBEXP_BITS 35 ------------------ | Branch (466:6): [True: 0, False: 96] ------------------ 467| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 468| 0| } 469| 96| if (BN_num_bits(c.n) < OPENSSLRSA_MIN_MODULUS_BITS) { ------------------ | | 37| 96|#define OPENSSLRSA_MIN_MODULUS_BITS 512 ------------------ | Branch (469:6): [True: 0, False: 96] ------------------ 470| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 471| 0| } 472| 96| isc_buffer_forward(data, length); 473| | 474| 96| key->key_size = BN_num_bits(c.n); 475| 96| result = isc_ossl_wrap_load_rsa_public_from_components( 476| 96| &c, &key->keydata.pkeypair.pub); 477| | 478| 96|cleanup: 479| 96| isc_ossl_wrap_rsa_components_cleanup(&c); 480| 96| return result; 481| 96|} dns_order_create: 50| 2|dns_order_create(isc_mem_t *mctx, dns_order_t **orderp) { 51| 2| dns_order_t *order = NULL; 52| | 53| 2| REQUIRE(orderp != NULL && *orderp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 54| | 55| 2| order = isc_mem_get(mctx, sizeof(*order)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 56| 2| *order = (dns_order_t){ 57| 2| .ents = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 58| 2| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 59| 2| .magic = DNS_ORDER_MAGIC, ------------------ | | 46| 2|#define DNS_ORDER_MAGIC ISC_MAGIC('O', 'r', 'd', 'r') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 60| 2| }; 61| | 62| 2| isc_mem_attach(mctx, &order->mctx); 63| 2| *orderp = order; 64| 2|} dns_peerlist_new: 116| 2|dns_peerlist_new(isc_mem_t *mem, dns_peerlist_t **list) { 117| 2| dns_peerlist_t *l; 118| | 119| 2| REQUIRE(list != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 120| | 121| 2| l = isc_mem_get(mem, sizeof(*l)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 122| | 123| 2| ISC_LIST_INIT(l->elements); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 124| 2| l->mem = mem; 125| 2| isc_refcount_init(&l->refs, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 126| 2| l->magic = DNS_PEERLIST_MAGIC; ------------------ | | 38| 2|#define DNS_PEERLIST_MAGIC ISC_MAGIC('s', 'e', 'R', 'L') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 127| | 128| 2| *list = l; 129| 2|} dns__qp_initialize: 180| 2|dns__qp_initialize(void) { 181| | /* zero common character marker not a valid shift position */ 182| 2| INSIST(0 < SHIFT_BITMAP); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, Folded] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 183| | /* first bit is common byte or escape byte */ 184| 2| dns_qpshift_t bit_one = SHIFT_BITMAP; 185| | /* second bit is position in escaped range */ 186| 2| dns_qpshift_t bit_two = SHIFT_BITMAP; 187| 2| bool escaping = true; 188| | 189| 514| for (unsigned int byte = 0; byte < BYTE_VALUES; byte++) { ------------------ | | 132| 514|#define BYTE_VALUES (UINT8_MAX + 1) ------------------ | Branch (189:30): [True: 512, False: 2] ------------------ 190| 512| if (qp_common_character(byte)) { ------------------ | Branch (190:7): [True: 82, False: 430] ------------------ 191| 82| escaping = false; 192| 82| bit_one++; 193| 82| dns_qp_byte_for_bit[bit_one] = byte; 194| 82| dns_qp_bits_for_byte[byte] = bit_one; 195| 430| } else if ('A' <= byte && byte <= 'Z') { ------------------ | Branch (195:14): [True: 326, False: 104] | Branch (195:29): [True: 52, False: 274] ------------------ 196| | /* map upper case to lower case */ 197| 52| dns_qpshift_t after_esc = bit_one + 1; 198| 52| dns_qpshift_t skip_punct = 'a' - '_'; 199| 52| dns_qpshift_t letter = byte - 'A'; 200| 52| dns_qpshift_t bit = after_esc + skip_punct + letter; 201| 52| dns_qp_bits_for_byte[byte] = bit; 202| | /* to simplify reverse conversion */ 203| 52| bit_two++; 204| 378| } else { 205| | /* non-hostname characters need to be escaped */ 206| 378| if (!escaping || bit_two >= SHIFT_OFFSET) { ------------------ | Branch (206:8): [True: 4, False: 374] | Branch (206:21): [True: 4, False: 370] ------------------ 207| 8| escaping = true; 208| 8| bit_one++; 209| 8| dns_qp_byte_for_bit[bit_one] = byte; 210| 8| bit_two = SHIFT_BITMAP; 211| 8| } 212| 378| dns_qp_bits_for_byte[byte] = bit_two << 8 | bit_one; 213| 378| bit_two++; 214| 378| } 215| 512| } 216| 2| ENSURE(bit_one < SHIFT_OFFSET); ------------------ | | 196| 2|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 2, False: 0] | | | | ------------------ | | | | 49| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 217| 2|} dns_qpkey_fromname: 243| 1.41k| dns_namespace_t space) { 244| 1.41k| REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.82k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.41k, False: 0] | | | | | Branch (42:11): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 245| | 246| 1.41k| dns_offsets_t offsets; 247| 1.41k| size_t labels = dns_name_offsets(name, offsets); 248| 1.41k| size_t len = 0; 249| | 250| | /* namespace */ 251| 1.41k| key[len++] = ENCODE_NAMESPACE(space); ------------------ | | 124| 1.41k|#define ENCODE_NAMESPACE(c) dns_qp_bits_for_byte[(c) + (uint8_t)'0'] ------------------ 252| | /* name */ 253| 1.41k| if (labels == 0) { ------------------ | Branch (253:6): [True: 0, False: 1.41k] ------------------ 254| 0| key[len] = SHIFT_NOBYTE; 255| 0| return len; 256| 0| } 257| | 258| 1.41k| size_t label = labels; 259| 17.4k| while (label-- > 0) { ------------------ | Branch (259:9): [True: 16.0k, False: 1.41k] ------------------ 260| 16.0k| const uint8_t *ldata = name->ndata + offsets[label]; 261| 16.0k| size_t label_len = *ldata++; 262| 55.3k| while (label_len-- > 0) { ------------------ | Branch (262:10): [True: 39.3k, False: 16.0k] ------------------ 263| 39.3k| uint16_t bits = dns_qp_bits_for_byte[*ldata++]; 264| 39.3k| key[len++] = bits & 0xFF; /* bit_one */ 265| 39.3k| if ((bits >> 8) != 0) { /* escape? */ ------------------ | Branch (265:8): [True: 28.4k, False: 10.8k] ------------------ 266| 28.4k| key[len++] = bits >> 8; /* bit_two */ 267| 28.4k| } 268| 39.3k| } 269| | /* label terminator */ 270| 16.0k| key[len++] = SHIFT_NOBYTE; 271| 16.0k| } 272| | /* mark end with a double NOBYTE */ 273| 1.41k| key[len] = SHIFT_NOBYTE; 274| 1.41k| ENSURE(len < sizeof(dns_qpkey_t)); ------------------ | | 196| 1.41k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 49| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 275| 1.41k| return len; 276| 1.41k|} dns_qp_compact: 1020| 6|dns_qp_compact(dns_qp_t *qp, dns_qpgc_t mode) { 1021| 6| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1022| 6| if (mode == DNS_QPGC_MAYBE && !QP_NEEDGC(qp)) { ------------------ | | 195| 6|#define QP_NEEDGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count) | | ------------------ | | | | 193| 6| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 159| 6|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 148| 6|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (193:3): [True: 0, False: 6] | | | | | Branch (193:33): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (1022:6): [True: 6, False: 0] ------------------ 1023| 6| return; 1024| 6| } 1025| 0| if (mode == DNS_QPGC_ALL) { ------------------ | Branch (1025:6): [True: 0, False: 0] ------------------ 1026| 0| alloc_reset(qp); 1027| | qp->compact_all = true; 1028| 0| } 1029| 0| compact(qp); 1030| 0| recycle(qp); 1031| 0|} dns_qp_memusage: 1084| 2|dns_qp_memusage(dns_qp_t *qp) { 1085| 2| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1086| | 1087| 2| dns_qp_memusage_t memusage = { 1088| 2| .uctx = qp->uctx, 1089| 2| .leaves = qp->leaf_count, 1090| 2| .live = qp->used_count - qp->free_count, 1091| 2| .used = qp->used_count, 1092| 2| .hold = qp->hold_count, 1093| 2| .free = qp->free_count, 1094| 2| .node_size = sizeof(dns_qpnode_t), 1095| 2| .fragmented = QP_NEEDGC(qp), ------------------ | | 195| 2|#define QP_NEEDGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count) | | ------------------ | | | | 193| 2| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 159| 2|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 148| 2|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (193:3): [True: 0, False: 2] | | | | | Branch (193:33): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1096| 2| }; 1097| | 1098| 2| size_t chunk_usage_bytes = 0; 1099| 6| for (dns_qpchunk_t chunk = 0; chunk < qp->chunk_max; chunk++) { ------------------ | Branch (1099:32): [True: 4, False: 2] ------------------ 1100| 4| if (qp->base->ptr[chunk] != NULL) { ------------------ | Branch (1100:7): [True: 2, False: 2] ------------------ 1101| 2| chunk_usage_bytes += qp->usage[chunk].capacity; 1102| 2| memusage.chunk_count += 1; 1103| 2| } 1104| 4| } 1105| | 1106| | /* 1107| | * XXXFANF does not subtract chunks that have been shrunk, 1108| | * and does not count unreclaimed dns_qpbase_t objects 1109| | */ 1110| 2| memusage.bytes = chunk_usage_bytes + 1111| 2| qp->chunk_max * sizeof(qp->base->ptr[0]) + 1112| 2| qp->chunk_max * sizeof(qp->usage[0]); 1113| | 1114| 2| return memusage; 1115| 2|} dns_qpmulti_memusage: 1118| 2|dns_qpmulti_memusage(dns_qpmulti_t *multi) { 1119| 2| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1120| 2| LOCK(&multi->mutex); ------------------ | | 26| 2| { \ | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 2| __FILE__, __LINE__)); \ | | 29| 2| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 2| { \ | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 2| } | | | | ------------------ | | ------------------ | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 2| __FILE__, __LINE__)); \ | | 32| 2| } ------------------ 1121| | 1122| 2| dns_qp_t *qp = &multi->writer; 1123| 2| INSIST(QP_VALID(qp)); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 2, False: 0] | | | | | Branch (54:11): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1124| | 1125| 2| dns_qp_memusage_t memusage = dns_qp_memusage(qp); 1126| | 1127| 2| if (qp->transaction_mode == QP_UPDATE && qp->usage != NULL) { ------------------ | Branch (1127:6): [True: 0, False: 2] | Branch (1127:43): [True: 0, False: 0] ------------------ 1128| 0| memusage.bytes -= qp->usage[qp->bump].capacity; 1129| 0| memusage.bytes += qp->usage[qp->bump].used * 1130| 0| sizeof(dns_qpnode_t); 1131| 0| } 1132| | 1133| 2| UNLOCK(&multi->mutex); ------------------ | | 34| 2| { \ | | 35| 2| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 2| { \ | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 2| } | | | | ------------------ | | ------------------ | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 2| __FILE__, __LINE__)); \ | | 38| 2| } ------------------ 1134| 2| return memusage; 1135| 2|} dns_qpmulti_write: 1199| 8|dns_qpmulti_write(dns_qpmulti_t *multi, dns_qp_t **qptp) { 1200| 8| dns_qp_t *qp = transaction_open(multi, qptp); 1201| 8| TRACE(""); 1202| | 1203| 8| if (qp->transaction_mode == QP_WRITE) { ------------------ | Branch (1203:6): [True: 2, False: 6] ------------------ 1204| 2| qp->fender = qp->usage[qp->bump].used; 1205| 6| } else { 1206| 6| alloc_reset(qp); 1207| 6| } 1208| 8| qp->transaction_mode = QP_WRITE; 1209| 8|} dns_qpmulti_commit: 1259| 8|dns_qpmulti_commit(dns_qpmulti_t *multi, dns_qp_t **qptp) { 1260| 8| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1261| 8| REQUIRE(qptp != NULL && *qptp == &multi->writer); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1262| 8| REQUIRE(multi->writer.transaction_mode == QP_WRITE || ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1263| 8| multi->writer.transaction_mode == QP_UPDATE); 1264| | 1265| 8| dns_qp_t *qp = *qptp; 1266| 8| TRACE(""); 1267| | 1268| 8| if (qp->transaction_mode == QP_UPDATE) { ------------------ | Branch (1268:6): [True: 0, False: 8] ------------------ 1269| 0| INSIST(multi->rollback != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1270| | /* paired with dns_qpmulti_update() */ 1271| 0| if (qpbase_unref(multi->rollback)) { ------------------ | Branch (1271:7): [True: 0, False: 0] ------------------ 1272| 0| isc_mem_free(qp->mctx, multi->rollback->base); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1273| 0| } 1274| 0| if (multi->rollback->usage != NULL) { ------------------ | Branch (1274:7): [True: 0, False: 0] ------------------ 1275| 0| isc_mem_free(qp->mctx, multi->rollback->usage); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1276| 0| } 1277| 0| isc_mem_free(qp->mctx, multi->rollback); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 1278| 0| } 1279| 8| INSIST(multi->rollback == NULL); ------------------ | | 198| 8|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 8, False: 0] | | | | ------------------ | | | | 55| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1280| | 1281| | /* not the first commit? */ 1282| 8| if (multi->reader_ref != INVALID_REF) { ------------------ | | 229| 8|#define INVALID_REF ((dns_qpref_t)~0UL) ------------------ | Branch (1282:6): [True: 2, False: 6] ------------------ 1283| 2| INSIST(cells_immutable(qp, multi->reader_ref)); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1284| 2| free_twigs(qp, multi->reader_ref, READER_SIZE); ------------------ | | 840| 2|#define READER_SIZE 2 ------------------ 1285| 2| } 1286| | 1287| 8| if (qp->transaction_mode == QP_UPDATE) { ------------------ | Branch (1287:6): [True: 0, False: 8] ------------------ 1288| | /* minimize memory overhead */ 1289| 0| compact(qp); 1290| 0| multi->reader_ref = alloc_twigs(qp, READER_SIZE); ------------------ | | 840| 0|#define READER_SIZE 2 ------------------ 1291| 0| qp->base->ptr[qp->bump] = chunk_shrink_raw( 1292| 0| qp, qp->base->ptr[qp->bump], 1293| 0| qp->usage[qp->bump].used * sizeof(dns_qpnode_t)); 1294| 8| } else { 1295| 8| multi->reader_ref = alloc_twigs(qp, READER_SIZE); ------------------ | | 840| 8|#define READER_SIZE 2 ------------------ 1296| 8| } 1297| | 1298| | /* anchor a new version of the trie */ 1299| 8| dns_qpnode_t *reader = ref_ptr(qp, multi->reader_ref); 1300| 8| make_reader(reader, multi); 1301| | /* paired with chunk_free() */ 1302| 8| isc_refcount_increment(&qp->base->refcount); ------------------ | | 81| 8| ({ \ | | 82| 8| uint_fast32_t __v; \ | | 83| 8| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 8| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 8| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 198| 8|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 16| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:11): [True: 8, False: 0] | | | | | | | Branch (54:11): [True: 8, False: 0] | | | | | | ------------------ | | | | | | 55| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 8| __v; \ | | 86| 8| }) ------------------ 1303| | 1304| 8| rcu_assign_pointer(multi->reader, reader); /* COMMIT */ ------------------ | Branch (1304:2): [True: 8, False: 0] | Branch (1304:2): [Folded, False: 8] ------------------ 1305| | 1306| | /* clean up what we can right now */ 1307| 8| if (qp->transaction_mode == QP_UPDATE || QP_NEEDGC(qp)) { ------------------ | | 195| 8|#define QP_NEEDGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count) | | ------------------ | | | | 193| 8| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 159| 8|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 148| 8|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (193:3): [True: 0, False: 8] | | | | | Branch (193:33): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (1307:6): [True: 0, False: 8] ------------------ 1308| 0| recycle(qp); 1309| 0| } 1310| | 1311| | /* schedule the rest for later */ 1312| 8| reclaim_chunks(multi); 1313| | 1314| 8| *qptp = NULL; 1315| 8| UNLOCK(&multi->mutex); ------------------ | | 34| 8| { \ | | 35| 8| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 8|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 8| { \ | | | | | | 92| 8| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 8| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 8| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 8| } | | | | ------------------ | | ------------------ | | 36| 8| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 8| __FILE__, __LINE__)); \ | | 38| 8| } ------------------ 1316| 8|} dns_qpmulti_query: 1397| 587|dns_qpmulti_query(dns_qpmulti_t *multi, dns_qpread_t *qp) { 1398| 587| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 194| 587|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 587, False: 0] | | | | | Branch (42:11): [True: 587, False: 0] | | | | ------------------ | | | | 43| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1399| 587| REQUIRE(qp != NULL); ------------------ | | 194| 587|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 587| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 587, False: 0] | | | | ------------------ | | | | 43| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1400| | 1401| 587| qp->tid = isc_tid(); 1402| 587| rcu_read_lock(); 1403| | 1404| 587| dns_qpmulti_t *whence = reader_open(multi, qp); 1405| 587| INSIST(whence == multi); ------------------ | | 198| 587|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 587| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 587, False: 0] | | | | ------------------ | | | | 55| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1406| 587|} dns_qpread_destroy: 1409| 587|dns_qpread_destroy(dns_qpmulti_t *multi, dns_qpread_t *qp) { 1410| 587| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 194| 587|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 587, False: 0] | | | | | Branch (42:11): [True: 587, False: 0] | | | | ------------------ | | | | 43| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1411| 587| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 587|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 587, False: 0] | | | | | Branch (42:11): [True: 587, False: 0] | | | | ------------------ | | | | 43| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1412| 587| REQUIRE(qp->tid == isc_tid()); ------------------ | | 194| 587|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 587| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 587, False: 0] | | | | ------------------ | | | | 43| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1413| 587| *qp = (dns_qpread_t){}; 1414| | rcu_read_unlock(); 1415| 587|} dns_qpmulti_create: 1511| 8| dns_qpmulti_t **qpmp) { 1512| 8| REQUIRE(qpmp != NULL && *qpmp == NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1513| | 1514| 8| dns_qpmulti_t *multi = isc_mem_get(mctx, sizeof(*multi)); ------------------ | | 128| 8|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1515| 8| *multi = (dns_qpmulti_t){ .magic = QPMULTI_MAGIC, ------------------ | | 370| 8|#define QPMULTI_MAGIC ISC_MAGIC('q', 'p', 'm', 'v') | | ------------------ | | | | 31| 8|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1516| 8| .reader_ref = INVALID_REF, ------------------ | | 229| 8|#define INVALID_REF ((dns_qpref_t)~0UL) ------------------ 1517| 8| .references = ISC_REFCOUNT_INITIALIZER(1) }; ------------------ | | 34| 8|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 1518| 8| isc_mutex_init(&multi->mutex); ------------------ | | 68| 8|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 8| { \ | | | | 80| 8| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 8| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 8| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 8] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 8| } | | ------------------ ------------------ 1519| 8| ISC_LIST_INIT(multi->snapshots); ------------------ | | 43| 8| do { \ | | 44| 8| (list).head = NULL; \ | | 45| 8| (list).tail = NULL; \ | | 46| 8| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 8] | | ------------------ ------------------ 1520| | 1521| | /* 1522| | * Do not waste effort allocating a bump chunk that will be thrown 1523| | * away when a transaction is opened. dns_qpmulti_update() always 1524| | * allocates; to ensure dns_qpmulti_write() does too, pretend the 1525| | * previous transaction was an update 1526| | */ 1527| 8| dns_qp_t *qp = &multi->writer; 1528| 8| QP_INIT(qp, methods, uctx); ------------------ | | 393| 8| (*(qp) = (typeof(*(qp))){ \ | | 394| 8| .magic = QP_MAGIC, \ | | ------------------ | | | | 367| 8|#define QP_MAGIC ISC_MAGIC('t', 'r', 'i', 'e') | | | | ------------------ | | | | | | 31| 8|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 395| 8| .root_ref = INVALID_REF, \ | | ------------------ | | | | 229| 8|#define INVALID_REF ((dns_qpref_t)~0UL) | | ------------------ | | 396| 8| .uctx = x, \ | | 397| 8| .methods = m, \ | | 398| 8| }) ------------------ 1529| 8| isc_mem_attach(mctx, &qp->mctx); 1530| 8| qp->transaction_mode = QP_UPDATE; 1531| 8| TRACE(""); 1532| 8| *qpmp = multi; 1533| 8|} dns_qp_insert: 1647| 10|dns_qp_insert(dns_qp_t *qp, void *pval, uint32_t ival) { 1648| 10| dns_qpref_t new_ref, old_ref; 1649| 10| dns_qpnode_t new_leaf, old_node; 1650| 10| dns_qpnode_t *new_twigs = NULL, *old_twigs = NULL; 1651| 10| dns_qpshift_t new_bit, old_bit; 1652| 10| dns_qpweight_t old_size, new_size; 1653| 10| dns_qpkey_t new_key, old_key; 1654| 10| size_t new_keylen, old_keylen; 1655| 10| size_t offset; 1656| 10| uint64_t index; 1657| 10| dns_qpshift_t bit; 1658| 10| dns_qpweight_t pos; 1659| 10| dns_qpnode_t *n = NULL; 1660| | 1661| 10| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1662| | 1663| 10| new_leaf = make_leaf(pval, ival); 1664| 10| new_keylen = leaf_qpkey(qp, &new_leaf, new_key); 1665| | 1666| | /* first leaf in an empty trie? */ 1667| 10| if (qp->leaf_count == 0) { ------------------ | Branch (1667:6): [True: 6, False: 4] ------------------ 1668| 6| new_ref = alloc_twigs(qp, 1); 1669| 6| new_twigs = ref_ptr(qp, new_ref); 1670| 6| *new_twigs = new_leaf; 1671| 6| attach_leaf(qp, new_twigs); 1672| 6| qp->leaf_count++; 1673| 6| qp->root_ref = new_ref; 1674| 6| return ISC_R_SUCCESS; 1675| 6| } 1676| | 1677| | /* 1678| | * We need to keep searching down to a leaf even if our key is 1679| | * missing from this branch. It doesn't matter which twig we 1680| | * choose since the keys are all the same up to this node's 1681| | * offset. Note that if we simply use branch_twig_pos(n, bit) 1682| | * we may get an out-of-bounds access if our bit is greater 1683| | * than all the set bits in the node. 1684| | */ 1685| 4| n = ref_ptr(qp, qp->root_ref); 1686| 6| while (is_branch(n)) { ------------------ | Branch (1686:9): [True: 2, False: 4] ------------------ 1687| 2| prefetch_twigs(qp, n); 1688| 2| dns_qpref_t ref = branch_twigs_ref(n); 1689| 2| bit = branch_keybit(n, new_key, new_keylen); 1690| 2| pos = branch_has_twig(n, bit) ? branch_twig_pos(n, bit) : 0; ------------------ | Branch (1690:9): [True: 0, False: 2] ------------------ 1691| 2| n = ref_ptr(qp, ref + pos); 1692| 2| } 1693| | 1694| | /* do the keys differ, and if so, where? */ 1695| 4| old_keylen = leaf_qpkey(qp, n, old_key); 1696| 4| offset = qpkey_compare(new_key, new_keylen, old_key, old_keylen); 1697| 4| if (offset == QPKEY_EQUAL) { ------------------ | | 364| 4|#define QPKEY_EQUAL (~(size_t)0) ------------------ | Branch (1697:6): [True: 0, False: 4] ------------------ 1698| 0| return ISC_R_EXISTS; 1699| 0| } 1700| 4| new_bit = qpkey_bit(new_key, new_keylen, offset); 1701| 4| old_bit = qpkey_bit(old_key, old_keylen, offset); 1702| | 1703| | /* find where to insert a branch or grow an existing branch. */ 1704| 4| n = make_root_mutable(qp); 1705| 4| while (is_branch(n)) { ------------------ | Branch (1705:9): [True: 2, False: 2] ------------------ 1706| 2| prefetch_twigs(qp, n); 1707| 2| if (offset < branch_key_offset(n)) { ------------------ | Branch (1707:7): [True: 0, False: 2] ------------------ 1708| 0| goto newbranch; 1709| 0| } 1710| 2| if (offset == branch_key_offset(n)) { ------------------ | Branch (1710:7): [True: 2, False: 0] ------------------ 1711| 2| goto growbranch; 1712| 2| } 1713| 0| make_twigs_mutable(qp, n); 1714| 0| bit = branch_keybit(n, new_key, new_keylen); 1715| 0| INSIST(branch_has_twig(n, bit)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1716| 0| n = branch_twig_ptr(qp, n, bit); 1717| 0| } 1718| | /* fall through */ 1719| | 1720| 2|newbranch: 1721| 2| new_ref = alloc_twigs(qp, 2); 1722| 2| new_twigs = ref_ptr(qp, new_ref); 1723| | 1724| | /* save before overwriting. */ 1725| 2| old_node = *n; 1726| | 1727| | /* new branch node takes old node's place */ 1728| 2| index = BRANCH_TAG | (1ULL << new_bit) | (1ULL << old_bit) | 1729| 2| ((uint64_t)offset << SHIFT_OFFSET); 1730| 2| *n = make_node(index, new_ref); 1731| | 1732| | /* populate twigs */ 1733| 2| new_twigs[old_bit > new_bit] = old_node; 1734| 2| new_twigs[new_bit > old_bit] = new_leaf; 1735| | 1736| 2| attach_leaf(qp, &new_leaf); 1737| 2| qp->leaf_count++; 1738| | 1739| 2| return ISC_R_SUCCESS; 1740| | 1741| 2|growbranch: 1742| 2| INSIST(!branch_has_twig(n, new_bit)); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1743| | 1744| | /* locate twigs vectors */ 1745| 2| old_size = branch_twigs_size(n); 1746| 2| new_size = old_size + 1; 1747| 2| old_ref = branch_twigs_ref(n); 1748| 2| new_ref = alloc_twigs(qp, new_size); 1749| 2| old_twigs = ref_ptr(qp, old_ref); 1750| 2| new_twigs = ref_ptr(qp, new_ref); 1751| | 1752| | /* embiggen branch node */ 1753| 2| index = branch_index(n) | (1ULL << new_bit); 1754| 2| *n = make_node(index, new_ref); 1755| | 1756| | /* embiggen twigs vector */ 1757| 2| pos = branch_twig_pos(n, new_bit); 1758| 2| move_twigs(new_twigs, old_twigs, pos); 1759| 2| new_twigs[pos] = new_leaf; 1760| 2| move_twigs(new_twigs + pos + 1, old_twigs + pos, old_size - pos); 1761| | 1762| 2| if (squash_twigs(qp, old_ref, old_size)) { ------------------ | Branch (1762:6): [True: 2, False: 0] ------------------ 1763| | /* old twigs destroyed, only attach to new leaf */ 1764| 2| attach_leaf(qp, &new_leaf); 1765| 2| } else { 1766| | /* old twigs duplicated, attach to all leaves */ 1767| 0| attach_twigs(qp, new_twigs, new_size); 1768| 0| } 1769| 2| qp->leaf_count++; 1770| | 1771| 2| return ISC_R_SUCCESS; 1772| 4|} dns_qp_deletekey: 1776| 2| size_t search_keylen, void **pval_r, uint32_t *ival_r) { 1777| 2| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1778| 2| REQUIRE(search_keylen < sizeof(dns_qpkey_t)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1779| | 1780| 2| if (get_root(qp) == NULL) { ------------------ | Branch (1780:6): [True: 2, False: 0] ------------------ 1781| 2| return ISC_R_NOTFOUND; 1782| 2| } 1783| | 1784| 0| dns_qpshift_t bit = 0; /* suppress warning */ 1785| 0| dns_qpnode_t *parent = NULL; 1786| 0| dns_qpnode_t *n = make_root_mutable(qp); 1787| 0| while (is_branch(n)) { ------------------ | Branch (1787:9): [True: 0, False: 0] ------------------ 1788| 0| prefetch_twigs(qp, n); 1789| 0| bit = branch_keybit(n, search_key, search_keylen); 1790| 0| if (!branch_has_twig(n, bit)) { ------------------ | Branch (1790:7): [True: 0, False: 0] ------------------ 1791| 0| return ISC_R_NOTFOUND; 1792| 0| } 1793| 0| make_twigs_mutable(qp, n); 1794| 0| parent = n; 1795| 0| n = branch_twig_ptr(qp, n, bit); 1796| 0| } 1797| | 1798| 0| dns_qpkey_t found_key; 1799| 0| size_t found_keylen = leaf_qpkey(qp, n, found_key); 1800| 0| if (qpkey_compare(search_key, search_keylen, found_key, found_keylen) != ------------------ | Branch (1800:6): [True: 0, False: 0] ------------------ 1801| 0| QPKEY_EQUAL) ------------------ | | 364| 0|#define QPKEY_EQUAL (~(size_t)0) ------------------ 1802| 0| { 1803| 0| return ISC_R_NOTFOUND; 1804| 0| } 1805| | 1806| 0| SET_IF_NOT_NULL(pval_r, leaf_pval(n)); ------------------ | | 100| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 0] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 1807| 0| SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 100| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 0] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 1808| 0| detach_leaf(qp, n); 1809| 0| qp->leaf_count--; 1810| | 1811| | /* trie becomes empty */ 1812| 0| if (qp->leaf_count == 0) { ------------------ | Branch (1812:6): [True: 0, False: 0] ------------------ 1813| 0| INSIST(parent == NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1814| 0| INSIST(n == get_root(qp)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1815| 0| free_twigs(qp, qp->root_ref, 1); 1816| 0| qp->root_ref = INVALID_REF; ------------------ | | 229| 0|#define INVALID_REF ((dns_qpref_t)~0UL) ------------------ 1817| 0| return ISC_R_SUCCESS; 1818| 0| } 1819| | 1820| | /* step back to parent node */ 1821| 0| n = parent; 1822| 0| parent = NULL; 1823| | 1824| 0| INSIST(bit != 0); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1825| 0| dns_qpweight_t size = branch_twigs_size(n); 1826| 0| dns_qpweight_t pos = branch_twig_pos(n, bit); 1827| 0| dns_qpref_t ref = branch_twigs_ref(n); 1828| 0| dns_qpnode_t *twigs = ref_ptr(qp, ref); 1829| | 1830| 0| if (size == 2) { ------------------ | Branch (1830:6): [True: 0, False: 0] ------------------ 1831| | /* 1832| | * move the other twig to the parent branch. 1833| | */ 1834| 0| *n = twigs[!pos]; 1835| 0| squash_twigs(qp, ref, 2); 1836| 0| } else { 1837| | /* 1838| | * shrink the twigs in place, to avoid using the bump 1839| | * chunk too fast - the gc will clean up after us 1840| | */ 1841| 0| *n = make_node(branch_index(n) & ~(1ULL << bit), ref); 1842| 0| move_twigs(twigs + pos, twigs + pos + 1, size - pos - 1); 1843| 0| squash_twigs(qp, ref + size - 1, 1); 1844| 0| } 1845| | 1846| 0| return ISC_R_SUCCESS; 1847| 0|} dns_qp_deletename: 1851| 2| void **pval_r, uint32_t *ival_r) { 1852| 2| dns_qpkey_t key; 1853| 2| size_t keylen = dns_qpkey_fromname(key, name, space); 1854| 2| return dns_qp_deletekey(qp, key, keylen, pval_r, ival_r); 1855| 2|} dns_qpchain_init: 1861| 581|dns_qpchain_init(dns_qpreadable_t qpr, dns_qpchain_t *chain) { 1862| 581| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 581|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1863| 581| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 581|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 581, False: 0] | | | | | Branch (42:11): [True: 581, False: 0] | | | | ------------------ | | | | 43| 581| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1864| 581| REQUIRE(chain != NULL); ------------------ | | 194| 581|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 581| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 581, False: 0] | | | | ------------------ | | | | 43| 581| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1865| | 1866| | /* 1867| | * dns_qpchain_t contains a 2kb buffer, which is slow to 1868| | * zero-initialize. Therefore we avoid designated initializers, and 1869| | * initialize each field manually. 1870| | */ 1871| 581| chain->magic = QPCHAIN_MAGIC; ------------------ | | 369| 581|#define QPCHAIN_MAGIC ISC_MAGIC('q', 'p', 'c', 'h') | | ------------------ | | | | 31| 581|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1872| 581| chain->qp = qp; 1873| 581| chain->len = 0; 1874| 581|} dns_qpchain_length: 1877| 209|dns_qpchain_length(dns_qpchain_t *chain) { 1878| 209| REQUIRE(QPCHAIN_VALID(chain)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1879| | 1880| 209| return chain->len; 1881| 209|} dns_qpchain_node: 1885| 77| uint32_t *ival_r) { 1886| 77| dns_qpnode_t *node = NULL; 1887| | 1888| 77| REQUIRE(QPCHAIN_VALID(chain)); ------------------ | | 194| 77|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 154| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 77, False: 0] | | | | | Branch (42:11): [True: 77, False: 0] | | | | ------------------ | | | | 43| 77| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1889| 77| REQUIRE(level < chain->len); ------------------ | | 194| 77|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 77| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 77, False: 0] | | | | ------------------ | | | | 43| 77| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1890| | 1891| 77| node = chain->chain[level].node; 1892| 77| SET_IF_NOT_NULL(pval_r, leaf_pval(node)); ------------------ | | 100| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 77, False: 0] | | ------------------ | | 101| 77| *(obj) = (val); \ | | 102| 77| } ------------------ 1893| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 100| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 77] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 1894| 77|} dns_qpiter_init: 1901| 658|dns_qpiter_init(dns_qpreadable_t qpr, dns_qpiter_t *qpi) { 1902| 658| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 658|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1903| 658| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 658|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.31k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 658, False: 0] | | | | | Branch (42:11): [True: 658, False: 0] | | | | ------------------ | | | | 43| 658| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1904| 658| REQUIRE(qpi != NULL); ------------------ | | 194| 658|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 658| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 658, False: 0] | | | | ------------------ | | | | 43| 658| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1905| | 1906| | /* 1907| | * dns_qpiter_t contains a 4kb buffer, which is slow to zero-initialize. 1908| | * Therefore we avoid designated initializers, and initialize each 1909| | * field manually. 1910| | */ 1911| 658| qpi->qp = qp; 1912| 658| qpi->sp = 0; 1913| 658| qpi->magic = QPITER_MAGIC; ------------------ | | 368| 658|#define QPITER_MAGIC ISC_MAGIC('q', 'p', 'i', 't') | | ------------------ | | | | 31| 658|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1914| | /* 1915| | * The top of the stack must be initialized. 1916| | */ 1917| | qpi->stack[qpi->sp] = NULL; 1918| 658|} dns_qpiter_next: 2023| 231|dns_qpiter_next(dns_qpiter_t *qpi, void **pval_r, uint32_t *ival_r) { 2024| | return iterate(true, qpi, pval_r, ival_r); 2025| 231|} dns_qpiter_current: 2033| 77|dns_qpiter_current(dns_qpiter_t *qpi, void **pval_r, uint32_t *ival_r) { 2034| 77| dns_qpnode_t *node = NULL; 2035| | 2036| 77| REQUIRE(QPITER_VALID(qpi)); ------------------ | | 194| 77|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 154| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 77, False: 0] | | | | | Branch (42:11): [True: 77, False: 0] | | | | ------------------ | | | | 43| 77| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2037| | 2038| 77| node = qpi->stack[qpi->sp]; 2039| 77| if (node == NULL || is_branch(node)) { ------------------ | Branch (2039:6): [True: 0, False: 77] | Branch (2039:22): [True: 0, False: 77] ------------------ 2040| 0| return ISC_R_FAILURE; 2041| 0| } 2042| | 2043| 77| SET_IF_NOT_NULL(pval_r, leaf_pval(node)); ------------------ | | 100| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 77, False: 0] | | ------------------ | | 101| 77| *(obj) = (val); \ | | 102| 77| } ------------------ 2044| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 100| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 77] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 2045| 77| return ISC_R_SUCCESS; 2046| 77|} dns_qp_getkey: 2055| 12| size_t search_keylen, void **pval_r, uint32_t *ival_r) { 2056| 12| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 12|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 2057| 12| dns_qpkey_t found_key; 2058| 12| size_t found_keylen; 2059| 12| dns_qpshift_t bit; 2060| 12| dns_qpnode_t *n = NULL; 2061| | 2062| 12| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 12, False: 0] | | | | | Branch (42:11): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2063| 12| REQUIRE(search_keylen < sizeof(dns_qpkey_t)); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2064| | 2065| 12| n = get_root(qp); 2066| 12| if (n == NULL) { ------------------ | Branch (2066:6): [True: 0, False: 12] ------------------ 2067| 0| return ISC_R_NOTFOUND; 2068| 0| } 2069| | 2070| 24| while (is_branch(n)) { ------------------ | Branch (2070:9): [True: 12, False: 12] ------------------ 2071| 12| prefetch_twigs(qp, n); 2072| 12| bit = branch_keybit(n, search_key, search_keylen); 2073| 12| if (!branch_has_twig(n, bit)) { ------------------ | Branch (2073:7): [True: 0, False: 12] ------------------ 2074| 0| return ISC_R_NOTFOUND; 2075| 0| } 2076| 12| n = branch_twig_ptr(qp, n, bit); 2077| 12| } 2078| | 2079| 12| found_keylen = leaf_qpkey(qp, n, found_key); 2080| 12| if (qpkey_compare(search_key, search_keylen, found_key, found_keylen) != ------------------ | Branch (2080:6): [True: 0, False: 12] ------------------ 2081| 12| QPKEY_EQUAL) ------------------ | | 364| 12|#define QPKEY_EQUAL (~(size_t)0) ------------------ 2082| 0| { 2083| 0| return ISC_R_NOTFOUND; 2084| 0| } 2085| | 2086| 12| SET_IF_NOT_NULL(pval_r, leaf_pval(n)); ------------------ | | 100| 12| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 12, False: 0] | | ------------------ | | 101| 12| *(obj) = (val); \ | | 102| 12| } ------------------ 2087| | SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 100| 12| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 12] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 2088| 12| return ISC_R_SUCCESS; 2089| 12|} dns_qp_getname: 2093| 12| dns_namespace_t space, void **pval_r, uint32_t *ival_r) { 2094| 12| dns_qpkey_t key; 2095| 12| size_t keylen = dns_qpkey_fromname(key, name, space); 2096| 12| return dns_qp_getkey(qpr, key, keylen, pval_r, ival_r); 2097| 12|} dns_qp_lookup: 2272| 581| void **pval_r, uint32_t *ival_r) { 2273| 581| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 581|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 2274| 581| dns_qpkey_t search, found; 2275| 581| size_t searchlen, foundlen; 2276| 581| size_t offset = 0; 2277| 581| dns_qpnode_t *n = NULL; 2278| 581| dns_qpshift_t bit = SHIFT_NOBYTE; 2279| 581| dns_qpchain_t oc; 2280| 581| dns_qpiter_t it; 2281| 581| bool matched = false; 2282| 581| bool setiter = true; 2283| | 2284| 581| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 581|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 581, False: 0] | | | | | Branch (42:11): [True: 581, False: 0] | | | | ------------------ | | | | 43| 581| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2285| | 2286| 581| searchlen = dns_qpkey_fromname(search, name, space); 2287| | 2288| 581| if (chain == NULL) { ------------------ | Branch (2288:6): [True: 0, False: 581] ------------------ 2289| 0| chain = &oc; 2290| 0| } 2291| 581| if (iter == NULL) { ------------------ | Branch (2291:6): [True: 372, False: 209] ------------------ 2292| 372| iter = ⁢ 2293| 372| setiter = false; 2294| 372| } 2295| 581| dns_qpchain_init(qp, chain); 2296| 581| dns_qpiter_init(qp, iter); 2297| | 2298| 581| n = get_root(qp); 2299| 581| if (n == NULL) { ------------------ | Branch (2299:6): [True: 0, False: 581] ------------------ 2300| 0| return ISC_R_NOTFOUND; 2301| 0| } 2302| 581| iter->stack[0] = n; 2303| | 2304| | /* 2305| | * Like `dns_qp_insert()`, we must find a leaf. However, we don't make a 2306| | * second pass: instead, we keep track of any leaves with shorter keys 2307| | * that we discover along the way. (In general, qp-trie searches can be 2308| | * one-pass, by recording their traversal, or two-pass, for less stack 2309| | * memory usage.) 2310| | */ 2311| 790| while (is_branch(n)) { ------------------ | Branch (2311:9): [True: 209, False: 581] ------------------ 2312| 209| prefetch_twigs(qp, n); 2313| | 2314| 209| offset = branch_key_offset(n); 2315| 209| bit = qpkey_bit(search, searchlen, offset); 2316| 209| dns_qpnode_t *twigs = branch_twigs(qp, n); 2317| | 2318| | /* 2319| | * A shorter key that can be a parent domain always has a 2320| | * leaf node at SHIFT_NOBYTE (indicating end of its key) 2321| | * where our search key has a normal character immediately 2322| | * after a label separator. 2323| | * 2324| | * Note 1: It is OK if `off - 1` underflows: it will 2325| | * become SIZE_MAX, which is greater than `searchlen`, so 2326| | * `qpkey_bit()` will return SHIFT_NOBYTE, which is what we 2327| | * want when `off == 0`. 2328| | * 2329| | * Note 2: If SHIFT_NOBYTE twig is present, it will always 2330| | * be in position 0, the first location in 'twigs'. 2331| | */ 2332| 209| if (bit != SHIFT_NOBYTE && branch_has_twig(n, SHIFT_NOBYTE) && ------------------ | Branch (2332:7): [True: 209, False: 0] | Branch (2332:30): [True: 0, False: 209] ------------------ 2333| 0| qpkey_bit(search, searchlen, offset - 1) == SHIFT_NOBYTE && ------------------ | Branch (2333:7): [True: 0, False: 0] ------------------ 2334| 0| !is_branch(twigs)) ------------------ | Branch (2334:7): [True: 0, False: 0] ------------------ 2335| 0| { 2336| 0| add_link(chain, twigs, offset); 2337| 0| } 2338| | 2339| 209| matched = branch_has_twig(n, bit); 2340| 209| if (matched) { ------------------ | Branch (2340:7): [True: 209, False: 0] ------------------ 2341| | /* 2342| | * found a match: if it's a branch, we keep 2343| | * searching, and if it's a leaf, we drop out of 2344| | * the loop. 2345| | */ 2346| 209| n = branch_twig_ptr(qp, n, bit); 2347| 209| } else { 2348| | /* 2349| | * this branch is a dead end, and the predecessor 2350| | * doesn't matter. now we just need to find a leaf 2351| | * to end on so that qpkey_leaf() will work below. 2352| | */ 2353| 0| n = anyleaf(qp, twigs); 2354| 0| } 2355| | 2356| 209| iter->stack[++iter->sp] = n; 2357| 209| } 2358| | 2359| 581| if (setiter) { ------------------ | Branch (2359:6): [True: 209, False: 372] ------------------ 2360| | /* 2361| | * we found a leaf, but it might not be the leaf we wanted. 2362| | * if it isn't, and if the caller passed us an iterator, 2363| | * then we might need to reposition it. 2364| | */ 2365| 209| fix_iterator(qp, iter, search, searchlen); 2366| 209| n = iter->stack[iter->sp]; 2367| 209| } 2368| | 2369| | /* at this point, n can only be a leaf node */ 2370| 581| INSIST(!is_branch(n)); ------------------ | | 198| 581|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 581| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 581, False: 0] | | | | ------------------ | | | | 55| 581| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2371| | 2372| 581| foundlen = leaf_qpkey(qp, n, found); 2373| 581| offset = qpkey_compare(search, searchlen, found, foundlen); 2374| | 2375| | /* the search ended with an exact or partial match */ 2376| 581| if (offset == QPKEY_EQUAL || offset == foundlen) { ------------------ | | 364| 1.16k|#define QPKEY_EQUAL (~(size_t)0) ------------------ | Branch (2376:6): [True: 264, False: 317] | Branch (2376:31): [True: 154, False: 163] ------------------ 2377| 418| isc_result_t result = ISC_R_SUCCESS; 2378| | 2379| 418| if (offset == foundlen) { ------------------ | Branch (2379:7): [True: 154, False: 264] ------------------ 2380| 154| fix_chain(chain, offset); 2381| 154| result = DNS_R_PARTIALMATCH; 2382| 154| } 2383| 418| add_link(chain, n, offset); 2384| | 2385| 418| SET_IF_NOT_NULL(pval_r, leaf_pval(n)); ------------------ | | 100| 418| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 418, False: 0] | | ------------------ | | 101| 418| *(obj) = (val); \ | | 102| 418| } ------------------ 2386| 418| SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 100| 418| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 418] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 2387| 418| return result; 2388| 418| } 2389| | 2390| | /* 2391| | * the requested name was not found, but if an ancestor 2392| | * was, we can retrieve that from the chain. 2393| | */ 2394| 163| int len = chain->len; 2395| 163| while (len-- > 0) { ------------------ | Branch (2395:9): [True: 0, False: 163] ------------------ 2396| 0| if (offset >= chain->chain[len].offset) { ------------------ | Branch (2396:7): [True: 0, False: 0] ------------------ 2397| 0| n = chain->chain[len].node; 2398| 0| SET_IF_NOT_NULL(pval_r, leaf_pval(n)); ------------------ | | 100| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 0] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 2399| 0| SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 100| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 0] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 2400| 0| return DNS_R_PARTIALMATCH; 2401| 0| } else { 2402| | /* 2403| | * oops, during the search we found and added 2404| | * a leaf that's longer than the requested 2405| | * name; remove it from the chain. 2406| | */ 2407| 0| chain->len--; 2408| 0| } 2409| 0| } 2410| | 2411| | /* nothing was found at all */ 2412| 163| return ISC_R_NOTFOUND; 2413| 163|} qp.c:alloc_reset: 590| 6|alloc_reset(dns_qp_t *qp) { 591| 6| (void)alloc_slow(qp, 0); 592| 6|} qp.c:alloc_slow: 573| 6|alloc_slow(dns_qp_t *qp, dns_qpweight_t size) { 574| 6| dns_qpchunk_t chunk; 575| | 576| 6| for (chunk = 0; chunk < qp->chunk_max; chunk++) { ------------------ | Branch (576:18): [True: 0, False: 6] ------------------ 577| 0| if (!qp->usage[chunk].exists) { ------------------ | Branch (577:7): [True: 0, False: 0] ------------------ 578| 0| return chunk_alloc(qp, chunk, size); 579| 0| } 580| 0| } 581| 6| ENSURE(chunk == qp->chunk_max); ------------------ | | 196| 6|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 6, False: 0] | | | | ------------------ | | | | 49| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 582| 6| realloc_chunk_arrays(qp, GROWTH_FACTOR(chunk)); ------------------ | | 202| 6|#define GROWTH_FACTOR(size) ((size) + (size) / 2 + 2) ------------------ 583| 6| return chunk_alloc(qp, chunk, size); 584| 6|} qp.c:chunk_alloc: 510| 6|chunk_alloc(dns_qp_t *qp, dns_qpchunk_t chunk, dns_qpweight_t size) { 511| 6| INSIST(qp->base->ptr[chunk] == NULL); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 512| 6| INSIST(qp->usage[chunk].used == 0); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 513| 6| INSIST(qp->usage[chunk].free == 0); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 514| 6| INSIST(qp->chunk_capacity <= QP_CHUNK_SIZE); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 515| | 516| 6| qp->chunk_capacity = next_capacity(qp->chunk_capacity * 2u, size); 517| 6| qp->base->ptr[chunk] = 518| 6| chunk_get_raw(qp, qp->chunk_capacity * sizeof(dns_qpnode_t)); 519| | 520| 6| qp->usage[chunk] = (qp_usage_t){ .exists = true, 521| 6| .used = size, 522| 6| .capacity = qp->chunk_capacity }; 523| 6| qp->used_count += size; 524| 6| qp->bump = chunk; 525| 6| qp->fender = 0; 526| | 527| 6| if (qp->write_protect) { ------------------ | Branch (527:6): [True: 0, False: 6] ------------------ 528| 0| TRACE("chunk %u base %p", chunk, qp->base->ptr[chunk]); 529| 0| } 530| 6| return make_ref(chunk, 0); 531| 6|} qp.c:next_capacity: 495| 6|next_capacity(uint32_t prev_capacity, uint32_t size) { 496| | /* 497| | * Request size was floored at 2 because builtin_clz used to be 0. 498| | * We keep this behavior because stdc_leading_zeros(0) = 32. 499| | */ 500| 6| size = ISC_MAX3(size, prev_capacity, 2U); ------------------ | | 77| 6|#define ISC_MAX3(a, b, c) ISC_MAX(ISC_MAX((a), (b)), (c)) | | ------------------ | | | | 72| 12|#define ISC_MAX(a, b) ((a) > (b) ? (a) : (b)) | | | | ------------------ | | | | | Branch (72:24): [True: 0, False: 6] | | | | | Branch (72:25): [True: 0, False: 6] | | | | | Branch (72:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 501| 6| uint32_t log2 = 32U - stdc_leading_zeros(size - 1U); ------------------ | | 39| 6|#define stdc_leading_zeros(x) __builtin_clzg(x, (int)(sizeof(x) * 8)) ------------------ 502| | 503| 6| return 1U << ISC_CLAMP(log2, QP_CHUNK_LOG_MIN, QP_CHUNK_LOG_MAX); ------------------ | | 75| 6|#define ISC_CLAMP(v, x, y) ((v) < (x) ? (x) : ((v) > (y) ? (y) : (v))) | | ------------------ | | | Branch (75:29): [True: 6, False: 0] | | | Branch (75:48): [True: 0, False: 0] | | ------------------ ------------------ 504| 6|} qp.c:chunk_get_raw: 415| 6|chunk_get_raw(dns_qp_t *qp, size_t len) { 416| 6| if (qp->write_protect) { ------------------ | Branch (416:6): [True: 0, False: 6] ------------------ 417| 0| size_t size = chunk_size_raw(); 418| 0| void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, 419| 0| MAP_ANON | MAP_PRIVATE, -1, 0); 420| 0| RUNTIME_CHECK(ptr != MAP_FAILED); ------------------ | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ ------------------ 421| 0| return ptr; 422| 6| } else { 423| 6| return isc_mem_allocate(qp->mctx, len); ------------------ | | 138| 6|#define isc_mem_allocate(c, s) isc__mem_allocate((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 424| 6| } 425| 6|} qp.c:realloc_chunk_arrays: 541| 6|realloc_chunk_arrays(dns_qp_t *qp, dns_qpchunk_t newmax) { 542| 6| size_t oldptrs = sizeof(qp->base->ptr[0]) * qp->chunk_max; 543| 6| size_t newptrs = sizeof(qp->base->ptr[0]) * newmax; 544| 6| size_t size = STRUCT_FLEX_SIZE(qp->base, ptr, newmax); ------------------ | | 110| 6| (sizeof(*(pointer)) + sizeof(*(pointer)->member) * (count)) ------------------ 545| | 546| 6| if (qp->base == NULL || qpbase_unref(qp)) { ------------------ | Branch (546:6): [True: 6, False: 0] | Branch (546:26): [True: 0, False: 0] ------------------ 547| 6| qp->base = isc_mem_reallocate(qp->mctx, qp->base, size); ------------------ | | 143| 6| isc__mem_reallocate((c), (p), (s), 0 _ISC_MEM_FILELINE) ------------------ 548| 6| } else { 549| 0| dns_qpbase_t *oldbase = qp->base; 550| 0| qp->base = isc_mem_allocate(qp->mctx, size); ------------------ | | 138| 0|#define isc_mem_allocate(c, s) isc__mem_allocate((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 551| 0| memmove(&qp->base->ptr[0], &oldbase->ptr[0], oldptrs); 552| 0| } 553| 6| memset(&qp->base->ptr[qp->chunk_max], 0, newptrs - oldptrs); 554| 6| isc_refcount_init(&qp->base->refcount, 1); ------------------ | | 44| 6|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 555| 6| qp->base->magic = QPBASE_MAGIC; ------------------ | | 372| 6|#define QPBASE_MAGIC ISC_MAGIC('q', 'p', 'b', 'p') | | ------------------ | | | | 31| 6|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 556| | 557| | /* usage array is exclusive to the writer */ 558| 6| size_t oldusage = sizeof(qp->usage[0]) * qp->chunk_max; 559| 6| size_t newusage = sizeof(qp->usage[0]) * newmax; 560| 6| qp->usage = isc_mem_reallocate(qp->mctx, qp->usage, newusage); ------------------ | | 143| 6| isc__mem_reallocate((c), (p), (s), 0 _ISC_MEM_FILELINE) ------------------ 561| 6| memset(&qp->usage[qp->chunk_max], 0, newusage - oldusage); 562| | 563| 6| qp->chunk_max = newmax; 564| | 565| 6| TRACE("qpbase %p usage %p max %u", qp->base, qp->usage, qp->chunk_max); 566| 6|} qp.c:transaction_open: 1151| 8|transaction_open(dns_qpmulti_t *multi, dns_qp_t **qptp) { 1152| 8| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1153| 8| REQUIRE(qptp != NULL && *qptp == NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1154| | 1155| 8| LOCK(&multi->mutex); ------------------ | | 26| 8| { \ | | 27| 8| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 8| __FILE__, __LINE__)); \ | | 29| 8| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 8|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 8| { \ | | | | | | 86| 8| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 8| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 8| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 8| } | | | | ------------------ | | ------------------ | | 30| 8| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 8| __FILE__, __LINE__)); \ | | 32| 8| } ------------------ 1156| | 1157| 8| dns_qp_t *qp = &multi->writer; 1158| 8| INSIST(QP_VALID(qp)); ------------------ | | 198| 8|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 8, False: 0] | | | | | Branch (54:11): [True: 8, False: 0] | | | | ------------------ | | | | 55| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1159| | 1160| | /* 1161| | * Mark existing chunks as immutable. 1162| | * 1163| | * Aside: The bump chunk is special: in a series of write 1164| | * transactions the bump chunk is reused; the first part (up 1165| | * to fender) is immutable, the rest mutable. But we set its 1166| | * immutable flag so that when the bump chunk fills up, the 1167| | * first part continues to be treated as immutable. (And the 1168| | * rest of the chunk too, but that's OK.) 1169| | */ 1170| 12| for (dns_qpchunk_t chunk = 0; chunk < qp->chunk_max; chunk++) { ------------------ | Branch (1170:32): [True: 4, False: 8] ------------------ 1171| 4| if (qp->usage[chunk].exists) { ------------------ | Branch (1171:7): [True: 2, False: 2] ------------------ 1172| 2| qp->usage[chunk].immutable = true; 1173| 2| write_protect(qp, chunk); 1174| 2| } 1175| 4| } 1176| | 1177| | /* 1178| | * Ensure QP_AUTOGC() ignores free space in immutable chunks. 1179| | */ 1180| 8| qp->hold_count = qp->free_count; 1181| | 1182| 8| *qptp = qp; 1183| 8| return qp; 1184| 8|} qp.c:write_protect: 446| 2|write_protect(dns_qp_t *qp, dns_qpchunk_t chunk) { 447| 2| if (qp->write_protect) { ------------------ | Branch (447:6): [True: 0, False: 2] ------------------ 448| | /* see transaction_open() wrt this special case */ 449| 0| if (qp->transaction_mode == QP_WRITE && chunk == qp->bump) { ------------------ | Branch (449:7): [True: 0, False: 0] | Branch (449:43): [True: 0, False: 0] ------------------ 450| 0| return; 451| 0| } 452| 0| TRACE("chunk %u", chunk); 453| 0| void *ptr = qp->base->ptr[chunk]; 454| 0| size_t size = chunk_size_raw(); 455| 0| RUNTIME_CHECK(mprotect(ptr, size, PROT_READ) >= 0); ------------------ | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ ------------------ 456| 0| } 457| 2|} qp.c:cells_immutable: 480| 10|cells_immutable(dns_qp_t *qp, dns_qpref_t ref) { 481| 10| dns_qpchunk_t chunk = ref_chunk(ref); 482| 10| dns_qpcell_t cell = ref_cell(ref); 483| 10| if (chunk == qp->bump) { ------------------ | Branch (483:6): [True: 10, False: 0] ------------------ 484| 10| return cell < qp->fender; 485| 10| } else { 486| 0| return qp->usage[chunk].immutable; 487| 0| } 488| 10|} qp.c:free_twigs: 622| 4|free_twigs(dns_qp_t *qp, dns_qpref_t twigs, dns_qpweight_t size) { 623| 4| dns_qpchunk_t chunk = ref_chunk(twigs); 624| | 625| 4| qp->free_count += size; 626| 4| qp->usage[chunk].free += size; 627| 4| ENSURE(qp->free_count <= qp->used_count); ------------------ | | 196| 4|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 4, False: 0] | | | | ------------------ | | | | 49| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 628| 4| ENSURE(qp->usage[chunk].free <= qp->usage[chunk].used); ------------------ | | 196| 4|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 4, False: 0] | | | | ------------------ | | | | 49| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 629| | 630| 4| if (cells_immutable(qp, twigs)) { ------------------ | Branch (630:6): [True: 2, False: 2] ------------------ 631| 2| qp->hold_count += size; 632| 2| ENSURE(qp->free_count >= qp->hold_count); ------------------ | | 196| 2|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 2, False: 0] | | | | ------------------ | | | | 49| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 633| 2| return false; 634| 2| } else { 635| 2| zero_twigs(ref_ptr(qp, twigs), size); 636| | return true; 637| 2| } 638| 4|} qp.c:alloc_twigs: 598| 18|alloc_twigs(dns_qp_t *qp, dns_qpweight_t size) { 599| 18| dns_qpchunk_t chunk = qp->bump; 600| 18| dns_qpcell_t cell = qp->usage[chunk].used; 601| | 602| 18| if (cell + size <= qp->usage[chunk].capacity) { ------------------ | Branch (602:6): [True: 18, False: 0] ------------------ 603| 18| qp->usage[chunk].used += size; 604| 18| qp->used_count += size; 605| 18| return make_ref(chunk, cell); 606| 18| } else { 607| 0| return alloc_slow(qp, size); 608| 0| } 609| 18|} qp.c:reclaim_chunks: 803| 8|reclaim_chunks(dns_qpmulti_t *multi) { 804| 8| dns_qp_t *qp = &multi->writer; 805| | 806| 8| unsigned int count = 0; 807| 24| for (dns_qpchunk_t chunk = 0; chunk < qp->chunk_max; chunk++) { ------------------ | Branch (807:32): [True: 16, False: 8] ------------------ 808| 16| if (chunk != qp->bump && chunk_usage(qp, chunk) == 0 && ------------------ | Branch (808:7): [True: 8, False: 8] | Branch (808:28): [True: 8, False: 0] ------------------ 809| 8| qp->usage[chunk].exists && qp->usage[chunk].immutable && ------------------ | Branch (809:7): [True: 0, False: 8] | Branch (809:34): [True: 0, False: 0] ------------------ 810| 0| !qp->usage[chunk].discounted) ------------------ | Branch (810:7): [True: 0, False: 0] ------------------ 811| 0| { 812| 0| count++; 813| 0| } 814| 16| } 815| | 816| 8| if (count == 0) { ------------------ | Branch (816:6): [True: 8, False: 0] ------------------ 817| 8| return; 818| 8| } 819| | 820| 0| qp_rcuctx_t *rcuctx = 821| 0| isc_mem_get(qp->mctx, STRUCT_FLEX_SIZE(rcuctx, chunk, count)); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 822| 0| *rcuctx = (qp_rcuctx_t){ 823| 0| .magic = QPRCU_MAGIC, ------------------ | | 373| 0|#define QPRCU_MAGIC ISC_MAGIC('q', 'p', 'c', 'b') | | ------------------ | | | | 31| 0|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 824| 0| .multi = multi, 825| 0| .count = count, 826| 0| }; 827| 0| isc_mem_attach(qp->mctx, &rcuctx->mctx); 828| | 829| 0| unsigned int i = 0; 830| 0| for (dns_qpchunk_t chunk = 0; chunk < qp->chunk_max; chunk++) { ------------------ | Branch (830:32): [True: 0, False: 0] ------------------ 831| 0| if (chunk != qp->bump && chunk_usage(qp, chunk) == 0 && ------------------ | Branch (831:7): [True: 0, False: 0] | Branch (831:28): [True: 0, False: 0] ------------------ 832| 0| qp->usage[chunk].exists && qp->usage[chunk].immutable && ------------------ | Branch (832:7): [True: 0, False: 0] | Branch (832:34): [True: 0, False: 0] ------------------ 833| 0| !qp->usage[chunk].discounted) ------------------ | Branch (833:7): [True: 0, False: 0] ------------------ 834| 0| { 835| 0| rcuctx->chunk[i++] = chunk; 836| 0| chunk_discount(qp, chunk); 837| 0| } 838| 0| } 839| | 840| | /* 841| | * Reference the qpmulti object to keep it from being 842| | * freed until reclaim_chunks_cb() runs. 843| | */ 844| 0| dns_qpmulti_ref(multi); 845| 0| call_rcu(&rcuctx->rcu_head, reclaim_chunks_cb); 846| | 847| 0| LOG_STATS("qp will reclaim %u chunks", count); ------------------ | | 74| 0| isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_QP, \ | | 75| 0| ISC_LOG_DEBUG(DNS_QP_LOG_STATS_LEVEL), __VA_ARGS__) | | ------------------ | | | | 36| 0|#define ISC_LOG_DEBUG(level) (level) | | ------------------ ------------------ 848| 0|} qp.c:reader_open: 1381| 587|reader_open(dns_qpmulti_t *multi, dns_qpreadable_t qpr) { 1382| 587| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 587|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1383| 587| dns_qpnode_t *reader = rcu_dereference(multi->reader); 1384| 587| if (reader == NULL) { ------------------ | Branch (1384:6): [True: 0, False: 587] ------------------ 1385| 0| QP_INIT(qp, multi->writer.methods, multi->writer.uctx); ------------------ | | 393| 0| (*(qp) = (typeof(*(qp))){ \ | | 394| 0| .magic = QP_MAGIC, \ | | ------------------ | | | | 367| 0|#define QP_MAGIC ISC_MAGIC('t', 'r', 'i', 'e') | | | | ------------------ | | | | | | 31| 0|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 395| 0| .root_ref = INVALID_REF, \ | | ------------------ | | | | 229| 0|#define INVALID_REF ((dns_qpref_t)~0UL) | | ------------------ | | 396| 0| .uctx = x, \ | | 397| 0| .methods = m, \ | | 398| 0| }) ------------------ 1386| 587| } else { 1387| 587| multi = unpack_reader(qp, reader); 1388| 587| } 1389| 587| return multi; 1390| 587|} qp.c:chunk_usage: 663| 8|chunk_usage(dns_qp_t *qp, dns_qpchunk_t chunk) { 664| 8| return qp->usage[chunk].used - qp->usage[chunk].free; 665| 8|} qp.c:qpkey_compare: 381| 806| const dns_qpkey_t key_b, const size_t keylen_b) { 382| 806| size_t keylen = ISC_MAX(keylen_a, keylen_b); ------------------ | | 72| 806|#define ISC_MAX(a, b) ((a) > (b) ? (a) : (b)) | | ------------------ | | | Branch (72:24): [True: 348, False: 458] | | ------------------ ------------------ 383| 7.59k| for (size_t offset = 0; offset < keylen; offset++) { ------------------ | Branch (383:26): [True: 7.18k, False: 408] ------------------ 384| 7.18k| if (qpkey_bit(key_a, keylen_a, offset) != ------------------ | Branch (384:7): [True: 398, False: 6.79k] ------------------ 385| 7.18k| qpkey_bit(key_b, keylen_b, offset)) 386| 398| { 387| 398| return offset; 388| 398| } 389| 7.18k| } 390| 408| return QPKEY_EQUAL; ------------------ | | 364| 408|#define QPKEY_EQUAL (~(size_t)0) ------------------ 391| 806|} qp.c:make_root_mutable: 931| 4|make_root_mutable(dns_qp_t *qp) { 932| 4| if (cells_immutable(qp, qp->root_ref)) { ------------------ | Branch (932:6): [True: 0, False: 4] ------------------ 933| 0| qp->root_ref = evacuate(qp, MOVABLE_ROOT(qp)); ------------------ | | 734| 0| (&(dns_qpnode_t){ \ | | 735| 0| .biglo = BRANCH_TAG | (1 << SHIFT_NOBYTE), \ | | 736| 0| .small = qp->root_ref, \ | | 737| 0| }) ------------------ 934| 0| } 935| 4| return ref_ptr(qp, qp->root_ref); 936| 4|} qp.c:squash_twigs: 1054| 2|squash_twigs(dns_qp_t *qp, dns_qpref_t twigs, dns_qpweight_t size) { 1055| 2| bool destroyed = free_twigs(qp, twigs, size); 1056| 2| if (destroyed && QP_AUTOGC(qp)) { ------------------ | | 196| 2|#define QP_AUTOGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count - (qp)->hold_count) | | ------------------ | | | | 193| 2| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 159| 2|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 148| 2|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (193:3): [True: 0, False: 2] | | | | | Branch (193:33): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (1056:6): [True: 2, False: 0] ------------------ 1057| 0| compact(qp); 1058| 0| recycle(qp); 1059| | /* 1060| | * This shouldn't happen if the garbage collector is 1061| | * working correctly. We can recover at the cost of some 1062| | * time and space, but recovery should be cheaper than 1063| | * letting compact+recycle fail repeatedly. 1064| | */ 1065| 0| if (QP_AUTOGC(qp)) { ------------------ | | 196| 0|#define QP_AUTOGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count - (qp)->hold_count) | | ------------------ | | | | 193| 0| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 159| 0|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 148| 0|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (193:3): [True: 0, False: 0] | | | | | Branch (193:33): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1066| 0| isc_log_write(DNS_LOGCATEGORY_DATABASE, 1067| 0| DNS_LOGMODULE_QP, ISC_LOG_NOTICE, ------------------ | | 43| 0|#define ISC_LOG_NOTICE (-2) ------------------ 1068| 0| "qp %p uctx \"%s\" compact/recycle " 1069| 0| "failed to recover any space, " 1070| 0| "scheduling a full compaction", 1071| 0| qp, TRIENAME(qp)); ------------------ | | 916| 0| triename(qp, (char[DNS_QP_TRIENAME_MAX]){}, DNS_QP_TRIENAME_MAX) | | ------------------ | | | | 306| 0|#define DNS_QP_TRIENAME_MAX 300 | | ------------------ ------------------ 1072| | qp->compact_all = true; 1073| 0| } 1074| 0| } 1075| 2| return destroyed; 1076| 2|} qp.c:iterate: 1944| 231|iterate(bool forward, dns_qpiter_t *qpi, void **pval_r, uint32_t *ival_r) { 1945| 231| dns_qpnode_t *node = NULL; 1946| 231| bool initial_branch = true; 1947| | 1948| 231| REQUIRE(QPITER_VALID(qpi)); ------------------ | | 194| 231|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 462| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 231, False: 0] | | | | | Branch (42:11): [True: 231, False: 0] | | | | ------------------ | | | | 43| 231| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1949| | 1950| 231| dns_qpreader_t *qp = qpi->qp; 1951| | 1952| 231| REQUIRE(QP_VALID(qp)); ------------------ | | 194| 231|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 462| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 231, False: 0] | | | | | Branch (42:11): [True: 231, False: 0] | | | | ------------------ | | | | 43| 231| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1953| | 1954| 231| node = get_root(qp); 1955| 231| if (node == NULL) { ------------------ | Branch (1955:6): [True: 0, False: 231] ------------------ 1956| 0| return ISC_R_NOMORE; 1957| 0| } 1958| | 1959| 308| do { 1960| 308| if (qpi->stack[qpi->sp] == NULL) { ------------------ | Branch (1960:7): [True: 0, False: 308] ------------------ 1961| | /* newly initialized iterator: use the root node */ 1962| 0| INSIST(qpi->sp == 0); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1963| 0| qpi->stack[0] = node; 1964| 308| } else if (!initial_branch) { ------------------ | Branch (1964:14): [True: 0, False: 308] ------------------ 1965| | /* 1966| | * in a prior loop, we reached a branch; from 1967| | * here we just need to get the highest or lowest 1968| | * leaf in the subtree; we don't need to bother 1969| | * stepping forward or backward through twigs 1970| | * anymore. 1971| | */ 1972| 0| INSIST(qpi->sp > 0); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1973| 308| } else if (last_twig(qpi, forward)) { ------------------ | Branch (1973:14): [True: 154, False: 154] ------------------ 1974| | /* 1975| | * we've stepped to the end (or the beginning, 1976| | * if we're iterating backwards) of a set of twigs. 1977| | */ 1978| 154| if (qpi->sp == 0) { ------------------ | Branch (1978:8): [True: 77, False: 77] ------------------ 1979| | /* 1980| | * we've finished iterating. reinitialize 1981| | * the iterator, then return ISC_R_NOMORE. 1982| | */ 1983| 77| dns_qpiter_init(qpi->qp, qpi); 1984| 77| return ISC_R_NOMORE; 1985| 77| } 1986| | 1987| | /* 1988| | * pop the stack, and resume at the parent branch. 1989| | */ 1990| 77| qpi->stack[qpi->sp] = NULL; 1991| 77| qpi->sp--; 1992| 77| continue; 1993| 154| } else { 1994| | /* 1995| | * there are more twigs in the current branch, 1996| | * so step the node pointer forward (or back). 1997| | */ 1998| 154| qpi->stack[qpi->sp] += (forward ? 1 : -1); ------------------ | Branch (1998:28): [True: 154, False: 0] ------------------ 1999| 154| node = qpi->stack[qpi->sp]; 2000| 154| } 2001| | 2002| | /* 2003| | * if we're at a branch now, we loop down to the 2004| | * left- or rightmost leaf. 2005| | */ 2006| 154| if (is_branch(node)) { ------------------ | Branch (2006:7): [True: 0, False: 154] ------------------ 2007| 0| qpi->sp++; 2008| 0| INSIST(qpi->sp < DNS_QP_MAXKEY); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2009| 0| node = ref_ptr(qp, branch_twigs_ref(node)) + 2010| 0| (forward ? 0 : branch_twigs_size(node) - 1); ------------------ | Branch (2010:12): [True: 0, False: 0] ------------------ 2011| 0| qpi->stack[qpi->sp] = node; 2012| 0| initial_branch = false; 2013| 0| } 2014| 231| } while (is_branch(node)); ------------------ | Branch (2014:11): [True: 77, False: 154] ------------------ 2015| | 2016| | /* we're at a leaf: return its data to the caller */ 2017| 154| SET_IF_NOT_NULL(pval_r, leaf_pval(node)); ------------------ | | 100| 154| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 77, False: 77] | | ------------------ | | 101| 77| *(obj) = (val); \ | | 102| 77| } ------------------ 2018| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 100| 154| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 154] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 2019| 154| return ISC_R_SUCCESS; 2020| 231|} qp.c:last_twig: 1925| 308|last_twig(dns_qpiter_t *qpi, bool forward) { 1926| 308| dns_qpweight_t pos = 0, max = 0; 1927| 308| if (qpi->sp > 0) { ------------------ | Branch (1927:6): [True: 231, False: 77] ------------------ 1928| 231| dns_qpnode_t *child = qpi->stack[qpi->sp]; 1929| 231| dns_qpnode_t *parent = qpi->stack[qpi->sp - 1]; 1930| 231| pos = child - ref_ptr(qpi->qp, branch_twigs_ref(parent)); 1931| 231| if (forward) { ------------------ | Branch (1931:7): [True: 231, False: 0] ------------------ 1932| 231| max = branch_twigs_size(parent) - 1; 1933| 231| } 1934| 231| } 1935| 308| return pos == max; 1936| 308|} qp.c:add_link: 2100| 418|add_link(dns_qpchain_t *chain, dns_qpnode_t *node, size_t offset) { 2101| | /* prevent duplication */ 2102| 418| if (chain->len != 0 && chain->chain[chain->len - 1].node == node) { ------------------ | Branch (2102:6): [True: 0, False: 418] | Branch (2102:25): [True: 0, False: 0] ------------------ 2103| 0| return; 2104| 0| } 2105| 418| chain->chain[chain->len].node = node; 2106| 418| chain->chain[chain->len].offset = offset; 2107| 418| chain->len++; 2108| 418| INSIST(chain->len <= DNS_NAME_MAXLABELS); ------------------ | | 198| 418|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 418, False: 0] | | | | ------------------ | | | | 55| 418| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2109| 418|} qp.c:fix_iterator: 2164| 209| size_t len) { 2165| 209| dns_qpnode_t *n = it->stack[it->sp]; 2166| | 2167| 209| REQUIRE(!is_branch(n)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 209| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2168| | 2169| 209| dns_qpkey_t found; 2170| 209| size_t foundlen = leaf_qpkey(qp, n, found); 2171| 209| size_t to = qpkey_compare(key, len, found, foundlen); 2172| | 2173| | /* If the keys are equal, the iterator is already at the right node. */ 2174| 209| if (to == QPKEY_EQUAL) { ------------------ | | 364| 209|#define QPKEY_EQUAL (~(size_t)0) ------------------ | Branch (2174:6): [True: 132, False: 77] ------------------ 2175| 132| return; 2176| 132| } 2177| | 2178| | /* 2179| | * Special case: if the key differs even before the root 2180| | * key offset, it means the name desired either precedes or 2181| | * follows the entire range of names in the database, and 2182| | * popping up the stack won't help us, so just move the 2183| | * iterator one step back from the origin and return. 2184| | */ 2185| 77| if (to < branch_key_offset(it->stack[0])) { ------------------ | Branch (2185:6): [True: 0, False: 77] ------------------ 2186| 0| dns_qpiter_init(qp, it); 2187| 0| prevleaf(it); 2188| 0| return; 2189| 0| } 2190| | 2191| | /* 2192| | * As long as the branch offset point is after the point where the 2193| | * key differs, we need to branch up and find a better node. 2194| | */ 2195| 77| while (it->sp > 0) { ------------------ | Branch (2195:9): [True: 77, False: 0] ------------------ 2196| 77| dns_qpnode_t *b = it->stack[it->sp - 1]; 2197| 77| if (branch_key_offset(b) < to) { ------------------ | Branch (2197:7): [True: 77, False: 0] ------------------ 2198| 77| break; 2199| 77| } 2200| 0| it->sp--; 2201| 0| } 2202| 77| n = it->stack[it->sp]; 2203| | 2204| | /* 2205| | * Either we are now at the correct branch, or we are at the 2206| | * first unmatched node. Determine the bit position for the 2207| | * twig we need (sbit). 2208| | */ 2209| 77| dns_qpshift_t kbit = qpkey_bit(key, len, to); 2210| 77| dns_qpshift_t fbit = qpkey_bit(found, foundlen, to); 2211| 77| dns_qpshift_t sbit = 0; 2212| | 2213| 77| if (is_branch(n) && branch_key_offset(n) == to) { ------------------ | Branch (2213:6): [True: 0, False: 77] | Branch (2213:22): [True: 0, False: 0] ------------------ 2214| | /* We are on the correct branch now. */ 2215| 0| sbit = kbit; 2216| 77| } else if (it->sp == 0) { ------------------ | Branch (2216:13): [True: 0, False: 77] ------------------ 2217| | /* 2218| | * We are on the root branch, popping up the stack won't 2219| | * help us, so just move the iterator one step back from the 2220| | * origin and return. 2221| | */ 2222| 0| dns_qpiter_init(qp, it); 2223| 0| prevleaf(it); 2224| 0| return; 2225| 77| } else { 2226| | /* We are at the first unmatched node, pop up the stack. */ 2227| 77| n = it->stack[--it->sp]; 2228| 77| sbit = qpkey_bit(key, len, branch_key_offset(n)); 2229| 77| } 2230| | 2231| 77| INSIST(is_branch(n)); ------------------ | | 198| 77|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 77| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 77, False: 0] | | | | ------------------ | | | | 55| 77| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2232| | 2233| 77| prefetch_twigs(qp, n); 2234| 77| dns_qpnode_t *twigs = branch_twigs(qp, n); 2235| 77| int toff = twig_offset(n, sbit, kbit, fbit); 2236| 77| if (toff >= 0) { ------------------ | Branch (2236:6): [True: 77, False: 0] ------------------ 2237| | /* 2238| | * The name we want would've been after some twig in 2239| | * this branch. Walk down from that twig to the 2240| | * highest leaf in its subtree to get the predecessor. 2241| | */ 2242| 77| greatest_leaf(qp, twigs + toff, it); 2243| 77| } else { 2244| | /* 2245| | * Every leaf below this node is greater than the one we 2246| | * wanted, so the previous leaf is the predecessor. 2247| | */ 2248| 0| prevleaf(it); 2249| 0| } 2250| 77|} qp.c:twig_offset: 2141| 77| dns_qpshift_t fbit) { 2142| 77| dns_qpweight_t pos = branch_twig_pos(n, sbit); 2143| 77| if (branch_has_twig(n, sbit)) { ------------------ | Branch (2143:6): [True: 77, False: 0] ------------------ 2144| 77| return pos - (kbit < fbit); 2145| 77| } 2146| 0| return pos - 1; 2147| 77|} qp.c:greatest_leaf: 2121| 77|greatest_leaf(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpiter_t *iter) { 2122| 77| while (is_branch(n)) { ------------------ | Branch (2122:9): [True: 0, False: 77] ------------------ 2123| 0| dns_qpref_t ref = branch_twigs_ref(n) + branch_twigs_size(n) - 2124| 0| 1; 2125| 0| iter->stack[++iter->sp] = n; 2126| 0| n = ref_ptr(qpr, ref); 2127| 0| } 2128| 77| iter->stack[++iter->sp] = n; 2129| 77|} qp.c:fix_chain: 2260| 154|fix_chain(dns_qpchain_t *chain, size_t offset) { 2261| 154| while (chain->len > 0 && chain->chain[chain->len - 1].offset >= offset) ------------------ | Branch (2261:9): [True: 0, False: 154] | Branch (2261:27): [True: 0, False: 0] ------------------ 2262| 0| { 2263| 0| chain->len--; 2264| | chain->chain[chain->len].node = NULL; 2265| 0| chain->chain[chain->len].offset = 0; 2266| 0| } 2267| 154|} qp.c:qp_common_character: 930| 512|qp_common_character(uint8_t byte) { 931| 512| return ('-' <= byte && byte <= '9') || ('_' <= byte && byte <= 'z'); ------------------ | Branch (931:10): [True: 422, False: 90] | Branch (931:25): [True: 26, False: 396] | Branch (931:42): [True: 322, False: 164] | Branch (931:57): [True: 56, False: 266] ------------------ 932| 512|} qp.c:qpkey_bit: 671| 14.8k|qpkey_bit(const dns_qpkey_t key, size_t len, size_t offset) { 672| 14.8k| if (offset < len) { ------------------ | Branch (672:6): [True: 14.4k, False: 349] ------------------ 673| 14.4k| return key[offset]; 674| 14.4k| } else { 675| 349| return SHIFT_NOBYTE; 676| 349| } 677| 14.8k|} qp.c:make_ref: 210| 24|make_ref(dns_qpchunk_t chunk, dns_qpcell_t cell) { 211| 24| return QP_CHUNK_SIZE * chunk + cell; ------------------ | | 159| 24|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 148| 24|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 212| 24|} qp.c:ref_chunk: 215| 1.91k|ref_chunk(dns_qpref_t ref) { 216| 1.91k| return ref / QP_CHUNK_SIZE; ------------------ | | 159| 1.91k|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 148| 1.91k|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 217| 1.91k|} qp.c:ref_cell: 220| 1.90k|ref_cell(dns_qpref_t ref) { 221| 1.90k| return ref % QP_CHUNK_SIZE; ------------------ | | 159| 1.90k|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 148| 1.90k|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 222| 1.90k|} qp.c:zero_twigs: 802| 2|zero_twigs(dns_qpnode_t *twigs, dns_qpweight_t size) { 803| 2| memset(twigs, 0, size * sizeof(dns_qpnode_t)); 804| 2|} qp.c:ref_ptr: 357| 1.89k|ref_ptr(dns_qpreadable_t qpr, dns_qpref_t ref) { 358| 1.89k| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 1.89k|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 359| 1.89k| return qp->base->ptr[ref_chunk(ref)] + ref_cell(ref); 360| 1.89k|} qp.c:make_reader: 847| 8|make_reader(dns_qpnode_t *reader, dns_qpmulti_t *multi) { 848| 8| dns_qp_t *qp = &multi->writer; 849| 8| reader[0] = make_node(READER_TAG | (uintptr_t)multi, QPREADER_MAGIC); ------------------ | | 371| 8|#define QPREADER_MAGIC ISC_MAGIC('q', 'p', 'r', 'x') | | ------------------ | | | | 31| 8|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 850| 8| reader[1] = make_node(READER_TAG | (uintptr_t)qp->base, qp->root_ref); 851| 8|} qp.c:node_tag: 602| 1.18k|node_tag(dns_qpnode_t *n) { 603| 1.18k| return n->biglo & TAG_MASK; 604| 1.18k|} qp.c:node_pointer: 594| 2.66k|node_pointer(dns_qpnode_t *n) { 595| 2.66k| return (void *)(uintptr_t)(node64(n) & ~TAG_MASK); 596| 2.66k|} qp.c:node64: 563| 4.16k|node64(dns_qpnode_t *n) { 564| 4.16k| uint64_t lo = n->biglo; 565| 4.16k| uint64_t hi = n->bighi; 566| 4.16k| return lo | (hi << 32); 567| 4.16k|} qp.c:reader_valid: 854| 587|reader_valid(dns_qpnode_t *reader) { 855| 587| return reader != NULL && // ------------------ | Branch (855:9): [True: 587, False: 0] ------------------ 856| 587| node_tag(&reader[0]) == READER_TAG && ------------------ | Branch (856:9): [True: 587, False: 0] ------------------ 857| 587| node_tag(&reader[1]) == READER_TAG && ------------------ | Branch (857:9): [True: 587, False: 0] ------------------ 858| 587| node32(&reader[0]) == QPREADER_MAGIC; ------------------ | | 371| 587|#define QPREADER_MAGIC ISC_MAGIC('q', 'p', 'r', 'x') | | ------------------ | | | | 31| 1.17k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ | Branch (858:9): [True: 587, False: 0] ------------------ 859| 587|} qp.c:node32: 573| 3.04k|node32(dns_qpnode_t *n) { 574| 3.04k| return n->small; 575| 3.04k|} qp.c:unpack_reader: 866| 587|unpack_reader(dns_qpreader_t *qp, dns_qpnode_t *reader) { 867| 587| INSIST(reader_valid(reader)); ------------------ | | 198| 587|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 587| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 587, False: 0] | | | | ------------------ | | | | 55| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 868| 587| dns_qpmulti_t *multi = node_pointer(&reader[0]); 869| 587| dns_qpbase_t *base = node_pointer(&reader[1]); 870| 587| INSIST(QPMULTI_VALID(multi)); ------------------ | | 198| 587|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 587, False: 0] | | | | | Branch (54:11): [True: 587, False: 0] | | | | ------------------ | | | | 55| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 871| 587| INSIST(QPBASE_VALID(base)); ------------------ | | 198| 587|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 587, False: 0] | | | | | Branch (54:11): [True: 587, False: 0] | | | | ------------------ | | | | 55| 587| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 872| 587| *qp = (dns_qpreader_t){ 873| 587| .magic = QP_MAGIC, ------------------ | | 367| 587|#define QP_MAGIC ISC_MAGIC('t', 'r', 'i', 'e') | | ------------------ | | | | 31| 587|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 874| 587| .uctx = multi->writer.uctx, 875| 587| .methods = multi->writer.methods, 876| 587| .root_ref = node32(&reader[1]), 877| 587| .base = base, 878| 587| }; 879| 587| return multi; 880| 587|} qp.c:make_leaf: 636| 10|make_leaf(const void *pval, uint32_t ival) { 637| 10| dns_qpnode_t leaf = make_node((uintptr_t)pval, ival); 638| 10| REQUIRE(node_tag(&leaf) == LEAF_TAG); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 639| 10| return leaf; 640| 10|} qp.c:leaf_qpkey: 900| 816|leaf_qpkey(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpkey_t key) { 901| 816| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 816|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 902| 816| size_t len = qp->methods->makekey(key, qp->uctx, leaf_pval(n), 903| 816| leaf_ival(n)); 904| 816| INSIST(len < sizeof(dns_qpkey_t)); ------------------ | | 198| 816|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 816| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 816, False: 0] | | | | ------------------ | | | | 55| 816| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 905| 816| return len; 906| 816|} qp.c:attach_leaf: 888| 10|attach_leaf(dns_qpreadable_t qpr, dns_qpnode_t *n) { 889| 10| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 10|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 890| 10| qp->methods->attach(qp->uctx, leaf_pval(n), leaf_ival(n)); 891| 10|} qp.c:is_branch: 610| 2.30k|is_branch(dns_qpnode_t *n) { 611| 2.30k| return n->biglo & BRANCH_TAG; 612| 2.30k|} qp.c:prefetch_twigs: 708| 302|prefetch_twigs(dns_qpreadable_t qpr, dns_qpnode_t *n) { 709| 302| __builtin_prefetch(ref_ptr(qpr, branch_twigs_ref(n))); 710| 302|} qp.c:branch_twigs_ref: 662| 1.04k|branch_twigs_ref(dns_qpnode_t *n) { 663| 1.04k| return node32(n); 664| 1.04k|} qp.c:branch_keybit: 691| 14|branch_keybit(dns_qpnode_t *n, const dns_qpkey_t key, size_t len) { 692| 14| return qpkey_bit(key, len, branch_key_offset(n)); 693| 14|} qp.c:branch_has_twig: 790| 511|branch_has_twig(dns_qpnode_t *n, dns_qpshift_t bit) { 791| 511| return branch_index(n) & (1ULL << bit); 792| 511|} qp.c:branch_twig_pos: 774| 300|branch_twig_pos(dns_qpnode_t *n, dns_qpshift_t bit) { 775| 300| return branch_count_bitmap_before(n, bit); 776| 300|} qp.c:branch_count_bitmap_before: 753| 533|branch_count_bitmap_before(dns_qpnode_t *n, dns_qpshift_t bit) { 754| 533| uint64_t mask = (1ULL << bit) - 1 - TAG_MASK; 755| 533| uint64_t bitmap = branch_index(n) & mask; 756| 533| return (dns_qpweight_t)stdc_count_ones(bitmap); ------------------ | | 29| 533|#define stdc_count_ones(x) __builtin_popcountg(x) ------------------ 757| 533|} qp.c:branch_key_offset: 683| 458|branch_key_offset(dns_qpnode_t *n) { 684| 458| return (size_t)(branch_index(n) >> SHIFT_OFFSET); 685| 458|} qp.c:branch_twig_ptr: 782| 221|branch_twig_ptr(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpshift_t bit) { 783| 221| return ref_ptr(qpr, branch_twigs_ref(n) + branch_twig_pos(n, bit)); 784| 221|} qp.c:make_node: 581| 30|make_node(uint64_t big, uint32_t small) { 582| 30| return (dns_qpnode_t){ 583| 30| .biglo = (uint32_t)(big), 584| 30| .bighi = (uint32_t)(big >> 32), 585| 30| .small = small, 586| 30| }; 587| 30|} qp.c:branch_twigs_size: 766| 233|branch_twigs_size(dns_qpnode_t *n) { 767| 233| return branch_count_bitmap_before(n, SHIFT_OFFSET); 768| 233|} qp.c:branch_index: 654| 1.50k|branch_index(dns_qpnode_t *n) { 655| 1.50k| return node64(n); 656| 1.50k|} qp.c:move_twigs: 797| 4|move_twigs(dns_qpnode_t *to, dns_qpnode_t *from, dns_qpweight_t size) { 798| 4| memmove(to, from, size * sizeof(dns_qpnode_t)); 799| 4|} qp.c:get_root: 718| 826|get_root(dns_qpreadable_t qpr) { 719| 826| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 826|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 720| 826| if (qp->root_ref == INVALID_REF) { ------------------ | | 229| 826|#define INVALID_REF ((dns_qpref_t)~0UL) ------------------ | Branch (720:6): [True: 2, False: 824] ------------------ 721| 2| return NULL; 722| 824| } else { 723| 824| return ref_ptr(qp, qp->root_ref); 724| 824| } 725| 826|} qp.c:leaf_pval: 620| 1.48k|leaf_pval(dns_qpnode_t *n) { 621| 1.48k| return node_pointer(n); 622| 1.48k|} qp.c:leaf_ival: 628| 826|leaf_ival(dns_qpnode_t *n) { 629| 826| return node32(n); 630| 826|} qp.c:branch_twigs: 700| 286|branch_twigs(dns_qpreadable_t qpr, dns_qpnode_t *n) { 701| 286| return ref_ptr(qpr, branch_twigs_ref(n)); 702| 286|} dns__qpzone_initialize: 471| 2|dns__qpzone_initialize(void) { 472| 2.05k| for (size_t idx = 0; idx < ARRAY_SIZE(qpzone_buckets_g); ++idx) { ------------------ | | 94| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (472:23): [True: 2.04k, False: 2] ------------------ 473| 2.04k| NODE_INITLOCK(&qpzone_buckets_g[idx].lock); ------------------ | | 28| 2.04k|#define NODE_INITLOCK(l) isc_rwlock_init((l)) ------------------ 474| 2.04k| } 475| 2|} dns__qpzone_create: 861| 2| dns_db_t **dbp) { 862| 2| qpzonedb_t *qpdb = NULL; 863| 2| isc_result_t result; 864| 2| dns_qp_t *qp = NULL; 865| | 866| 2| qpdb = isc_mem_get(mctx, sizeof(*qpdb)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 867| 2| *qpdb = (qpzonedb_t){ 868| 2| .common.origin = DNS_NAME_INITEMPTY, ------------------ | | 183| 4| { .magic = DNS_NAME_MAGIC, \ | | ------------------ | | | | 121| 2|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | | | ------------------ | | | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 184| 4| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 2| { \ | | | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 2| } | | | | ------------------ | | ------------------ | | 185| 4| .list = ISC_LIST_INITIALIZER } | | ------------------ | | | | 21| 2| { \ | | | | 22| 2| .head = NULL, \ | | | | 23| 2| .tail = NULL, \ | | | | 24| 2| } | | ------------------ ------------------ 869| 2| .common.rdclass = rdclass, 870| 2| .common.references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 871| 2| .current_serial = 1, 872| 2| .least_serial = 1, 873| 2| .next_serial = 2, 874| 2| .open_versions = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 875| 2| }; 876| | 877| 2| qpdb->common.methods = &qpdb_zonemethods; 878| 2| if (type == dns_dbtype_stub) { ------------------ | Branch (878:6): [True: 0, False: 2] ------------------ 879| 0| qpdb->common.attributes |= DNS_DBATTR_STUB; 880| 0| } 881| | 882| 2| isc_rwlock_init(&qpdb->lock); 883| | 884| 2| qpdb->common.update_listeners = cds_lfht_new(16, 16, 0, 0, NULL); 885| | 886| 2| qpdb->heap = new_qpz_heap(mctx); 887| | 888| | /* 889| | * Attach to the mctx. The database will persist so long as there 890| | * are references to it, and attaching to the mctx ensures that our 891| | * mctx won't disappear out from under us. 892| | */ 893| 2| isc_mem_attach(mctx, &qpdb->common.mctx); 894| | 895| | /* 896| | * Make a copy of the origin name. 897| | */ 898| 2| dns_name_dup(origin, mctx, &qpdb->common.origin); 899| | 900| 2| dns_qpmulti_create(mctx, &qpmethods, qpdb, &qpdb->tree); 901| | 902| | /* 903| | * Version initialization. 904| | */ 905| 2| qpdb->current_version = allocate_version(mctx, 1, 1, false); 906| 2| qpdb->current_version->qpdb = qpdb; 907| | 908| 2| dns_qpmulti_write(qpdb->tree, &qp); 909| | 910| | /* 911| | * In order to set the node callback bit correctly in zone databases, 912| | * we need to know if the node has the origin name of the zone. 913| | * In loading_addrdataset() we could simply compare the new name 914| | * to the origin name, but this is expensive. Also, we don't know the 915| | * node name in addrdataset(), so we need another way of knowing the 916| | * zone's top. 917| | * 918| | * We now explicitly create a node for the zone's origin, and then 919| | * we simply remember the node data's address. 920| | */ 921| 2| qpdb->origin = new_qpznode(qpdb, &qpdb->common.origin, 922| 2| DNS_DBNAMESPACE_NORMAL); 923| | 924| 2| result = dns_qp_insert(qp, qpdb->origin, 0); 925| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 926| | 927| | /* 928| | * Add an apex node to the NSEC tree so that we can quickly skip over 929| | * the NSEC nodes while iterating over the full tree. 930| | */ 931| 2| qpdb->nsec_origin = new_qpznode(qpdb, &qpdb->common.origin, 932| 2| DNS_DBNAMESPACE_NSEC); 933| 2| result = dns_qp_insert(qp, qpdb->nsec_origin, 0); 934| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 935| | 936| | /* 937| | * Add an apex node to the NSEC3 tree so that NSEC3 searches 938| | * return partial matches when there is only a single NSEC3 939| | * record in the tree. 940| | */ 941| 2| qpdb->nsec3_origin = new_qpznode(qpdb, &qpdb->common.origin, 942| 2| DNS_DBNAMESPACE_NSEC3); 943| 2| result = dns_qp_insert(qp, qpdb->nsec3_origin, 0); 944| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 945| | 946| 2| dns_qpmulti_commit(qpdb->tree, &qp); 947| | 948| | /* 949| | * Keep the current version in the open list so that list operation 950| | * won't happen in normal lookup operations. 951| | */ 952| 2| ISC_LIST_PREPEND(qpdb->open_versions, qpdb->current_version, link); ------------------ | | 79| 2| do { \ | | 80| 2| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 2| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 2| do { \ | | | | 68| 2| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 0, False: 2] | | | | ------------------ | | | | 69| 0| (list).head->link.prev = (elt); \ | | | | 70| 2| } else { \ | | | | 71| 2| (list).tail = (elt); \ | | | | 72| 2| } \ | | | | 73| 2| (elt)->link.prev = NULL; \ | | | | 74| 2| (elt)->link.next = (list).head; \ | | | | 75| 2| (list).head = (elt); \ | | | | 76| 2| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 2] | | | | ------------------ | | ------------------ | | 82| 2| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 2] | | ------------------ ------------------ 953| | 954| 2| qpdb->common.magic = DNS_DB_MAGIC; ------------------ | | 186| 2|#define DNS_DB_MAGIC ISC_MAGIC('D', 'N', 'S', 'D') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 955| 2| qpdb->common.impmagic = QPZONE_DB_MAGIC; ------------------ | | 84| 2|#define QPZONE_DB_MAGIC ISC_MAGIC('Q', 'Z', 'D', 'B') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 956| | 957| 2| *dbp = (dns_db_t *)qpdb; 958| | 959| 2| return ISC_R_SUCCESS; 960| 2|} qpzone.c:new_qpz_heap: 765| 2|new_qpz_heap(isc_mem_t *mctx) { 766| 2| qpz_heap_t *new_heap = isc_mem_get(mctx, sizeof(*new_heap)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 767| 2| *new_heap = (qpz_heap_t){ 768| 2| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 769| 2| }; 770| | 771| 2| isc_mutex_init(&new_heap->lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 772| 2| isc_heap_create(mctx, resign_sooner, set_index, 0, &new_heap->heap); 773| 2| isc_mem_attach(mctx, &new_heap->mctx); 774| | 775| 2| isc_hashmap_create(mctx, 1u, &new_heap->hashmap); 776| | 777| 2| return new_heap; 778| 2|} qpzone.c:qp_attach: 5719| 6| uint32_t ival ISC_ATTR_UNUSED) { 5720| 6| qpznode_t *data = pval; 5721| 6| qpznode_ref(data); 5722| 6|} qpzone.c:qp_makekey: 5733| 440| uint32_t ival ISC_ATTR_UNUSED) { 5734| 440| qpznode_t *data = pval; 5735| 440| return dns_qpkey_fromname(key, &data->name, data->nspace); 5736| 440|} qpzone.c:allocate_version: 840| 2| bool writer) { 841| 2| qpz_version_t *version = isc_mem_get(mctx, sizeof(*version)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 842| 2| *version = (qpz_version_t){ 843| 2| .serial = serial, 844| 2| .writer = writer, 845| 2| .changed_list = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 846| 2| .resigned_list = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 847| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 848| 2| .references = ISC_REFCOUNT_INITIALIZER(references), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 849| 2| }; 850| | 851| 2| cds_wfs_init(&version->glue_stack); 852| 2| isc_rwlock_init(&version->rwlock); 853| | 854| 2| return version; 855| 2|} qpzone.c:new_qpznode: 817| 6|new_qpznode(qpzonedb_t *qpdb, const dns_name_t *name, dns_namespace_t nspace) { 818| 6| qpznode_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata)); ------------------ | | 128| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 819| 6| *newdata = (qpznode_t){ 820| 6| .next_type = ISC_SLIST_INITIALIZER, ------------------ | | 25| 6| { \ | | 26| 6| .head = NULL, \ | | 27| 6| } ------------------ 821| 6| .methods = &qpznode_methods, 822| 6| .name = DNS_NAME_INITEMPTY, ------------------ | | 183| 6| { .magic = DNS_NAME_MAGIC, \ | | ------------------ | | | | 121| 6|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | | | ------------------ | | | | | | 31| 6|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 184| 6| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 6|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 6| { \ | | | | | | 27| 6| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 6| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 6| } | | | | ------------------ | | ------------------ | | 185| 6| .list = ISC_LIST_INITIALIZER } | | ------------------ | | | | 21| 6| { \ | | | | 22| 6| .head = NULL, \ | | | | 23| 6| .tail = NULL, \ | | | | 24| 6| } | | ------------------ ------------------ 823| 6| .nspace = nspace, 824| 6| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 6|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 825| 6| .locknum = qpzone_get_locknum(), 826| 6| }; 827| | 828| 6| isc_mem_attach(qpdb->common.mctx, &newdata->mctx); 829| 6| dns_name_dup(name, qpdb->common.mctx, &newdata->name); 830| | 831| |#if DNS_DB_NODETRACE 832| | fprintf(stderr, "new_qpznode:%s:%s:%d:%p->references = 1\n", __func__, 833| | __FILE__, __LINE__ + 1, name); 834| |#endif 835| 6| return newdata; 836| 6|} qpzone.c:qpzone_get_locknum: 490| 6|qpzone_get_locknum(void) { 491| 6| return isc_random_uniform(ARRAY_SIZE(qpzone_buckets_g)); ------------------ | | 94| 6|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ 492| 6|} qpzone.c:qpznode_acquire: 984| 140|qpznode_acquire(qpznode_t *node DNS__DB_FLARG) { 985| 140| qpznode_ref(node); 986| 140| qpznode_erefs_increment(node DNS__DB_FLARG_PASS); 987| 140|} qpzone.c:qpznode_erefs_increment: 971| 140|qpznode_erefs_increment(qpznode_t *node DNS__DB_FLARG) { 972| 140| uint_fast32_t refs = isc_refcount_increment0(&node->erefs); ------------------ | | 68| 140| ({ \ | | 69| 140| uint_fast32_t __v; \ | | 70| 140| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 140| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 71| 140| INSIST(__v < UINT32_MAX); \ | | ------------------ | | | | 198| 140|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 140| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 140, False: 0] | | | | | | ------------------ | | | | | | 55| 140| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 140| __v; \ | | 73| 140| }) ------------------ 973| |#if DNS_DB_NODETRACE 974| | fprintf(stderr, "incr:node:%s:%s:%u:%p->erefs = %" PRIuFAST32 "\n", 975| | func, file, line, node, refs + 1); 976| |#endif 977| | 978| 140| if (refs > 0) { ------------------ | Branch (978:6): [True: 0, False: 140] ------------------ 979| 0| return; 980| 0| } 981| 140|} qpzone.c:qpzone_detachnode: 4011| 140|qpzone_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) { 4012| 140| qpznode_t *node = NULL; 4013| 140| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 4014| 140| isc_rwlock_t *nlock = NULL; 4015| | 4016| 140| REQUIRE(nodep != NULL && *nodep != NULL); ------------------ | | 194| 140|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 280| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 140, False: 0] | | | | | Branch (42:11): [True: 140, False: 0] | | | | ------------------ | | | | 43| 140| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4017| | 4018| 140| node = (qpznode_t *)(*nodep); 4019| | 4020| 140| *nodep = NULL; 4021| 140| nlock = qpzone_get_lock(node); 4022| | 4023| | /* 4024| | * qpzone_destroy() uses call_rcu() API to destroy the node locks, so it 4025| | * is safe to call it in the middle of NODE_LOCK, but we need to acquire 4026| | * the database reference to prevent destroying the database while the 4027| | * NODE_LOCK is locked. 4028| | */ 4029| | 4030| 140| rcu_read_lock(); 4031| 140| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 140|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 140| { \ | | | | 32| 140| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 140| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 140| { \ | | | | | | 31| 140| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 140| (t), __FILE__, __LINE__)); \ | | | | | | 33| 140| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 140| { \ | | | | | | | | 253| 140| switch (type) { \ | | | | | | | | 254| 140| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 140, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 140| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 140| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 140] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 140] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 140| } \ | | | | | | | | 263| 140| } | | | | | | ------------------ | | | | | | 34| 140| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 140| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 140| } | | | | ------------------ | | | | 34| 140| *tp = t; \ | | | | 35| 140| } | | ------------------ ------------------ 4032| 140| (void)qpznode_release(node DNS__DB_FLARG_PASS); 4033| 140| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 140| { \ | | 38| 140| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 140| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 140| { \ | | | | 39| 140| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 140| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 140| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 140| { \ | | | | | | 283| 140| switch (type) { \ | | | | | | 284| 140| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 140, False: 0] | | | | | | ------------------ | | | | | | 285| 140| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 140| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 140] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 140] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 140| } \ | | | | | | 293| 140| } | | | | ------------------ | | | | 42| 140| } | | ------------------ | | 40| 140| *tp = isc_rwlocktype_none; \ | | 41| 140| } ------------------ 4034| | rcu_read_unlock(); 4035| 140|} qpzone.c:qpzone_get_lock: 485| 523|qpzone_get_lock(qpznode_t *node) { 486| 523| return &qpzone_buckets_g[node->locknum].lock; 487| 523|} qpzone.c:qpznode_release: 1145| 140|qpznode_release(qpznode_t *node DNS__DB_FLARG) { 1146| 140| bool has_erefs = false; 1147| | 1148| 140| if (!qpznode_erefs_decrement(node DNS__DB_FLARG_PASS)) { ------------------ | Branch (1148:6): [True: 0, False: 140] ------------------ 1149| 0| has_erefs = true; 1150| 0| goto unref; 1151| 0| } 1152| | 1153| | /* Handle easy and typical case first. */ 1154| 140| if (!node->dirty && !ISC_SLIST_EMPTY(node->next_type)) { ------------------ | | 45| 140|#define ISC_SLIST_EMPTY(list) ((list).head == NULL) ------------------ | Branch (1154:6): [True: 140, False: 0] | Branch (1154:22): [True: 140, False: 0] ------------------ 1155| 140| has_erefs = true; 1156| 140| goto unref; 1157| 140| } 1158| | 1159| 140|unref: 1160| 140| qpznode_unref(node); 1161| 140| return has_erefs; 1162| 140|} qpzone.c:qpznode_erefs_decrement: 1118| 140|qpznode_erefs_decrement(qpznode_t *node DNS__DB_FLARG) { 1119| 140| uint_fast32_t refs = isc_refcount_decrement(&node->erefs); ------------------ | | 94| 140| ({ \ | | 95| 140| uint_fast32_t __v; \ | | 96| 140| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 140| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 140| INSIST(__v > 0); \ | | ------------------ | | | | 198| 140|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 140| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 140, False: 0] | | | | | | ------------------ | | | | | | 55| 140| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 140| __v; \ | | 99| 140| }) ------------------ 1120| | 1121| |#if DNS_DB_NODETRACE 1122| | fprintf(stderr, "decr:node:%s:%s:%u:%p->erefs = %" PRIuFAST32 "\n", 1123| | func, file, line, node, refs - 1); 1124| |#endif 1125| 140| if (refs > 1) { ------------------ | Branch (1125:6): [True: 0, False: 140] ------------------ 1126| 0| return false; 1127| 0| } 1128| | 1129| 140| return true; 1130| 140|} qpzone.c:beginload: 2310| 2|beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 2311| 2| qpz_load_t *loadctx = NULL; 2312| 2| qpzonedb_t *qpdb = NULL; 2313| 2| qpdb = (qpzonedb_t *)db; 2314| | 2315| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2316| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2317| | 2318| 2| loadctx = isc_mem_get(qpdb->common.mctx, sizeof(*loadctx)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 2319| 2| *loadctx = (qpz_load_t){ .db = db }; 2320| | 2321| 2| RWLOCK(&qpdb->lock, isc_rwlocktype_write); ------------------ | | 30| 2| { \ | | 31| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 2| (t), __FILE__, __LINE__)); \ | | 33| 2| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 2| { \ | | | | 253| 2| switch (type) { \ | | | | 254| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 0, False: 2] | | | | ------------------ | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | 256| 0| break; \ | | | | 257| 2| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 2, False: 0] | | | | ------------------ | | | | 258| 2| isc_rwlock_wrlock(rwl); \ | | | | 259| 2| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 2] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 2| } \ | | | | 263| 2| } | | ------------------ | | 34| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 2| (lp), (t), __FILE__, __LINE__)); \ | | 36| 2| } ------------------ 2322| | 2323| 2| REQUIRE((qpdb->attributes & (QPDB_ATTR_LOADED | QPDB_ATTR_LOADING)) == ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2324| 2| 0); 2325| 2| qpdb->attributes |= QPDB_ATTR_LOADING; ------------------ | | 71| 2|#define QPDB_ATTR_LOADING 0x02 ------------------ 2326| | 2327| 2| RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); ------------------ | | 38| 2| { \ | | 39| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 2| (lp), (t), __FILE__, __LINE__)); \ | | 41| 2| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 2| { \ | | | | 283| 2| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 2] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 2| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 2, False: 0] | | | | ------------------ | | | | 288| 2| isc_rwlock_wrunlock(rwl); \ | | | | 289| 2| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 2] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 2328| | 2329| 2| callbacks->update = loading_addrdataset; 2330| 2| callbacks->setup = loading_setup; 2331| 2| callbacks->commit = loading_commit; 2332| 2| callbacks->add_private = loadctx; 2333| | 2334| 2| return ISC_R_SUCCESS; 2335| 2|} qpzone.c:loading_addrdataset: 2204| 6| dns_diffop_t op ISC_ATTR_UNUSED DNS__DB_FLARG) { 2205| 6| qpz_load_t *loadctx = arg; 2206| 6| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2207| 6| qpznode_t *node = NULL; 2208| 6| isc_result_t result = ISC_R_SUCCESS; 2209| 6| isc_region_t region; 2210| 6| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 2211| 6| isc_rwlock_t *nlock = NULL; 2212| | 2213| 6| REQUIRE(rdataset->rdclass == qpdb->common.rdclass); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2214| | 2215| | /* 2216| | * SOA records are only allowed at top of zone. 2217| | */ 2218| 6| if (rdataset->type == dns_rdatatype_soa && ------------------ | | 120| 12|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (2218:6): [True: 2, False: 4] ------------------ 2219| 2| !dns_name_equal(name, &qpdb->common.origin)) ------------------ | Branch (2219:6): [True: 0, False: 2] ------------------ 2220| 0| { 2221| 0| return DNS_R_NOTZONETOP; 2222| 0| } 2223| | 2224| 6| if (rdataset->type != dns_rdatatype_nsec3 && ------------------ | | 164| 12|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2224:6): [True: 6, False: 0] ------------------ 2225| 6| rdataset->covers != dns_rdatatype_nsec3) ------------------ | | 164| 6|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2225:6): [True: 6, False: 0] ------------------ 2226| 6| { 2227| 6| addwildcards(qpdb, loadctx->tree, name, DNS_DBNAMESPACE_NORMAL); 2228| 6| } 2229| | 2230| 6| if (dns_name_iswildcard(name)) { ------------------ | Branch (2230:6): [True: 0, False: 6] ------------------ 2231| 0| if (rdataset->type == dns_rdatatype_ns) { ------------------ | | 116| 0|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (2231:7): [True: 0, False: 0] ------------------ 2232| | /* 2233| | * NS owners cannot legally be wild cards. 2234| | */ 2235| 0| return DNS_R_INVALIDNS; 2236| 0| } 2237| | 2238| 0| if (rdataset->type == dns_rdatatype_nsec3) { ------------------ | | 164| 0|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2238:7): [True: 0, False: 0] ------------------ 2239| | /* 2240| | * NSEC3 owners cannot legally be wild cards. 2241| | */ 2242| 0| return DNS_R_INVALIDNSEC3; 2243| 0| } 2244| | 2245| 0| wildcardmagic(qpdb, loadctx->tree, name, 2246| 0| DNS_DBNAMESPACE_NORMAL); 2247| 0| } 2248| | 2249| 6| loading_addnode(loadctx, name, rdataset->type, rdataset->covers, &node); 2250| 6| result = dns_rdatavec_fromrdataset(rdataset, node->mctx, ®ion, 2251| 6| qpdb->maxrrperset); 2252| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2252:6): [True: 0, False: 6] ------------------ 2253| 0| if (result == DNS_R_TOOMANYRECORDS) { ------------------ | Branch (2253:7): [True: 0, False: 0] ------------------ 2254| 0| dns__db_logtoomanyrecords((dns_db_t *)qpdb, name, 2255| 0| rdataset->type, "adding", 2256| 0| qpdb->maxrrperset); 2257| 0| } 2258| 0| return result; 2259| 0| } 2260| | 2261| 6| dns_vecheader_t *newheader = (dns_vecheader_t *)region.base; 2262| 6| newheader->ttl = rdataset->ttl; 2263| 6| newheader->serial = 1; 2264| 6| atomic_store(&newheader->trust, rdataset->trust); 2265| | 2266| 6| dns_vecheader_setownercase(newheader, name); 2267| | 2268| 6| if (rdataset->attributes.resign) { ------------------ | Branch (2268:6): [True: 0, False: 6] ------------------ 2269| 0| DNS_VECHEADER_SETATTR(newheader, DNS_VECHEADERATTR_RESIGN); ------------------ | | 143| 0| atomic_fetch_or_release(&(header)->attributes, attribute) | | ------------------ | | | | 58| 0| atomic_fetch_or_explicit((o), (v), memory_order_release) | | ------------------ ------------------ 2270| 0| newheader->resign = dns_time64_from32(rdataset->resign); 2271| 0| } 2272| | 2273| 6| nlock = qpzone_get_lock(node); 2274| 6| NODE_WRLOCK(nlock, &nlocktype); ------------------ | | 43| 6|#define NODE_WRLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_write, tp); | | ------------------ | | | | 31| 6| { \ | | | | 32| 6| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 6| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 6| { \ | | | | | | 31| 6| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 6| (t), __FILE__, __LINE__)); \ | | | | | | 33| 6| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 6| { \ | | | | | | | | 253| 6| switch (type) { \ | | | | | | | | 254| 0| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 0| break; \ | | | | | | | | 257| 6| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 258| 6| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 6| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 6] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 6| } \ | | | | | | | | 263| 6| } | | | | | | ------------------ | | | | | | 34| 6| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 6| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 6| } | | | | ------------------ | | | | 34| 6| *tp = t; \ | | | | 35| 6| } | | ------------------ ------------------ 2275| 6| result = add(qpdb, node, name, qpdb->current_version, newheader, 2276| 6| DNS_DBADD_MERGE, true, NULL, 0 DNS__DB_FLARG_PASS); ------------------ | | 298| 6|#define DNS_DBADD_MERGE 0x01 ------------------ 2277| 6| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 6| { \ | | 38| 6| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 6| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 6| { \ | | | | 39| 6| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 6| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 6| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 6| { \ | | | | | | 283| 6| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 6| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 6, False: 0] | | | | | | ------------------ | | | | | | 288| 6| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 6| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 6| } \ | | | | | | 293| 6| } | | | | ------------------ | | | | 42| 6| } | | ------------------ | | 40| 6| *tp = isc_rwlocktype_none; \ | | 41| 6| } ------------------ 2278| | 2279| 6| if (result == ISC_R_SUCCESS && ------------------ | Branch (2279:6): [True: 6, False: 0] ------------------ 2280| 6| delegating_type(qpdb, node, rdataset->type)) ------------------ | Branch (2280:6): [True: 0, False: 6] ------------------ 2281| 0| { 2282| 0| node->delegating = true; 2283| 6| } else if (result == DNS_R_UNCHANGED) { ------------------ | Branch (2283:13): [True: 0, False: 6] ------------------ 2284| 0| result = ISC_R_SUCCESS; 2285| 0| } 2286| | 2287| 6| return result; 2288| 6|} qpzone.c:addwildcards: 2184| 6| dns_namespace_t nspace) { 2185| 6| dns_name_t foundname; 2186| 6| unsigned int n, l, i; 2187| | 2188| 6| dns_name_init(&foundname); 2189| 6| n = dns_name_countlabels(name); 2190| 6| l = dns_name_countlabels(&qpdb->common.origin); 2191| 6| i = l + 1; 2192| 6| while (i < n) { ------------------ | Branch (2192:9): [True: 0, False: 6] ------------------ 2193| 0| dns_name_getlabelsequence(name, n - i, i, &foundname); 2194| 0| if (dns_name_iswildcard(&foundname)) { ------------------ | Branch (2194:7): [True: 0, False: 0] ------------------ 2195| 0| wildcardmagic(qpdb, qp, &foundname, nspace); 2196| 0| } 2197| | 2198| 0| i++; 2199| 0| } 2200| 6|} qpzone.c:loading_addnode: 1761| 6| qpznode_t **nodep) { 1762| 6| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 1763| 6| isc_result_t result; 1764| 6| qpznode_t *node = NULL, *nsecnode = NULL; 1765| | 1766| 6| if (type == dns_rdatatype_nsec3 || covers == dns_rdatatype_nsec3) { ------------------ | | 164| 12|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ if (type == dns_rdatatype_nsec3 || covers == dns_rdatatype_nsec3) { ------------------ | | 164| 6|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1766:6): [True: 0, False: 6] | Branch (1766:37): [True: 0, False: 6] ------------------ 1767| 0| result = dns_qp_getname(loadctx->tree, name, 1768| 0| DNS_DBNAMESPACE_NSEC3, (void **)&node, 1769| 0| NULL); 1770| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1770:7): [True: 0, False: 0] ------------------ 1771| 0| *nodep = node; 1772| 0| } else { 1773| 0| node = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NSEC3); 1774| 0| result = dns_qp_insert(loadctx->tree, node, 0); 1775| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1776| 0| *nodep = node; 1777| 0| qpznode_detach(&node); 1778| 0| } 1779| 0| return; 1780| 0| } 1781| | 1782| 6| result = dns_qp_getname(loadctx->tree, name, DNS_DBNAMESPACE_NORMAL, 1783| 6| (void **)&node, NULL); 1784| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1784:6): [True: 6, False: 0] ------------------ 1785| 6| if (type == dns_rdatatype_nsec && node->havensec) { ------------------ | | 161| 12|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1785:7): [True: 0, False: 6] | Branch (1785:37): [True: 0, False: 0] ------------------ 1786| 0| goto done; 1787| 0| } 1788| 6| } else { 1789| 0| INSIST(node == NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1790| 0| node = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NORMAL); 1791| 0| result = dns_qp_insert(loadctx->tree, node, 0); 1792| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1793| 0| qpznode_unref(node); 1794| 0| } 1795| 6| if (type != dns_rdatatype_nsec) { ------------------ | | 161| 6|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1795:6): [True: 6, False: 0] ------------------ 1796| 6| goto done; 1797| 6| } 1798| | 1799| | /* 1800| | * We're adding an NSEC record, so create a node in the nsec tree 1801| | * too. This tree speeds searches for closest NSECs that would 1802| | * otherwise need to examine many irrelevant nodes in large TLDs. 1803| | * If dns_qp_insert() fails, it means there's already an NSEC 1804| | * node there, so we can just detach the new one we created and 1805| | * move on. 1806| | */ 1807| 0| node->havensec = true; 1808| 0| nsecnode = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NSEC); 1809| 0| (void)dns_qp_insert(loadctx->tree, nsecnode, 0); 1810| 0| qpznode_detach(&nsecnode); 1811| | 1812| 6|done: 1813| 6| *nodep = node; 1814| 6|} qpzone.c:add: 1899| 6| isc_stdtime_t now ISC_ATTR_UNUSED DNS__DB_FLARG) { 1900| 6| qpz_changed_t *changed = NULL; 1901| 6| dns_vectop_t *foundtop = NULL; 1902| 6| dns_vectop_t *priotop = NULL; 1903| 6| dns_vecheader_t *merged = NULL; 1904| 6| isc_result_t result; 1905| 6| bool merge = false; 1906| 6| uint32_t ntypes; 1907| | 1908| 6| if ((options & DNS_DBADD_MERGE) != 0) { ------------------ | | 298| 6|#define DNS_DBADD_MERGE 0x01 ------------------ | Branch (1908:6): [True: 6, False: 0] ------------------ 1909| 6| REQUIRE(version != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1910| 6| merge = true; 1911| 6| } 1912| | 1913| 6| if (!loading) { ------------------ | Branch (1913:6): [True: 0, False: 6] ------------------ 1914| | /* 1915| | * We always add a changed record, even if no changes end up 1916| | * being made to this node, because it's harmless and 1917| | * simplifies the code. 1918| | */ 1919| 0| changed = add_changed(qpdb, node, version DNS__DB_FLARG_PASS); 1920| 0| } 1921| | 1922| 6| ntypes = 0; 1923| 6| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 6| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 6| for (typeof(first) elt = first, \ | | | | 64| 6| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 4|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 4, False: 2] | | | | ------------------ | | | | 65| 12| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 6, False: 6] | | | | ------------------ | | | | 66| 6| elt = elt##_next, \ | | | | 67| 6| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 2|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 2, False: 4] | | | | ------------------ | | ------------------ ------------------ 1924| 6| ++ntypes; 1925| 6| if (prio_type(top->typepair)) { ------------------ | Branch (1925:7): [True: 2, False: 4] ------------------ 1926| 2| priotop = top; 1927| 2| } 1928| 6| if (top->typepair == newheader->typepair) { ------------------ | Branch (1928:7): [True: 0, False: 6] ------------------ 1929| 0| foundtop = top; 1930| 0| break; 1931| 0| } 1932| 6| } 1933| | 1934| | /* 1935| | * If topheader isn't NULL, we've found the right type. There may be 1936| | * IGNORE rdatasets between the top of the chain and the first real 1937| | * data. We skip over them. 1938| | */ 1939| 6| dns_vecheader_t **header_p = NULL; 1940| 6| dns_vecheader_t *header = NULL; 1941| 6| if (foundtop != NULL) { ------------------ | Branch (1941:6): [True: 0, False: 6] ------------------ 1942| 0| ISC_SLIST_FOREACH_PTR(p, &ISC_SLIST_HEAD(foundtop->headers)) { ------------------ | | 76| 0| for (typeof(head) p = (head); *p != NULL;) | | ------------------ | | | Branch (76:32): [True: 0, False: 0] | | ------------------ ------------------ 1943| 0| if (!IGNORE(*p)) { ------------------ | | 30| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 31| 0| DNS_VECHEADERATTR_IGNORE) != 0) ------------------ | Branch (1943:8): [True: 0, False: 0] ------------------ 1944| 0| header_p = p; 1945| 0| header = *p; 1946| 0| break; 1947| 0| } 1948| 0| ISC_SLIST_PTR_ADVANCE(p, next_header); ------------------ | | 82| 0| (p = &ISC_SLIST_NEXT(*p, link_field)) | | ------------------ | | | | 59| 0|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ ------------------ 1949| 0| } 1950| 0| } 1951| | 1952| 6| if (header != NULL) { ------------------ | Branch (1952:6): [True: 0, False: 6] ------------------ 1953| | /* 1954| | * If 'merge' is true and header isn't empty/nonexistent, 1955| | * we'll try to create a new rdataset that is the union 1956| | * of 'newheader' and 'header'. 1957| | */ 1958| 0| if (merge && EXISTS(header)) { ------------------ | | 27| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (27:2): [True: 0, False: 0] | | ------------------ | | 28| 0| DNS_VECHEADERATTR_NONEXISTENT) == 0) ------------------ | Branch (1958:7): [True: 0, False: 0] ------------------ 1959| 0| unsigned int flags = 0; 1960| 0| INSIST(version->serial >= header->serial); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1961| 0| merged = NULL; 1962| 0| result = ISC_R_SUCCESS; 1963| | 1964| 0| if ((options & DNS_DBADD_EXACT) != 0) { ------------------ | | 300| 0|#define DNS_DBADD_EXACT 0x04 ------------------ | Branch (1964:8): [True: 0, False: 0] ------------------ 1965| 0| flags |= DNS_RDATAVEC_EXACT; ------------------ | | 57| 0|#define DNS_RDATAVEC_EXACT 0x2 ------------------ 1966| 0| } 1967| 0| if ((options & DNS_DBADD_EXACTTTL) != 0 && ------------------ | | 301| 0|#define DNS_DBADD_EXACTTTL 0x08 ------------------ | Branch (1967:8): [True: 0, False: 0] ------------------ 1968| 0| newheader->ttl != header->ttl) ------------------ | Branch (1968:8): [True: 0, False: 0] ------------------ 1969| 0| { 1970| 0| result = DNS_R_NOTEXACT; 1971| 0| } else if (newheader->ttl != header->ttl) { ------------------ | Branch (1971:15): [True: 0, False: 0] ------------------ 1972| 0| flags |= DNS_RDATAVEC_FORCE; ------------------ | | 56| 0|#define DNS_RDATAVEC_FORCE 0x1 ------------------ 1973| 0| } 1974| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1974:8): [True: 0, False: 0] ------------------ 1975| 0| result = dns_rdatavec_merge( 1976| 0| header, newheader, qpdb->common.mctx, 1977| 0| qpdb->common.rdclass, 1978| 0| DNS_TYPEPAIR_TYPE(header->typepair), ------------------ | | 30| 0| ({ \ | | 31| 0| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 32| 0| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 33| 0| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 26| 0|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 34| 0| __base; \ | | 35| 0| }) ------------------ 1979| 0| flags, qpdb->maxrrperset, &merged); 1980| 0| } 1981| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1981:8): [True: 0, False: 0] ------------------ 1982| | /* 1983| | * If 'header' has the same serial number as 1984| | * we do, we could clean it up now if we knew 1985| | * that our caller had no references to it. 1986| | * We don't know this, however, so we leave it 1987| | * alone. It will get cleaned up when 1988| | * clean_zone_node() runs. 1989| | */ 1990| 0| dns_vecheader_unref(newheader); 1991| 0| newheader = merged; 1992| | /* 1993| | * dns_rdatavec_subtract takes the header from 1994| | * the first argument, so it preserves the case 1995| | */ 1996| 0| if (loading && RESIGN(newheader) && ------------------ | | 36| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (36:2): [True: 0, False: 0] | | ------------------ | | 37| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ | Branch (1996:9): [True: 0, False: 0] ------------------ 1997| 0| RESIGN(header) && ------------------ | | 36| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (36:2): [True: 0, False: 0] | | ------------------ | | 37| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 1998| 0| resign_sooner_values(header->resign, ------------------ | Branch (1998:9): [True: 0, False: 0] ------------------ 1999| 0| header->typepair, 2000| 0| newheader->resign, 2001| 0| newheader->typepair)) 2002| 0| { 2003| 0| newheader->resign = header->resign; 2004| 0| } 2005| 0| } else { 2006| 0| if (result == DNS_R_TOOMANYRECORDS) { ------------------ | Branch (2006:9): [True: 0, False: 0] ------------------ 2007| 0| dns__db_logtoomanyrecords( 2008| 0| (dns_db_t *)qpdb, nodename, 2009| 0| DNS_TYPEPAIR_TYPE( ------------------ | | 30| 0| ({ \ | | 31| 0| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 32| 0| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 33| 0| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 26| 0|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 34| 0| __base; \ | | 35| 0| }) ------------------ 2010| 0| header->typepair), 2011| 0| "updating", qpdb->maxrrperset); 2012| 0| } 2013| 0| dns_vecheader_unref(newheader); 2014| 0| return result; 2015| 0| } 2016| 0| } 2017| | 2018| 0| INSIST(version->serial >= header->serial); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2019| 0| INSIST(foundtop->typepair == newheader->typepair); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2020| | 2021| 0| if (loading) { ------------------ | Branch (2021:7): [True: 0, False: 0] ------------------ 2022| 0| if (RESIGN(newheader)) { ------------------ | | 36| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (36:2): [True: 0, False: 0] | | ------------------ | | 37| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 2023| 0| LOCK(&qpdb->heap->lock); ------------------ | | 26| 0| { \ | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 0| __FILE__, __LINE__)); \ | | 29| 0| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 0| { \ | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2024| 0| resign_register(qpdb->heap, node, newheader); 2025| 0| UNLOCK(&qpdb->heap->lock); ------------------ | | 34| 0| { \ | | 35| 0| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 0| { \ | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2026| | /* resigndelete not needed here */ 2027| 0| } 2028| | 2029| | /* 2030| | * There are no other references to 'header' when 2031| | * loading, so we MAY clean up 'header' now. 2032| | * Since we don't generate changed records when 2033| | * loading, we MUST clean up 'header' now. 2034| | */ 2035| 0| ISC_SLIST_PTR_REMOVE(header_p, header, next_header); ------------------ | | 79| 0| (*(p) = ISC_SLIST_NEXT(elt, link_field)) | | ------------------ | | | | 59| 0|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ ------------------ 2036| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2037| 0| next_header); 2038| 0| maybe_update_recordsandsize(false, version, header, 2039| 0| nodename->length); 2040| | 2041| 0| LOCK(&qpdb->heap->lock); ------------------ | | 26| 0| { \ | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 0| __FILE__, __LINE__)); \ | | 29| 0| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 0| { \ | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2042| 0| resign_unregister(qpdb->heap, node, header); 2043| 0| UNLOCK(&qpdb->heap->lock); ------------------ | | 34| 0| { \ | | 35| 0| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 0| { \ | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2044| 0| dns_vecheader_unref(header); 2045| 0| } else { 2046| 0| if (RESIGN(newheader)) { ------------------ | | 36| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (36:2): [True: 0, False: 0] | | ------------------ | | 37| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 2047| 0| LOCK(&qpdb->heap->lock); ------------------ | | 26| 0| { \ | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 0| __FILE__, __LINE__)); \ | | 29| 0| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 0| { \ | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2048| 0| resign_register(qpdb->heap, node, newheader); 2049| 0| resign_unregister(qpdb->heap, node, header); 2050| 0| UNLOCK(&qpdb->heap->lock); ------------------ | | 34| 0| { \ | | 35| 0| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 0| { \ | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2051| 0| resign_rollback(qpdb, node, version, 2052| 0| header DNS__DB_FLARG_PASS); 2053| 0| } 2054| | 2055| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2056| 0| next_header); 2057| | 2058| 0| node->dirty = true; 2059| 0| if (changed != NULL) { ------------------ | Branch (2059:8): [True: 0, False: 0] ------------------ 2060| 0| changed->dirty = true; 2061| 0| } 2062| 0| maybe_update_recordsandsize(false, version, header, 2063| 0| nodename->length); 2064| 0| } 2065| 6| } else { 2066| | /* 2067| | * No non-IGNORED rdatasets of the given type exist at 2068| | * this node. 2069| | * 2070| | * If we're trying to delete the type, don't bother. 2071| | */ 2072| 6| if (!EXISTS(newheader)) { ------------------ | | 27| 6| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 6|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 28| 6| DNS_VECHEADERATTR_NONEXISTENT) == 0) ------------------ | Branch (2072:7): [True: 0, False: 6] ------------------ 2073| 0| dns_vecheader_unref(newheader); 2074| 0| return DNS_R_UNCHANGED; 2075| 0| } 2076| | 2077| 6| if (RESIGN(newheader)) { ------------------ | | 36| 6| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 6|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (36:2): [True: 0, False: 6] | | ------------------ | | 37| 6| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 2078| 0| LOCK(&qpdb->heap->lock); ------------------ | | 26| 0| { \ | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 0| __FILE__, __LINE__)); \ | | 29| 0| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 0| { \ | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2079| 0| resign_register(qpdb->heap, node, newheader); 2080| 0| resign_unregister(qpdb->heap, node, header); 2081| 0| UNLOCK(&qpdb->heap->lock); ------------------ | | 34| 0| { \ | | 35| 0| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 0| { \ | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2082| 0| resign_rollback(qpdb, node, version, 2083| 0| header DNS__DB_FLARG_PASS); 2084| 0| } 2085| | 2086| 6| if (foundtop != NULL) { ------------------ | Branch (2086:7): [True: 0, False: 6] ------------------ 2087| | /* 2088| | * We have a list of rdatasets of the given type, 2089| | * but they're all marked IGNORE. We simply insert 2090| | * the new rdataset at the head of the list. 2091| | * 2092| | * Ignored rdatasets cannot occur during loading, so 2093| | * we INSIST on it. 2094| | */ 2095| 0| INSIST(!loading); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2096| | 2097| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2098| 0| next_header); 2099| | 2100| 0| if (changed != NULL) { ------------------ | Branch (2100:8): [True: 0, False: 0] ------------------ 2101| 0| changed->dirty = true; 2102| 0| } 2103| 0| node->dirty = true; 2104| 6| } else { 2105| | /* 2106| | * No rdatasets of the given type exist at the node. 2107| | */ 2108| | 2109| 6| if (qpdb->maxtypepername > 0 && ------------------ | Branch (2109:8): [True: 0, False: 6] ------------------ 2110| 0| ntypes >= qpdb->maxtypepername) ------------------ | Branch (2110:8): [True: 0, False: 0] ------------------ 2111| 0| { 2112| 0| LOCK(&qpdb->heap->lock); ------------------ | | 26| 0| { \ | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 0| __FILE__, __LINE__)); \ | | 29| 0| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 0| { \ | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2113| 0| resign_unregister(qpdb->heap, node, newheader); 2114| 0| UNLOCK(&qpdb->heap->lock); ------------------ | | 34| 0| { \ | | 35| 0| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 0| { \ | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2115| 0| dns_vecheader_unref(newheader); 2116| 0| return DNS_R_TOOMANYRECORDS; 2117| 0| } 2118| | 2119| 6| dns_vectop_t *newtop = 2120| 6| dns_vectop_new(node->mctx, newheader->typepair); 2121| | 2122| 6| ISC_SLIST_PREPEND(newtop->headers, newheader, ------------------ | | 48| 6| ({ \ | | 49| 6| (elt)->link.next = (list).head; \ | | 50| 6| (list).head = (elt); \ | | 51| 6| }) ------------------ 2123| 6| next_header); 2124| | 2125| 6| if (prio_type(newheader->typepair)) { ------------------ | Branch (2125:8): [True: 4, False: 2] ------------------ 2126| | /* This is a priority type, prepend it */ 2127| 4| ISC_SLIST_PREPEND(node->next_type, newtop, ------------------ | | 48| 4| ({ \ | | 49| 4| (elt)->link.next = (list).head; \ | | 50| 4| (list).head = (elt); \ | | 51| 4| }) ------------------ 2128| 4| next_type); 2129| 4| } else if (priotop != NULL) { ------------------ | Branch (2129:15): [True: 0, False: 2] ------------------ 2130| | /* Append after the priority headers */ 2131| 0| ISC_SLIST_INSERTAFTER(priotop, newtop, ------------------ | | 54| 0| ({ \ | | 55| 0| (elt)->link.next = (after)->link.next; \ | | 56| 0| (after)->link.next = (elt); \ | | 57| 0| }) ------------------ 2132| 0| next_type); 2133| 2| } else { 2134| | /* There were no priority headers */ 2135| 2| ISC_SLIST_PREPEND(node->next_type, newtop, ------------------ | | 48| 2| ({ \ | | 49| 2| (elt)->link.next = (list).head; \ | | 50| 2| (list).head = (elt); \ | | 51| 2| }) ------------------ 2136| 2| next_type); 2137| 2| } 2138| 6| } 2139| 6| } 2140| | 2141| 6| maybe_update_recordsandsize(true, version, newheader, nodename->length); 2142| | 2143| | /* 2144| | * Check if the node now contains CNAME and other data. 2145| | */ 2146| 6| if (cname_and_other(node, version->serial)) { ------------------ | Branch (2146:6): [True: 0, False: 6] ------------------ 2147| 0| return DNS_R_CNAMEANDOTHER; 2148| 0| } 2149| | 2150| 6| bindrdataset(qpdb, newheader, addedrdataset DNS__DB_FLARG_PASS); 2151| | 2152| 6| return ISC_R_SUCCESS; 2153| 6|} qpzone.c:maybe_update_recordsandsize: 1879| 6| dns_vecheader_t *header, unsigned int namelen) { 1880| 6| if (!EXISTS(header)) { ------------------ | | 27| 6| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 6|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 28| 6| DNS_VECHEADERATTR_NONEXISTENT) == 0) ------------------ | Branch (1880:6): [True: 0, False: 6] ------------------ 1881| 0| return; 1882| 0| } 1883| | 1884| 12| RWLOCK(&version->rwlock, isc_rwlocktype_write); ------------------ | | 30| 6| { \ | | 31| 6| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 6| (t), __FILE__, __LINE__)); \ | | 33| 6| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 6| { \ | | | | 253| 6| switch (type) { \ | | | | 254| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 0, False: 6] | | | | ------------------ | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | 256| 0| break; \ | | | | 257| 6| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 6, False: 0] | | | | ------------------ | | | | 258| 6| isc_rwlock_wrlock(rwl); \ | | | | 259| 6| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 6] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 6| } \ | | | | 263| 6| } | | ------------------ | | 34| 6| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 6| (lp), (t), __FILE__, __LINE__)); \ | | 36| 6| } ------------------ 1885| 12| if (add) { ------------------ | Branch (1885:6): [True: 6, False: 0] ------------------ 1886| 6| version->records += dns_rdatavec_count(header); 1887| 6| version->xfrsize += recordsize(header, namelen); 1888| 6| } else { 1889| 0| version->records -= dns_rdatavec_count(header); 1890| 0| version->xfrsize -= recordsize(header, namelen); 1891| 0| } 1892| 12| RWUNLOCK(&version->rwlock, isc_rwlocktype_write); ------------------ | | 38| 6| { \ | | 39| 6| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 6| (lp), (t), __FILE__, __LINE__)); \ | | 41| 6| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 6| { \ | | | | 283| 6| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 6] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 6| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 6, False: 0] | | | | ------------------ | | | | 288| 6| isc_rwlock_wrunlock(rwl); \ | | | | 289| 6| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 6] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 6| } \ | | | | 293| 6| } | | ------------------ | | 42| 6| } ------------------ 1893| 6|} qpzone.c:recordsize: 1872| 6|recordsize(dns_vecheader_t *header, unsigned int namelen) { 1873| 6| return dns_rdatavec_size(header) + sizeof(dns_ttl_t) + 1874| 6| sizeof(dns_rdatatype_t) + sizeof(dns_rdataclass_t) + namelen; 1875| 6|} qpzone.c:cname_and_other: 1817| 6|cname_and_other(qpznode_t *node, uint32_t serial) { 1818| 6| bool cname = false, other = false; 1819| | 1820| | /* 1821| | * Look for CNAME and "other data" rdatasets active in our version. 1822| | * ("Other data" is any rdataset whose type is not KEY, NSEC, SIG 1823| | * or RRSIG. 1824| | */ 1825| 12| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 6| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 6| for (typeof(first) elt = first, \ | | | | 64| 6| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 6|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 6, False: 0] | | | | ------------------ | | | | 65| 12| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 12, False: 0] | | | | ------------------ | | | | 66| 6| elt = elt##_next, \ | | | | 67| 6| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 6|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 6, False: 0] | | | | ------------------ | | ------------------ ------------------ 1826| 12| dns_rdatatype_t rdtype = DNS_TYPEPAIR_TYPE(top->typepair); ------------------ | | 30| 12| ({ \ | | 31| 12| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 32| 12| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 33| 12| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 26| 12|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 34| 12| __base; \ | | 35| 12| }) ------------------ 1827| 12| if (rdtype == dns_rdatatype_cname) { ------------------ | | 119| 12|#define dns_rdatatype_cname ((dns_rdatatype_t)dns_rdatatype_cname) ------------------ | Branch (1827:7): [True: 0, False: 12] ------------------ 1828| 0| if (first_existing_header(top, serial) != NULL) { ------------------ | Branch (1828:8): [True: 0, False: 0] ------------------ 1829| 0| cname = true; 1830| 0| } 1831| 12| } else if (rdtype != dns_rdatatype_nsec && ------------------ | | 161| 24|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1831:14): [True: 12, False: 0] ------------------ 1832| 12| rdtype != dns_rdatatype_rrsig) ------------------ | | 160| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1832:7): [True: 12, False: 0] ------------------ 1833| 12| { 1834| 12| if (first_existing_header(top, serial) != NULL) { ------------------ | Branch (1834:8): [True: 12, False: 0] ------------------ 1835| 12| if (!prio_type(rdtype)) { ------------------ | Branch (1835:9): [True: 6, False: 6] ------------------ 1836| | /* 1837| | * CNAME is in the priority list, so if 1838| | * we are done with priority types, we 1839| | * know there will not be a CNAME, and 1840| | * are safe to skip the rest. 1841| | */ 1842| 6| return cname; 1843| 6| } 1844| 6| other = true; 1845| 6| } 1846| 12| } 1847| | 1848| 6| if (cname && other) { ------------------ | Branch (1848:7): [True: 0, False: 6] | Branch (1848:16): [True: 0, False: 0] ------------------ 1849| 0| return true; 1850| 0| } 1851| 6| } 1852| | 1853| 0| return false; 1854| 6|} qpzone.c:first_existing_header: 995| 527|first_existing_header(dns_vectop_t *top, uint32_t serial) { 996| 527| ISC_SLIST_FOREACH(header, top->headers, next_header) { ------------------ | | 70| 527| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 527| for (typeof(first) elt = first, \ | | | | 64| 527| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 527|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 527, False: 0] | | | | ------------------ | | | | 65| 527| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 527, False: 0] | | | | ------------------ | | | | 66| 527| elt = elt##_next, \ | | | | 67| 0| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 0|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 997| 527| if (header->serial <= serial && !IGNORE(header)) { ------------------ | | 30| 527| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 527|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 31| 527| DNS_VECHEADERATTR_IGNORE) != 0) ------------------ | Branch (997:7): [True: 527, False: 0] | Branch (997:35): [True: 527, False: 0] ------------------ 998| 527| if (EXISTS(header)) { ------------------ | | 27| 527| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 527|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (27:2): [True: 527, False: 0] | | ------------------ | | 28| 527| DNS_VECHEADERATTR_NONEXISTENT) == 0) ------------------ 999| 527| return header; 1000| 527| } 1001| 0| break; 1002| 527| } 1003| 527| } 1004| 0| return NULL; 1005| 527|} qpzone.c:bindrdataset: 1166| 142| dns_rdataset_t *rdataset DNS__DB_FLARG) { 1167| 142| if (rdataset == NULL) { ------------------ | Branch (1167:6): [True: 6, False: 136] ------------------ 1168| 6| return; 1169| 6| } 1170| | 1171| 136| INSIST(rdataset->methods == NULL); /* We must be disassociated. */ ------------------ | | 198| 136|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 136| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 136, False: 0] | | | | ------------------ | | | | 55| 136| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1172| | 1173| 136| rdataset->methods = &dns_rdatavec_rdatasetmethods; 1174| 136| rdataset->rdclass = qpdb->common.rdclass; 1175| 136| rdataset->type = DNS_TYPEPAIR_TYPE(header->typepair); ------------------ | | 30| 136| ({ \ | | 31| 136| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 32| 136| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 33| 136| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 26| 136|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 34| 136| __base; \ | | 35| 136| }) ------------------ 1176| 136| rdataset->covers = DNS_TYPEPAIR_COVERS(header->typepair); ------------------ | | 37| 136| ({ \ | | 38| 136| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 39| 136| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 40| 136| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 26| 136|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 41| 136| __covers; \ | | 42| 136| }) ------------------ 1177| 136| rdataset->ttl = header->ttl; 1178| 136| rdataset->trust = atomic_load(&header->trust); 1179| | 1180| 136| if (OPTOUT(header)) { ------------------ | | 33| 136| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 136|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 136] | | ------------------ | | 34| 136| DNS_VECHEADERATTR_OPTOUT) != 0) ------------------ 1181| 0| rdataset->attributes.optout = true; 1182| 0| } 1183| | 1184| 136| rdataset->vec.header = header; 1185| 136| dns_vecheader_ref(header); 1186| 136| rdataset->vec.iter.iter_pos = NULL; 1187| 136| rdataset->vec.iter.iter_count = 0; 1188| | 1189| | /* 1190| | * Add noqname proof. 1191| | */ 1192| | 1193| | /* 1194| | * Copy out re-signing information. 1195| | */ 1196| 136| if (RESIGN(header)) { ------------------ | | 36| 136| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 136|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (36:2): [True: 0, False: 136] | | ------------------ | | 37| 136| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 1197| 0| rdataset->attributes.resign = true; 1198| 0| rdataset->resign = header->resign; 1199| 136| } else { 1200| 136| rdataset->resign = 0; 1201| 136| } 1202| 136|} qpzone.c:delegating_type: 1752| 6|delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t typepair) { 1753| 6| return typepair == DNS_TYPEPAIR(dns_rdatatype_dname) || ------------------ | | 52| 6|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (1753:9): [True: 0, False: 6] ------------------ 1754| 6| (typepair == DNS_TYPEPAIR(dns_rdatatype_ns) && ------------------ | | 52| 6|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (1754:10): [True: 2, False: 4] ------------------ 1755| 2| (node != qpdb->origin || IS_STUB(qpdb))); ------------------ | | 84| 2|#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0) | | ------------------ | | | Branch (84:22): [True: 0, False: 2] | | ------------------ ------------------ | Branch (1755:4): [True: 0, False: 2] ------------------ 1756| 6|} qpzone.c:loading_setup: 2291| 2|loading_setup(void *arg) { 2292| 2| qpz_load_t *loadctx = arg; 2293| 2| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2294| | 2295| 2| dns_qpmulti_write(qpdb->tree, &loadctx->tree); 2296| 2|} qpzone.c:loading_commit: 2299| 2|loading_commit(void *arg) { 2300| 2| qpz_load_t *loadctx = arg; 2301| 2| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2302| | 2303| 2| if (loadctx->tree != NULL) { ------------------ | Branch (2303:6): [True: 2, False: 0] ------------------ 2304| 2| dns_qp_compact(loadctx->tree, DNS_QPGC_MAYBE); 2305| 2| dns_qpmulti_commit(qpdb->tree, &loadctx->tree); 2306| 2| } 2307| 2|} qpzone.c:endload: 2338| 2|endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 2339| 2| qpz_load_t *loadctx = NULL; 2340| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2341| | 2342| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2343| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2344| 2| loadctx = callbacks->add_private; 2345| 2| REQUIRE(loadctx != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2346| 2| REQUIRE(loadctx->db == db); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2347| | 2348| 2| RWLOCK(&qpdb->lock, isc_rwlocktype_write); ------------------ | | 30| 2| { \ | | 31| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 2| (t), __FILE__, __LINE__)); \ | | 33| 2| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 2| { \ | | | | 253| 2| switch (type) { \ | | | | 254| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 0, False: 2] | | | | ------------------ | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | 256| 0| break; \ | | | | 257| 2| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 2, False: 0] | | | | ------------------ | | | | 258| 2| isc_rwlock_wrlock(rwl); \ | | | | 259| 2| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 2] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 2| } \ | | | | 263| 2| } | | ------------------ | | 34| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 2| (lp), (t), __FILE__, __LINE__)); \ | | 36| 2| } ------------------ 2349| | 2350| 2| REQUIRE((qpdb->attributes & QPDB_ATTR_LOADING) != 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2351| 2| REQUIRE((qpdb->attributes & QPDB_ATTR_LOADED) == 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2352| | 2353| 2| qpdb->attributes &= ~QPDB_ATTR_LOADING; ------------------ | | 71| 2|#define QPDB_ATTR_LOADING 0x02 ------------------ 2354| 2| qpdb->attributes |= QPDB_ATTR_LOADED; ------------------ | | 70| 2|#define QPDB_ATTR_LOADED 0x01 ------------------ 2355| | 2356| 2| if (qpdb->origin != NULL) { ------------------ | Branch (2356:6): [True: 2, False: 0] ------------------ 2357| 2| qpz_version_t *version = qpdb->current_version; 2358| 2| RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); ------------------ | | 38| 2| { \ | | 39| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 2| (lp), (t), __FILE__, __LINE__)); \ | | 41| 2| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 2| { \ | | | | 283| 2| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 2] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 2| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 2, False: 0] | | | | ------------------ | | | | 288| 2| isc_rwlock_wrunlock(rwl); \ | | | | 289| 2| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 2] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 2359| 2| setsecure(db, version, (dns_dbnode_t *)qpdb->origin); 2360| 2| } else { 2361| 0| RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); ------------------ | | 38| 0| { \ | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 0| { \ | | | | 283| 0| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 0] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 0] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 0] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 2362| 0| } 2363| | 2364| 2| callbacks->update = NULL; 2365| 2| callbacks->setup = NULL; 2366| 2| callbacks->commit = NULL; 2367| 2| callbacks->add_private = NULL; 2368| | 2369| 2| isc_mem_put(qpdb->common.mctx, loadctx, sizeof(*loadctx)); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 2370| | 2371| 2| return ISC_R_SUCCESS; 2372| 2|} qpzone.c:setsecure: 1292| 2|setsecure(dns_db_t *db, qpz_version_t *version, dns_dbnode_t *origin) { 1293| 2| dns_rdataset_t keyset; 1294| 2| dns_rdataset_t nsecset, signsecset; 1295| 2| bool haszonekey = false; 1296| 2| bool hasnsec = false; 1297| 2| isc_result_t result; 1298| | 1299| 2| version->secure = false; 1300| 2| version->havensec3 = false; 1301| | 1302| 2| dns_rdataset_init(&keyset); 1303| 2| result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 1304| 2| dns_rdatatype_dnskey, 0, 0, &keyset, NULL); 1305| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1305:6): [True: 0, False: 2] ------------------ 1306| 0| haszonekey = dns_dnssec_haszonekey(&keyset); 1307| 0| dns_rdataset_disassociate(&keyset); ------------------ | | 291| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1308| 0| } 1309| 2| if (!haszonekey) { ------------------ | Branch (1309:6): [True: 2, False: 0] ------------------ 1310| 2| return; 1311| 2| } 1312| | 1313| 0| dns_rdataset_init(&nsecset); 1314| 0| dns_rdataset_init(&signsecset); 1315| 0| result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version, ------------------ | | 1125| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 0| sigrdataset DNS__DB_FILELINE) ------------------ 1316| 0| dns_rdatatype_nsec, 0, 0, &nsecset, 1317| 0| &signsecset); 1318| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1318:6): [True: 0, False: 0] ------------------ 1319| 0| if (dns_rdataset_isassociated(&signsecset)) { ------------------ | Branch (1319:7): [True: 0, False: 0] ------------------ 1320| 0| hasnsec = true; 1321| 0| dns_rdataset_disassociate(&signsecset); ------------------ | | 291| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1322| 0| } 1323| 0| dns_rdataset_disassociate(&nsecset); ------------------ | | 291| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1324| 0| } 1325| | 1326| 0| setnsec3parameters(db, version); 1327| | 1328| | /* 1329| | * If we don't have a valid NSEC/NSEC3 chain, 1330| | * clear the secure flag. 1331| | */ 1332| 0| if (version->havensec3 || hasnsec) { ------------------ | Branch (1332:6): [True: 0, False: 0] | Branch (1332:28): [True: 0, False: 0] ------------------ 1333| | version->secure = true; 1334| 0| } 1335| 0|} qpzone.c:begin_transaction: 2583| 6|begin_transaction(qpzonedb_t *qpdb, dns_qpread_t *qprp, bool create) { 2584| 6| dns_qp_t *qp = NULL; 2585| | 2586| 6| if (create) { ------------------ | Branch (2586:6): [True: 0, False: 6] ------------------ 2587| 0| dns_qpmulti_write(qpdb->tree, &qp); 2588| 6| } else { 2589| 6| dns_qpmulti_query(qpdb->tree, qprp); 2590| 6| qp = (dns_qp_t *)qprp; 2591| 6| } 2592| | 2593| 6| return qp; 2594| 6|} qpzone.c:findnodeintree: 2609| 6| bool create, bool nsec3, dns_dbnode_t **nodep DNS__DB_FLARG) { 2610| 6| isc_result_t result; 2611| 6| qpznode_t *node = NULL; 2612| 6| dns_namespace_t nspace = nsec3 ? DNS_DBNAMESPACE_NSEC3 ------------------ | Branch (2612:27): [True: 0, False: 6] ------------------ 2613| 6| : DNS_DBNAMESPACE_NORMAL; 2614| | /* 2615| | * findnodeintree is a wrapper around dns_qp_getname that does some 2616| | * qpzone-specific bookkeeping before returning the lookup result to the 2617| | * caller. 2618| | * 2619| | * First, we do a lookup ... 2620| | */ 2621| 6| result = dns_qp_getname(qp, name, nspace, (void **)&node, NULL); 2622| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (2622:6): [True: 6, False: 0] ------------------ 2623| | /* 2624| | * ... if the lookup is successful, we need to increase both the 2625| | * internal and external reference count before returning to 2626| | * the caller. qpznode_acquire takes care of that. 2627| | */ 2628| 6| qpznode_acquire(node DNS__DB_FLARG_PASS); 2629| | 2630| 6| INSIST(node->nspace == DNS_DBNAMESPACE_NSEC3 || !nsec3); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 0, False: 6] | | | | | Branch (54:11): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2631| 6| } else if (result != ISC_R_SUCCESS && create) { ------------------ | Branch (2631:13): [True: 0, False: 0] | Branch (2631:40): [True: 0, False: 0] ------------------ 2632| | /* 2633| | * ... if the lookup is unsuccessful, but the caller asked us to 2634| | * create a new node, create one and insert it into the tree. 2635| | */ 2636| 0| node = new_qpznode(qpdb, name, nspace); 2637| 0| result = dns_qp_insert(qp, node, 0); 2638| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2639| | 2640| | /* 2641| | * The new node now has two internal references: 2642| | * - One from new_qpznode, that initializes references at 1. 2643| | * - One from attach_leaf, that increases the reference by 2644| | * one at insertion in the qp-tree. 2645| | * We want the node to have two internal and one external 2646| | * reference: 2647| | * - One internal reference from the qp-tree. 2648| | * - One internal and one external reference from the caller. 2649| | * 2650| | * So we increase the external reference count by one. 2651| | */ 2652| 0| qpznode_erefs_increment(node DNS__DB_FLARG_PASS); 2653| | 2654| 0| if (!nsec3) { ------------------ | Branch (2654:7): [True: 0, False: 0] ------------------ 2655| | /* 2656| | * Add empty non-terminal nodes to help with wildcards. 2657| | */ 2658| 0| addwildcards(qpdb, qp, name, nspace); 2659| 0| if (dns_name_iswildcard(name)) { ------------------ | Branch (2659:8): [True: 0, False: 0] ------------------ 2660| 0| wildcardmagic(qpdb, qp, name, nspace); 2661| 0| } 2662| 0| } 2663| | 2664| 0| INSIST(node->nspace == DNS_DBNAMESPACE_NSEC3 || !nsec3); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 0, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2665| 0| } 2666| | /* 2667| | * ... if the lookup is unsuccessful, and the caller didn't ask us 2668| | * to create a new node, there is nothing to do. Return the result 2669| | * of the lookup to the caller, and set *nodep to NULL 2670| | */ 2671| | 2672| 6| *nodep = (dns_dbnode_t *)node; 2673| | 2674| 6| return result; 2675| 6|} qpzone.c:end_transaction: 2597| 6|end_transaction(qpzonedb_t *qpdb, dns_qp_t *qp, bool create) { 2598| 6| if (create) { ------------------ | Branch (2598:6): [True: 0, False: 6] ------------------ 2599| 0| dns_qp_compact(qp, DNS_QPGC_MAYBE); 2600| 0| dns_qpmulti_commit(qpdb->tree, &qp); 2601| 6| } else { 2602| 6| dns_qpread_t *qprp = (dns_qpread_t *)qp; 2603| 6| dns_qpread_destroy(qpdb->tree, qprp); 2604| 6| } 2605| 6|} qpzone.c:currentversion: 1338| 219|currentversion(dns_db_t *db, dns_dbversion_t **versionp) { 1339| 219| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1340| 219| qpz_version_t *version = NULL; 1341| | 1342| 219| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 219|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 438| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 219, False: 0] | | | | | Branch (42:11): [True: 219, False: 0] | | | | ------------------ | | | | 43| 219| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1343| | 1344| 219| RWLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 30| 219| { \ | | 31| 219| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 219| (t), __FILE__, __LINE__)); \ | | 33| 219| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 219| { \ | | | | 253| 219| switch (type) { \ | | | | 254| 219| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 219, False: 0] | | | | ------------------ | | | | 255| 219| isc_rwlock_rdlock(rwl); \ | | | | 256| 219| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 219] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 219] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 219| } \ | | | | 263| 219| } | | ------------------ | | 34| 219| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 219| (lp), (t), __FILE__, __LINE__)); \ | | 36| 219| } ------------------ 1345| 219| version = qpdb->current_version; 1346| 219| isc_refcount_increment(&version->references); ------------------ | | 81| 219| ({ \ | | 82| 219| uint_fast32_t __v; \ | | 83| 219| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 219| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 219| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 198| 219|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 438| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:11): [True: 219, False: 0] | | | | | | | Branch (54:11): [True: 219, False: 0] | | | | | | ------------------ | | | | | | 55| 219| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 219| __v; \ | | 86| 219| }) ------------------ 1347| 219| RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 38| 219| { \ | | 39| 219| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 219| (lp), (t), __FILE__, __LINE__)); \ | | 41| 219| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 219| { \ | | | | 283| 219| switch (type) { \ | | | | 284| 219| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 219, False: 0] | | | | ------------------ | | | | 285| 219| isc_rwlock_rdunlock(rwl); \ | | | | 286| 219| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 219] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 219] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 219| } \ | | | | 293| 219| } | | ------------------ | | 42| 219| } ------------------ 1348| | 1349| 219| *versionp = (dns_dbversion_t *)version; 1350| 219|} qpzone.c:closeversion: 1436| 219| bool commit DNS__DB_FLARG) { 1437| 219| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1438| 219| qpz_version_t *version = NULL, *cleanup_version = NULL; 1439| 219| qpz_version_t *least_greater = NULL; 1440| 219| qpznode_t *node = NULL; 1441| 219| bool rollback = false; 1442| 219| qpz_changedlist_t cleanup_list; 1443| 219| qpz_resignedlist_t resigned_list; 1444| 219| uint32_t serial, least_serial; 1445| | 1446| 219| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 219|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 438| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 219, False: 0] | | | | | Branch (42:11): [True: 219, False: 0] | | | | ------------------ | | | | 43| 219| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1447| 219| version = (qpz_version_t *)*versionp; 1448| 219| INSIST(version->qpdb == qpdb); ------------------ | | 198| 219|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 219| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 219, False: 0] | | | | ------------------ | | | | 55| 219| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1449| | 1450| 219| if (isc_refcount_decrement(&version->references) > 1) { ------------------ | | 94| 219| ({ \ | | 95| 219| uint_fast32_t __v; \ | | 96| 219| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 219| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 219| INSIST(__v > 0); \ | | ------------------ | | | | 198| 219|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 219| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 219, False: 0] | | | | | | ------------------ | | | | | | 55| 219| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 219| __v; \ | | 99| 219| }) ------------------ | Branch (1450:6): [True: 219, False: 0] ------------------ 1451| 219| *versionp = NULL; 1452| 219| return; 1453| 219| } 1454| | 1455| 0| ISC_LIST_INIT(cleanup_list); ------------------ | | 43| 0| do { \ | | 44| 0| (list).head = NULL; \ | | 45| 0| (list).tail = NULL; \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 0] | | ------------------ ------------------ 1456| 0| ISC_LIST_INIT(resigned_list); ------------------ | | 43| 0| do { \ | | 44| 0| (list).head = NULL; \ | | 45| 0| (list).tail = NULL; \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 0] | | ------------------ ------------------ 1457| | 1458| | /* 1459| | * Update the zone's secure status in version before making 1460| | * it the current version. 1461| | */ 1462| 0| if (version->writer && commit) { ------------------ | Branch (1462:6): [True: 0, False: 0] | Branch (1462:25): [True: 0, False: 0] ------------------ 1463| 0| setsecure(db, version, (dns_dbnode_t *)qpdb->origin); 1464| 0| } 1465| | 1466| 0| RWLOCK(&qpdb->lock, isc_rwlocktype_write); ------------------ | | 30| 0| { \ | | 31| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 0| (t), __FILE__, __LINE__)); \ | | 33| 0| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 0| { \ | | | | 253| 0| switch (type) { \ | | | | 254| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 0, False: 0] | | | | ------------------ | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | 256| 0| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 0] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 0] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 0| } \ | | | | 263| 0| } | | ------------------ | | 34| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 0| (lp), (t), __FILE__, __LINE__)); \ | | 36| 0| } ------------------ 1467| 0| serial = version->serial; 1468| 0| if (version->writer) { ------------------ | Branch (1468:6): [True: 0, False: 0] ------------------ 1469| 0| if (commit) { ------------------ | Branch (1469:7): [True: 0, False: 0] ------------------ 1470| 0| unsigned int cur_ref; 1471| 0| qpz_version_t *cur_version = NULL; 1472| | 1473| 0| INSIST(version == qpdb->future_version); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1474| | /* 1475| | * The current version is going to be replaced. 1476| | * Release the (likely last) reference to it from the 1477| | * DB itself and unlink it from the open list. 1478| | */ 1479| 0| cur_version = qpdb->current_version; 1480| 0| cur_ref = isc_refcount_decrement( ------------------ | | 94| 0| ({ \ | | 95| 0| uint_fast32_t __v; \ | | 96| 0| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 0| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 0| INSIST(__v > 0); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 0| __v; \ | | 99| 0| }) ------------------ 1481| 0| &cur_version->references); 1482| 0| if (cur_ref == 1) { ------------------ | Branch (1482:8): [True: 0, False: 0] ------------------ 1483| 0| (void)isc_refcount_current( ------------------ | | 52| 0|#define isc_refcount_current(target) atomic_load_acquire(target) | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ ------------------ 1484| 0| &cur_version->references); 1485| 0| if (cur_version->serial == qpdb->least_serial) { ------------------ | Branch (1485:9): [True: 0, False: 0] ------------------ 1486| 0| INSIST(ISC_LIST_EMPTY( ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1487| 0| cur_version->changed_list)); 1488| 0| } 1489| 0| ISC_LIST_UNLINK(qpdb->open_versions, ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1490| 0| cur_version, link); 1491| 0| } 1492| 0| if (ISC_LIST_EMPTY(qpdb->open_versions)) { ------------------ | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (64:30): [True: 0, False: 0] | | ------------------ ------------------ 1493| | /* 1494| | * We're going to become the least open 1495| | * version. 1496| | */ 1497| 0| make_least_version(qpdb, version, 1498| 0| &cleanup_list); 1499| 0| } else { 1500| | /* 1501| | * Some other open version is the 1502| | * least version. We can't cleanup 1503| | * records that were changed in this 1504| | * version because the older versions 1505| | * may still be in use by an open 1506| | * version. 1507| | * 1508| | * We can, however, discard the 1509| | * changed records for things that 1510| | * we've added that didn't exist in 1511| | * prior versions. 1512| | */ 1513| 0| cleanup_nondirty(version, &cleanup_list); 1514| 0| } 1515| | /* 1516| | * If the (soon to be former) current version 1517| | * isn't being used by anyone, we can clean 1518| | * it up. 1519| | */ 1520| 0| if (cur_ref == 1) { ------------------ | Branch (1520:8): [True: 0, False: 0] ------------------ 1521| 0| cleanup_version = cur_version; 1522| 0| ISC_LIST_APPENDLIST( ------------------ | | 181| 0| do { \ | | 182| 0| if (ISC_LIST_EMPTY(list1)) { \ | | ------------------ | | | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | | | ------------------ | | | | | Branch (64:30): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 183| 0| (list1) = (list2); \ | | 184| 0| } else if (!ISC_LIST_EMPTY(list2)) { \ | | ------------------ | | | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (184:14): [True: 0, False: 0] | | ------------------ | | 185| 0| (list1).tail->link.next = (list2).head; \ | | 186| 0| (list2).head->link.prev = (list1).tail; \ | | 187| 0| (list1).tail = (list2).tail; \ | | 188| 0| } \ | | 189| 0| (list2).head = NULL; \ | | 190| 0| (list2).tail = NULL; \ | | 191| 0| } while (0) | | ------------------ | | | Branch (191:11): [Folded, False: 0] | | ------------------ ------------------ 1523| 0| version->changed_list, 1524| 0| cleanup_version->changed_list, link); 1525| 0| } 1526| | /* 1527| | * Become the current version. 1528| | */ 1529| 0| version->writer = false; 1530| 0| qpdb->current_version = version; 1531| 0| qpdb->current_serial = version->serial; 1532| 0| qpdb->future_version = NULL; 1533| | 1534| | /* 1535| | * Keep the current version in the open list, and 1536| | * gain a reference for the DB itself (see the DB 1537| | * creation function below). This must be the only 1538| | * case where we need to increment the counter from 1539| | * zero and need to use isc_refcount_increment0(). 1540| | */ 1541| 0| INSIST(isc_refcount_increment0(&version->references) == ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1542| 0| 0); 1543| 0| ISC_LIST_PREPEND(qpdb->open_versions, ------------------ | | 79| 0| do { \ | | 80| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 0| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 0| do { \ | | | | 68| 0| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 0, False: 0] | | | | ------------------ | | | | 69| 0| (list).head->link.prev = (elt); \ | | | | 70| 0| } else { \ | | | | 71| 0| (list).tail = (elt); \ | | | | 72| 0| } \ | | | | 73| 0| (elt)->link.prev = NULL; \ | | | | 74| 0| (elt)->link.next = (list).head; \ | | | | 75| 0| (list).head = (elt); \ | | | | 76| 0| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 82| 0| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 0] | | ------------------ ------------------ 1544| 0| qpdb->current_version, link); 1545| 0| resigned_list = version->resigned_list; 1546| 0| ISC_LIST_INIT(version->resigned_list); ------------------ | | 43| 0| do { \ | | 44| 0| (list).head = NULL; \ | | 45| 0| (list).tail = NULL; \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 0] | | ------------------ ------------------ 1547| 0| } else { 1548| | /* 1549| | * We're rolling back this transaction. 1550| | */ 1551| 0| cleanup_list = version->changed_list; 1552| 0| ISC_LIST_INIT(version->changed_list); ------------------ | | 43| 0| do { \ | | 44| 0| (list).head = NULL; \ | | 45| 0| (list).tail = NULL; \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 0] | | ------------------ ------------------ 1553| 0| resigned_list = version->resigned_list; 1554| 0| ISC_LIST_INIT(version->resigned_list); ------------------ | | 43| 0| do { \ | | 44| 0| (list).head = NULL; \ | | 45| 0| (list).tail = NULL; \ | | 46| 0| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 0] | | ------------------ ------------------ 1555| 0| rollback = true; 1556| 0| cleanup_version = version; 1557| 0| qpdb->future_version = NULL; 1558| 0| } 1559| 0| } else { 1560| 0| if (version != qpdb->current_version) { ------------------ | Branch (1560:7): [True: 0, False: 0] ------------------ 1561| | /* 1562| | * There are no external or internal references 1563| | * to this version and it can be cleaned up. 1564| | */ 1565| 0| cleanup_version = version; 1566| | 1567| | /* 1568| | * Find the version with the least serial 1569| | * number greater than ours. 1570| | */ 1571| 0| least_greater = ISC_LIST_PREV(version, link); ------------------ | | 139| 0|#define ISC_LIST_PREV(elt, link) ((elt)->link.prev) ------------------ 1572| 0| if (least_greater == NULL) { ------------------ | Branch (1572:8): [True: 0, False: 0] ------------------ 1573| 0| least_greater = qpdb->current_version; 1574| 0| } 1575| | 1576| 0| INSIST(version->serial < least_greater->serial); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1577| | /* 1578| | * Is this the least open version? 1579| | */ 1580| 0| if (version->serial == qpdb->least_serial) { ------------------ | Branch (1580:8): [True: 0, False: 0] ------------------ 1581| | /* 1582| | * Yes. Install the new least open 1583| | * version. 1584| | */ 1585| 0| make_least_version(qpdb, least_greater, 1586| 0| &cleanup_list); 1587| 0| } else { 1588| | /* 1589| | * Add any unexecuted cleanups to 1590| | * those of the least greater version. 1591| | */ 1592| 0| ISC_LIST_APPENDLIST(least_greater->changed_list, ------------------ | | 181| 0| do { \ | | 182| 0| if (ISC_LIST_EMPTY(list1)) { \ | | ------------------ | | | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | | | ------------------ | | | | | Branch (64:30): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 183| 0| (list1) = (list2); \ | | 184| 0| } else if (!ISC_LIST_EMPTY(list2)) { \ | | ------------------ | | | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (184:14): [True: 0, False: 0] | | ------------------ | | 185| 0| (list1).tail->link.next = (list2).head; \ | | 186| 0| (list2).head->link.prev = (list1).tail; \ | | 187| 0| (list1).tail = (list2).tail; \ | | 188| 0| } \ | | 189| 0| (list2).head = NULL; \ | | 190| 0| (list2).tail = NULL; \ | | 191| 0| } while (0) | | ------------------ | | | Branch (191:11): [Folded, False: 0] | | ------------------ ------------------ 1593| 0| version->changed_list, 1594| 0| link); 1595| 0| } 1596| 0| } else if (version->serial == qpdb->least_serial) { ------------------ | Branch (1596:14): [True: 0, False: 0] ------------------ 1597| 0| INSIST(ISC_LIST_EMPTY(version->changed_list)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1598| 0| } 1599| 0| ISC_LIST_UNLINK(qpdb->open_versions, version, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1600| 0| } 1601| 0| least_serial = qpdb->least_serial; 1602| 0| RWUNLOCK(&qpdb->lock, isc_rwlocktype_write); ------------------ | | 38| 0| { \ | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 0| { \ | | | | 283| 0| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 0] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 0] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 0] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 1603| | 1604| 0| if (cleanup_version != NULL) { ------------------ | Branch (1604:6): [True: 0, False: 0] ------------------ 1605| 0| isc_refcount_destroy(&cleanup_version->references); ------------------ | | 60| 0| ISC_REQUIRE(isc_refcount_current(target) == 0) | | ------------------ | | | | 42| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1606| 0| INSIST(ISC_LIST_EMPTY(cleanup_version->changed_list)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1607| 0| cleanup_gluelists(&cleanup_version->glue_stack); 1608| 0| cds_wfs_destroy(&cleanup_version->glue_stack); 1609| 0| isc_rwlock_destroy(&cleanup_version->rwlock); 1610| 0| isc_mem_put(qpdb->common.mctx, cleanup_version, ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 1611| 0| sizeof(*cleanup_version)); 1612| 0| } 1613| | 1614| | /* 1615| | * Commit/rollback re-signed headers. 1616| | */ 1617| 0| ISC_LIST_FOREACH(resigned_list, resigned, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 1618| 0| isc_rwlock_t *nlock = NULL; 1619| 0| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1620| 0| dns_vecheader_t *header = resigned->header; 1621| 0| qpznode_t *resigned_node = resigned->node; 1622| | 1623| 0| ISC_LIST_UNLINK(resigned_list, resigned, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1624| | 1625| 0| nlock = qpzone_get_lock(resigned_node); 1626| 0| NODE_WRLOCK(nlock, &nlocktype); ------------------ | | 43| 0|#define NODE_WRLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_write, tp); | | ------------------ | | | | 31| 0| { \ | | | | 32| 0| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 0| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 0| { \ | | | | | | 31| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 0| (t), __FILE__, __LINE__)); \ | | | | | | 33| 0| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 0| { \ | | | | | | | | 253| 0| switch (type) { \ | | | | | | | | 254| 0| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 0| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 0| } \ | | | | | | | | 263| 0| } | | | | | | ------------------ | | | | | | 34| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 0| } | | | | ------------------ | | | | 34| 0| *tp = t; \ | | | | 35| 0| } | | ------------------ ------------------ 1627| 0| if (rollback && !IGNORE(header)) { ------------------ | | 30| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 31| 0| DNS_VECHEADERATTR_IGNORE) != 0) ------------------ | Branch (1627:7): [True: 0, False: 0] | Branch (1627:19): [True: 0, False: 0] ------------------ 1628| 0| LOCK(&qpdb->heap->lock); ------------------ | | 26| 0| { \ | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 0| __FILE__, __LINE__)); \ | | 29| 0| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 0| { \ | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 1629| 0| resign_register(qpdb->heap, resigned_node, header); 1630| 0| UNLOCK(&qpdb->heap->lock); ------------------ | | 34| 0| { \ | | 35| 0| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 0| { \ | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 1631| 0| } 1632| 0| qpz_resigned_destroy(db->mctx, &resigned); 1633| 0| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 0| { \ | | 38| 0| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 0| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 1634| 0| } 1635| | 1636| 0| if (ISC_LIST_EMPTY(cleanup_list)) { ------------------ | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (64:30): [True: 0, False: 0] | | ------------------ ------------------ 1637| 0| *versionp = NULL; 1638| 0| return; 1639| 0| } 1640| | 1641| 0| ISC_LIST_FOREACH(cleanup_list, changed, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 1642| 0| isc_rwlock_t *nlock = NULL; 1643| 0| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1644| | 1645| 0| node = changed->node; 1646| 0| nlock = qpzone_get_lock(node); 1647| | 1648| 0| NODE_WRLOCK(nlock, &nlocktype); ------------------ | | 43| 0|#define NODE_WRLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_write, tp); | | ------------------ | | | | 31| 0| { \ | | | | 32| 0| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 0| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 0| { \ | | | | | | 31| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 0| (t), __FILE__, __LINE__)); \ | | | | | | 33| 0| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 0| { \ | | | | | | | | 253| 0| switch (type) { \ | | | | | | | | 254| 0| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 0| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 0| } \ | | | | | | | | 263| 0| } | | | | | | ------------------ | | | | | | 34| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 0| } | | | | ------------------ | | | | 34| 0| *tp = t; \ | | | | 35| 0| } | | ------------------ ------------------ 1649| 0| if (rollback) { ------------------ | Branch (1649:7): [True: 0, False: 0] ------------------ 1650| 0| rollback_node(node, serial); 1651| 0| } 1652| 0| bool has_erefs = qpznode_release(node DNS__DB_FILELINE); 1653| 0| if (!has_erefs) { ------------------ | Branch (1653:7): [True: 0, False: 0] ------------------ 1654| 0| clean_zone_node(qpdb->heap, node, least_serial); 1655| 0| } 1656| | 1657| 0| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 0| { \ | | 38| 0| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 0| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 1658| | 1659| | /* 1660| | * The node reference is released separately above, so 1661| | * we just free the changed structure here. 1662| | */ 1663| 0| isc_mem_put(qpdb->common.mctx, changed, sizeof(*changed)); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 1664| 0| } 1665| | 1666| 0| *versionp = NULL; 1667| 0|} qpzone.c:qpzone_findrdataset: 1674| 14| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 1675| 14| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1676| 14| qpznode_t *node = (qpznode_t *)dbnode; 1677| 14| dns_vecheader_t *found = NULL, *foundsig = NULL; 1678| 14| uint32_t serial; 1679| 14| qpz_version_t *version = (qpz_version_t *)dbversion; 1680| 14| bool close_version = false; 1681| 14| dns_typepair_t typepair, sigpair; 1682| 14| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1683| 14| isc_rwlock_t *nlock = NULL; 1684| | 1685| 14| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 14, False: 0] | | | | | Branch (42:11): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1686| 14| REQUIRE(type != dns_rdatatype_any); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1687| 14| INSIST(version == NULL || version->qpdb == qpdb); ------------------ | | 198| 14|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 4, False: 10] | | | | | Branch (54:11): [True: 10, False: 0] | | | | ------------------ | | | | 55| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1688| | 1689| 14| if (type == dns_rdatatype_none && covers == dns_rdatatype_none) { ------------------ | | 114| 28|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ if (type == dns_rdatatype_none && covers == dns_rdatatype_none) { ------------------ | | 114| 0|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1689:6): [True: 0, False: 14] | Branch (1689:36): [True: 0, False: 0] ------------------ 1690| 0| return ISC_R_NOTFOUND; 1691| 0| } 1692| | 1693| 14| if (version == NULL) { ------------------ | Branch (1693:6): [True: 4, False: 10] ------------------ 1694| 4| currentversion(db, (dns_dbversion_t **)&version); 1695| 4| close_version = true; 1696| 4| } 1697| 14| serial = version->serial; 1698| | 1699| 14| nlock = qpzone_get_lock(node); 1700| 14| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 14|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 14| { \ | | | | 32| 14| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 14| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 14| { \ | | | | | | 31| 14| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 14| (t), __FILE__, __LINE__)); \ | | | | | | 33| 14| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 14| { \ | | | | | | | | 253| 14| switch (type) { \ | | | | | | | | 254| 14| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 14, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 14| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 14| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 14] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 14] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 14| } \ | | | | | | | | 263| 14| } | | | | | | ------------------ | | | | | | 34| 14| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 14| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 14| } | | | | ------------------ | | | | 34| 14| *tp = t; \ | | | | 35| 14| } | | ------------------ ------------------ 1701| | 1702| 14| typepair = DNS_TYPEPAIR_VALUE(type, covers); ------------------ | | 47| 14| ({ \ | | 48| 14| DNS__TYPEPAIR_CHECK(base, covers); \ | | ------------------ | | | | 26| 14|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 49| 14| DNS__TYPEPAIR_VALUE(base, covers); \ | | ------------------ | | | | 44| 14| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 14| (((uint32_t)base) & 0xffff)) | | ------------------ | | 50| 14| }) ------------------ 1703| 14| if (covers == dns_rdatatype_none) { ------------------ | | 114| 14|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1703:6): [True: 14, False: 0] ------------------ 1704| 14| sigpair = DNS_SIGTYPEPAIR(type); ------------------ | | 53| 14|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 14| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 14| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 1705| 14| } else { 1706| 0| sigpair = dns_typepair_none; 1707| 0| } 1708| | 1709| 42| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 14| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 14| for (typeof(first) elt = first, \ | | | | 64| 14| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 14|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 14, False: 0] | | | | ------------------ | | | | 65| 56| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 42, False: 14] | | | | ------------------ | | | | 66| 42| elt = elt##_next, \ | | | | 67| 42| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 28|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 28, False: 14] | | | | ------------------ | | ------------------ ------------------ 1710| 42| dns_vecheader_t *header = first_existing_header(top, serial); 1711| 42| if (header != NULL) { ------------------ | Branch (1711:7): [True: 42, False: 0] ------------------ 1712| | /* 1713| | * We have an active, extant rdataset. If it's a 1714| | * type we're looking for, remember it. 1715| | */ 1716| 42| if (top->typepair == typepair) { ------------------ | Branch (1716:8): [True: 4, False: 38] ------------------ 1717| 4| found = header; 1718| 4| if (foundsig != NULL) { ------------------ | Branch (1718:9): [True: 0, False: 4] ------------------ 1719| 0| break; 1720| 0| } 1721| 38| } else if (top->typepair == sigpair) { ------------------ | Branch (1721:15): [True: 0, False: 38] ------------------ 1722| 0| foundsig = header; 1723| 0| if (found != NULL) { ------------------ | Branch (1723:9): [True: 0, False: 0] ------------------ 1724| 0| break; 1725| 0| } 1726| 0| } 1727| 42| } 1728| 42| } 1729| 14| if (found != NULL) { ------------------ | Branch (1729:6): [True: 4, False: 10] ------------------ 1730| 4| bindrdataset(qpdb, found, rdataset DNS__DB_FLARG_PASS); 1731| 4| if (foundsig != NULL) { ------------------ | Branch (1731:7): [True: 0, False: 4] ------------------ 1732| 0| bindrdataset(qpdb, foundsig, 1733| 0| sigrdataset DNS__DB_FLARG_PASS); 1734| 0| } 1735| 4| } 1736| | 1737| 14| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 14| { \ | | 38| 14| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 14| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 14| { \ | | | | 39| 14| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 14| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 14| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 14| { \ | | | | | | 283| 14| switch (type) { \ | | | | | | 284| 14| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 14, False: 0] | | | | | | ------------------ | | | | | | 285| 14| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 14| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 14] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 14] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 14| } \ | | | | | | 293| 14| } | | | | ------------------ | | | | 42| 14| } | | ------------------ | | 40| 14| *tp = isc_rwlocktype_none; \ | | 41| 14| } ------------------ 1738| | 1739| 14| if (close_version) { ------------------ | Branch (1739:6): [True: 4, False: 10] ------------------ 1740| 4| closeversion(db, (dns_dbversion_t **)&version, 1741| 4| false DNS__DB_FLARG_PASS); 1742| 4| } 1743| | 1744| 14| if (found == NULL) { ------------------ | Branch (1744:6): [True: 10, False: 4] ------------------ 1745| 10| return ISC_R_NOTFOUND; 1746| 10| } 1747| | 1748| 4| return ISC_R_SUCCESS; 1749| 14|} qpzone.c:issecure: 2375| 2|issecure(dns_db_t *db) { 2376| 2| qpzonedb_t *qpdb = NULL; 2377| 2| bool secure; 2378| | 2379| 2| qpdb = (qpzonedb_t *)db; 2380| | 2381| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2382| | 2383| 2| RWLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 30| 2| { \ | | 31| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 2| (t), __FILE__, __LINE__)); \ | | 33| 2| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 2| { \ | | | | 253| 2| switch (type) { \ | | | | 254| 2| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 2, False: 0] | | | | ------------------ | | | | 255| 2| isc_rwlock_rdlock(rwl); \ | | | | 256| 2| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 2] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 2] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 2| } \ | | | | 263| 2| } | | ------------------ | | 34| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 2| (lp), (t), __FILE__, __LINE__)); \ | | 36| 2| } ------------------ 2384| 2| secure = qpdb->current_version->secure; 2385| 2| RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 38| 2| { \ | | 39| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 2| (lp), (t), __FILE__, __LINE__)); \ | | 41| 2| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 2| { \ | | | | 283| 2| switch (type) { \ | | | | 284| 2| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 2, False: 0] | | | | ------------------ | | | | 285| 2| isc_rwlock_rdunlock(rwl); \ | | | | 286| 2| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 2] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 2] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 2386| | 2387| 2| return secure; 2388| 2|} qpzone.c:nodecount: 4038| 2|nodecount(dns_db_t *db) { 4039| 2| qpzonedb_t *qpdb = qpdb = (qpzonedb_t *)db; 4040| 2| dns_qp_memusage_t mu; 4041| | 4042| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4043| | 4044| 2| mu = dns_qpmulti_memusage(qpdb->tree); 4045| | 4046| 2| return mu.leaves; 4047| 2|} qpzone.c:getoriginnode: 4050| 2|getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { 4051| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 4052| | 4053| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4054| 2| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4055| | 4056| | /* Note that the access to the origin node doesn't require a DB lock */ 4057| 2| INSIST(qpdb->origin != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4058| 2| qpznode_acquire(qpdb->origin DNS__DB_FLARG_PASS); 4059| 2| *nodep = (dns_dbnode_t *)qpdb->origin; 4060| | 4061| 2| return ISC_R_SUCCESS; 4062| 2|} qpzone.c:qpzone_findnode: 2681| 6| dns_dbnode_t **nodep DNS__DB_FLARG) { 2682| 6| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2683| | 2684| 6| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2685| | 2686| 6| dns_qpread_t qpr = { 0 }; 2687| 6| dns_qp_t *qp = begin_transaction(qpdb, &qpr, create); 2688| | 2689| 6| isc_result_t result = findnodeintree(qpdb, qp, name, create, false, 2690| 6| nodep DNS__DB_FLARG_PASS); 2691| | 2692| 6| end_transaction(qpdb, qp, create); 2693| | 2694| 6| return result; 2695| 6|} qpzone.c:qpzone_find: 3470| 209| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 3471| 209| isc_result_t result; 3472| 209| qpzonedb_t *qpdb = (qpzonedb_t *)db; 3473| 209| qpznode_t *node = NULL; 3474| 209| bool cname_ok = true, close_version = false; 3475| 209| bool maybe_zonecut = false, at_zonecut = false; 3476| 209| bool wild = false, empty_node = false; 3477| 209| bool nsec3 = false; 3478| 209| dns_vecheader_t *found = NULL, *nsecheader = NULL; 3479| 209| dns_vecheader_t *foundsig = NULL, *cnamesig = NULL, *nsecsig = NULL; 3480| 209| dns_typepair_t sigpair; 3481| 209| bool active; 3482| 209| isc_rwlock_t *nlock = NULL; 3483| 209| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 3484| | 3485| 209| REQUIRE(VALID_QPZONE((qpzonedb_t *)db)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 3486| 209| INSIST(version == NULL || ------------------ | | 198| 209|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 209| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 209, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3487| 209| ((qpz_version_t *)version)->qpdb == (qpzonedb_t *)db); 3488| | 3489| | /* 3490| | * If the caller didn't supply a version, attach to the current 3491| | * version. 3492| | */ 3493| 209| if (version == NULL) { ------------------ | Branch (3493:6): [True: 209, False: 0] ------------------ 3494| 209| currentversion(db, &version); 3495| 209| close_version = true; 3496| 209| } 3497| | 3498| 209| dns_namespace_t nspace; 3499| 209| qpz_search_t search; 3500| 209| qpz_search_init(&search, (qpzonedb_t *)db, (qpz_version_t *)version, 3501| 209| options); 3502| | 3503| 209| if ((options & DNS_DBFIND_FORCENSEC3) != 0) { ------------------ | Branch (3503:6): [True: 0, False: 209] ------------------ 3504| 0| nsec3 = true; 3505| 0| nspace = DNS_DBNAMESPACE_NSEC3; 3506| 209| } else { 3507| 209| nspace = DNS_DBNAMESPACE_NORMAL; 3508| 209| } 3509| 209| dns_qpmulti_query(qpdb->tree, &search.qpr); 3510| | 3511| | /* 3512| | * Search down from the root of the tree. 3513| | */ 3514| 209| result = dns_qp_lookup(&search.qpr, name, nspace, &search.iter, 3515| 209| &search.chain, (void **)&node, NULL); 3516| 209| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (3516:6): [True: 209, False: 0] ------------------ 3517| 209| dns_name_copy(&node->name, foundname); 3518| 209| } 3519| | 3520| | /* 3521| | * Check the QP chain to see if there's a node above us with a 3522| | * active DNAME or NS rdatasets. 3523| | * 3524| | * We're only interested in nodes above QNAME, so if the result 3525| | * was success, then we skip the last item in the chain. 3526| | */ 3527| 209| unsigned int clen = dns_qpchain_length(&search.chain); 3528| 209| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3528:6): [True: 132, False: 77] ------------------ 3529| 132| clen--; 3530| 132| } 3531| 286| for (unsigned int i = 0; i < clen && search.zonecut == NULL; i++) { ------------------ | Branch (3531:27): [True: 77, False: 209] | Branch (3531:39): [True: 77, False: 0] ------------------ 3532| 77| qpznode_t *n = NULL; 3533| 77| isc_result_t tresult; 3534| | 3535| 77| dns_qpchain_node(&search.chain, i, (void **)&n, NULL); 3536| 77| tresult = qpzone_check_zonecut(n, &search DNS__DB_FLARG_PASS); 3537| 77| if (tresult != DNS_R_CONTINUE) { ------------------ | Branch (3537:7): [True: 0, False: 77] ------------------ 3538| 0| result = tresult; 3539| 0| search.chain.len = i - 1; 3540| 0| dns_name_copy(&n->name, foundname); 3541| 0| node = n; 3542| 0| } 3543| 77| } 3544| | 3545| 209| if (result == DNS_R_PARTIALMATCH) { ------------------ | Branch (3545:6): [True: 77, False: 132] ------------------ 3546| 77| partial_match: 3547| 77| if (search.zonecut != NULL) { ------------------ | Branch (3547:7): [True: 0, False: 77] ------------------ 3548| 0| result = qpzone_setup_delegation( 3549| 0| &search, nodep, foundname, rdataset, 3550| 0| sigrdataset DNS__DB_FLARG_PASS); 3551| 0| goto tree_exit; 3552| 0| } 3553| | 3554| 77| if (search.wild) { ------------------ | Branch (3554:7): [True: 0, False: 77] ------------------ 3555| | /* 3556| | * At least one of the levels in the search chain 3557| | * potentially has a wildcard. For each such level, 3558| | * we must see if there's a matching wildcard active 3559| | * in the current version. 3560| | */ 3561| 0| result = find_wildcard(&search, &node, name, nspace); 3562| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3562:8): [True: 0, False: 0] ------------------ 3563| 0| dns_name_copy(name, foundname); 3564| 0| wild = true; 3565| 0| goto found; 3566| 0| } else if (result != ISC_R_NOTFOUND) { ------------------ | Branch (3566:15): [True: 0, False: 0] ------------------ 3567| 0| goto tree_exit; 3568| 0| } 3569| 0| } 3570| | 3571| 77| active = false; 3572| 77| if (!nsec3) { ------------------ | Branch (3572:7): [True: 77, False: 0] ------------------ 3573| | /* 3574| | * The NSEC3 tree won't have empty nodes, 3575| | * so it isn't necessary to check for them. 3576| | */ 3577| 77| dns_qpiter_t iter = search.iter; 3578| 77| active = activeempty(&search, &iter, name); 3579| 77| } 3580| | 3581| | /* 3582| | * If we're here, then the name does not exist, is not 3583| | * beneath a zonecut, and there's no matching wildcard. 3584| | */ 3585| 77| if ((search.version->secure && !search.version->havensec3) || ------------------ | Branch (3585:8): [True: 0, False: 77] | Branch (3585:34): [True: 0, False: 0] ------------------ 3586| 77| nsec3) ------------------ | Branch (3586:7): [True: 0, False: 77] ------------------ 3587| 0| { 3588| 0| result = find_closest_nsec( 3589| 0| &search, nodep, foundname, rdataset, 3590| 0| sigrdataset, nsec3, 3591| 0| search.version->secure DNS__DB_FLARG_PASS); 3592| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3592:8): [True: 0, False: 0] ------------------ 3593| 0| result = active ? DNS_R_EMPTYNAME ------------------ | Branch (3593:14): [True: 0, False: 0] ------------------ 3594| 0| : DNS_R_NXDOMAIN; 3595| 0| } 3596| 77| } else { 3597| 77| result = active ? DNS_R_EMPTYNAME : DNS_R_NXDOMAIN; ------------------ | Branch (3597:13): [True: 0, False: 77] ------------------ 3598| 77| } 3599| 77| goto tree_exit; 3600| 132| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (3600:13): [True: 0, False: 132] ------------------ 3601| 0| goto tree_exit; 3602| 0| } 3603| | 3604| 132|found: 3605| | /* 3606| | * We have found a node whose name is the desired name, or we 3607| | * have matched a wildcard. 3608| | */ 3609| | 3610| 132| nlock = qpzone_get_lock(node); 3611| 132| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 132|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 132| { \ | | | | 32| 132| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 132| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 132| { \ | | | | | | 31| 132| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 132| (t), __FILE__, __LINE__)); \ | | | | | | 33| 132| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 132| { \ | | | | | | | | 253| 132| switch (type) { \ | | | | | | | | 254| 132| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 132, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 132| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 132| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 132] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 132] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 132| } \ | | | | | | | | 263| 132| } | | | | | | ------------------ | | | | | | 34| 132| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 132| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 132| } | | | | ------------------ | | | | 34| 132| *tp = t; \ | | | | 35| 132| } | | ------------------ ------------------ 3612| | 3613| 132| if (search.zonecut != NULL) { ------------------ | Branch (3613:6): [True: 0, False: 132] ------------------ 3614| | /* 3615| | * If we're beneath a zone cut, we don't want to look for 3616| | * CNAMEs because they're not legitimate zone glue. 3617| | */ 3618| 0| cname_ok = false; 3619| 132| } else { 3620| | /* 3621| | * The node may be a zone cut itself. If it might be one, 3622| | * make sure we check for it later. 3623| | * 3624| | * DS records live above the zone cut in ordinary zone so 3625| | * we want to ignore any referral. 3626| | * 3627| | * Stub zones don't have anything "above" the delegation so 3628| | * we always return a referral. 3629| | */ 3630| 132| if (node->delegating && ((node != search.qpdb->origin && ------------------ | Branch (3630:7): [True: 0, False: 132] | Branch (3630:29): [True: 0, False: 0] ------------------ 3631| 0| !dns_rdatatype_atparent(type)) || ------------------ | Branch (3631:8): [True: 0, False: 0] ------------------ 3632| 0| IS_STUB(search.qpdb))) ------------------ | | 84| 0|#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0) | | ------------------ | | | Branch (84:22): [True: 0, False: 0] | | ------------------ ------------------ 3633| 0| { 3634| 0| maybe_zonecut = true; 3635| 0| } 3636| 132| } 3637| | 3638| | /* 3639| | * Certain DNSSEC types are not subject to CNAME matching 3640| | * (RFC4035, section 2.5). 3641| | * 3642| | * We don't check for RRSIG, because we don't store RRSIG records 3643| | * directly. 3644| | */ 3645| 132| if (type == dns_rdatatype_nsec) { ------------------ | | 161| 132|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (3645:6): [True: 0, False: 132] ------------------ 3646| 0| cname_ok = false; 3647| 0| } 3648| | 3649| | /* 3650| | * We now go looking for rdata... 3651| | */ 3652| | 3653| 132| sigpair = DNS_SIGTYPEPAIR(type); ------------------ | | 53| 132|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 132| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 132| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3654| 132| empty_node = true; 3655| 396| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 132| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 132| for (typeof(first) elt = first, \ | | | | 64| 132| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 132|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 132, False: 0] | | | | ------------------ | | | | 65| 528| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 396, False: 132] | | | | ------------------ | | | | 66| 396| elt = elt##_next, \ | | | | 67| 396| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 264|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 264, False: 132] | | | | ------------------ | | ------------------ ------------------ 3656| | /* 3657| | * Look for an active, extant rdataset. 3658| | */ 3659| 396| dns_vecheader_t *header = first_existing_header(top, 3660| 396| search.serial); 3661| 396| if (header != NULL) { ------------------ | Branch (3661:7): [True: 396, False: 0] ------------------ 3662| | /* 3663| | * We now know that there is at least one active 3664| | * rdataset at this node. 3665| | */ 3666| 396| empty_node = false; 3667| | 3668| | /* 3669| | * Do special zone cut handling, if requested. 3670| | */ 3671| 396| if (maybe_zonecut && ------------------ | Branch (3671:8): [True: 0, False: 396] ------------------ 3672| 0| top->typepair == DNS_TYPEPAIR(dns_rdatatype_ns)) ------------------ | | 52| 0|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 0| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 0| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3672:8): [True: 0, False: 0] ------------------ 3673| 0| { 3674| | /* 3675| | * We increment the reference count on node to 3676| | * ensure that search->zonecut_header will 3677| | * still be valid later. 3678| | */ 3679| 0| qpznode_acquire(node DNS__DB_FLARG_PASS); 3680| 0| search.zonecut = node; 3681| 0| search.zonecut_header = header; 3682| 0| search.zonecut_sigheader = NULL; 3683| 0| search.need_cleanup = true; 3684| 0| maybe_zonecut = false; 3685| 0| at_zonecut = true; 3686| | 3687| 0| if ((search.options & DNS_DBFIND_GLUEOK) == 0 && ------------------ | Branch (3687:9): [True: 0, False: 0] ------------------ 3688| 0| type != dns_rdatatype_nsec) ------------------ | | 161| 0|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (3688:9): [True: 0, False: 0] ------------------ 3689| 0| { 3690| | /* 3691| | * Glue is not OK, but any answer we 3692| | * could return would be glue. Return 3693| | * the delegation. 3694| | */ 3695| 0| found = NULL; 3696| 0| break; 3697| 0| } 3698| 0| if (found != NULL && foundsig != NULL) { ------------------ | Branch (3698:9): [True: 0, False: 0] | Branch (3698:26): [True: 0, False: 0] ------------------ 3699| 0| break; 3700| 0| } 3701| 0| } 3702| | 3703| | /* 3704| | * If the NSEC3 record doesn't match the chain 3705| | * we are using behave as if it isn't here. 3706| | */ 3707| 396| if (top->typepair == ------------------ | Branch (3707:8): [True: 0, False: 396] ------------------ 3708| 396| DNS_TYPEPAIR(dns_rdatatype_nsec3) && ------------------ | | 52| 396|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 792| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 792| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3709| 0| !matchparams(header, &search)) ------------------ | Branch (3709:8): [True: 0, False: 0] ------------------ 3710| 0| { 3711| 0| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 0| { \ | | 38| 0| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 0| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3712| 0| goto partial_match; 3713| 0| } 3714| | /* 3715| | * If we found a type we were looking for, 3716| | * remember it. 3717| | */ 3718| 396| if (top->typepair == type || ------------------ | Branch (3718:8): [True: 132, False: 264] ------------------ 3719| 264| type == dns_rdatatype_any || ------------------ | | 205| 660|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3719:8): [True: 0, False: 264] ------------------ 3720| 264| (top->typepair == ------------------ | Branch (3720:9): [True: 0, False: 264] ------------------ 3721| 264| DNS_TYPEPAIR(dns_rdatatype_cname) && ------------------ | | 52| 264|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 528| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 528| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3722| 0| cname_ok)) ------------------ | Branch (3722:9): [True: 0, False: 0] ------------------ 3723| 132| { 3724| | /* 3725| | * We've found the answer! 3726| | */ 3727| 132| found = header; 3728| 132| if (top->typepair == ------------------ | Branch (3728:9): [True: 0, False: 132] ------------------ 3729| 132| DNS_TYPEPAIR(dns_rdatatype_cname) && ------------------ | | 52| 132|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 264| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 264| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3730| 0| cname_ok) ------------------ | Branch (3730:9): [True: 0, False: 0] ------------------ 3731| 0| { 3732| | /* 3733| | * We may be finding a CNAME instead 3734| | * of the desired type. 3735| | * 3736| | * If we've already got the CNAME RRSIG, 3737| | * use it, otherwise change sigtype 3738| | * so that we find it. 3739| | */ 3740| 0| if (cnamesig != NULL) { ------------------ | Branch (3740:10): [True: 0, False: 0] ------------------ 3741| 0| foundsig = cnamesig; 3742| 0| } else { 3743| 0| sigpair = DNS_SIGTYPEPAIR( ------------------ | | 53| 0|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 0| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 0| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3744| 0| dns_rdatatype_cname); 3745| 0| } 3746| 0| } 3747| | /* 3748| | * If we've got all we need, end the search. 3749| | */ 3750| 132| if (!maybe_zonecut && foundsig != NULL) { ------------------ | Branch (3750:9): [True: 132, False: 0] | Branch (3750:27): [True: 0, False: 132] ------------------ 3751| 0| break; 3752| 0| } 3753| 264| } else if (top->typepair == sigpair) { ------------------ | Branch (3753:15): [True: 0, False: 264] ------------------ 3754| | /* 3755| | * We've found the RRSIG rdataset for our 3756| | * target type. Remember it. 3757| | */ 3758| 0| foundsig = header; 3759| | /* 3760| | * If we've got all we need, end the search. 3761| | */ 3762| 0| if (!maybe_zonecut && found != NULL) { ------------------ | Branch (3762:9): [True: 0, False: 0] | Branch (3762:27): [True: 0, False: 0] ------------------ 3763| 0| break; 3764| 0| } 3765| 264| } else if (top->typepair == ------------------ | Branch (3765:15): [True: 0, False: 264] ------------------ 3766| 264| DNS_TYPEPAIR(dns_rdatatype_nsec) && ------------------ | | 52| 264|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 528| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 528| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3767| 0| !search.version->havensec3) ------------------ | Branch (3767:8): [True: 0, False: 0] ------------------ 3768| 0| { 3769| | /* 3770| | * Remember a NSEC rdataset even if we're 3771| | * not specifically looking for it, because 3772| | * we might need it later. 3773| | */ 3774| 0| nsecheader = header; 3775| 264| } else if (top->typepair == ------------------ | Branch (3775:15): [True: 0, False: 264] ------------------ 3776| 264| DNS_SIGTYPEPAIR( ------------------ | | 53| 264|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 528| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 528| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3777| 0| dns_rdatatype_nsec) && 3778| 0| !search.version->havensec3) ------------------ | Branch (3778:8): [True: 0, False: 0] ------------------ 3779| 0| { 3780| | /* 3781| | * If we need the NSEC rdataset, we'll also 3782| | * need its signature. 3783| | */ 3784| 0| nsecsig = header; 3785| 264| } else if (cname_ok && ------------------ | Branch (3785:15): [True: 264, False: 0] ------------------ 3786| 264| top->typepair == ------------------ | Branch (3786:8): [True: 0, False: 264] ------------------ 3787| 264| DNS_SIGTYPEPAIR(dns_rdatatype_cname)) ------------------ | | 53| 264|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 264| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 264| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3788| 0| { 3789| | /* 3790| | * If we get a CNAME match, we'll also need 3791| | * its signature. 3792| | */ 3793| 0| cnamesig = header; 3794| 0| } 3795| 396| } 3796| 396| } 3797| | 3798| 132| if (empty_node) { ------------------ | Branch (3798:6): [True: 0, False: 132] ------------------ 3799| | /* 3800| | * We have an exact match for the name, but there are no 3801| | * active rdatasets in the desired version. That means that 3802| | * this node doesn't exist in the desired version. 3803| | * If there's a node above this one, reassign the 3804| | * foundname to the parent and treat this as a partial 3805| | * match. 3806| | */ 3807| 0| if (!wild) { ------------------ | Branch (3807:7): [True: 0, False: 0] ------------------ 3808| 0| unsigned int len = search.chain.len - 1; 3809| 0| if (len > 0) { ------------------ | Branch (3809:8): [True: 0, False: 0] ------------------ 3810| 0| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 0| { \ | | 38| 0| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 0| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3811| 0| dns_qpchain_node(&search.chain, len - 1, 3812| 0| (void **)&node, NULL); 3813| 0| dns_name_copy(&node->name, foundname); 3814| 0| goto partial_match; 3815| 0| } 3816| 0| } 3817| 0| } 3818| | 3819| | /* 3820| | * If we didn't find what we were looking for... 3821| | */ 3822| 132| if (found == NULL) { ------------------ | Branch (3822:6): [True: 0, False: 132] ------------------ 3823| 0| if (search.zonecut != NULL) { ------------------ | Branch (3823:7): [True: 0, False: 0] ------------------ 3824| | /* 3825| | * We were trying to find glue at a node beneath a 3826| | * zone cut, but didn't. 3827| | * 3828| | * Return the delegation. 3829| | */ 3830| 0| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 0| { \ | | 38| 0| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 0| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3831| 0| result = qpzone_setup_delegation( 3832| 0| &search, nodep, foundname, rdataset, 3833| 0| sigrdataset DNS__DB_FLARG_PASS); 3834| 0| goto tree_exit; 3835| 0| } 3836| | /* 3837| | * The desired type doesn't exist. 3838| | */ 3839| 0| result = DNS_R_NXRRSET; 3840| 0| if (search.version->secure && !search.version->havensec3 && ------------------ | Branch (3840:7): [True: 0, False: 0] | Branch (3840:33): [True: 0, False: 0] ------------------ 3841| 0| (nsecheader == NULL || nsecsig == NULL)) ------------------ | Branch (3841:8): [True: 0, False: 0] | Branch (3841:30): [True: 0, False: 0] ------------------ 3842| 0| { 3843| | /* 3844| | * The zone is secure but there's no NSEC, 3845| | * or the NSEC has no signature! 3846| | */ 3847| 0| if (!wild) { ------------------ | Branch (3847:8): [True: 0, False: 0] ------------------ 3848| 0| result = DNS_R_BADDB; 3849| 0| goto node_exit; 3850| 0| } 3851| | 3852| 0| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 0| { \ | | 38| 0| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 0| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3853| 0| result = find_closest_nsec( 3854| 0| &search, nodep, foundname, rdataset, 3855| 0| sigrdataset, false, 3856| 0| search.version->secure DNS__DB_FLARG_PASS); 3857| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3857:8): [True: 0, False: 0] ------------------ 3858| 0| result = DNS_R_EMPTYWILD; 3859| 0| } 3860| 0| goto tree_exit; 3861| 0| } 3862| 0| if (nodep != NULL) { ------------------ | Branch (3862:7): [True: 0, False: 0] ------------------ 3863| 0| qpznode_acquire(node DNS__DB_FLARG_PASS); 3864| 0| *nodep = (dns_dbnode_t *)node; 3865| 0| } 3866| 0| if (search.version->secure && !search.version->havensec3) { ------------------ | Branch (3866:7): [True: 0, False: 0] | Branch (3866:33): [True: 0, False: 0] ------------------ 3867| 0| bindrdataset(search.qpdb, nsecheader, 3868| 0| rdataset DNS__DB_FLARG_PASS); 3869| 0| if (nsecsig != NULL) { ------------------ | Branch (3869:8): [True: 0, False: 0] ------------------ 3870| 0| bindrdataset(search.qpdb, nsecsig, 3871| 0| sigrdataset DNS__DB_FLARG_PASS); 3872| 0| } 3873| 0| } 3874| 0| if (wild) { ------------------ | Branch (3874:7): [True: 0, False: 0] ------------------ 3875| 0| foundname->attributes.wildcard = true; 3876| 0| } 3877| 0| goto node_exit; 3878| 0| } 3879| | 3880| | /* 3881| | * We found what we were looking for, or we found a CNAME. 3882| | */ 3883| 132| if (type != found->typepair && type != dns_rdatatype_any && ------------------ | | 205| 132|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3883:6): [True: 0, False: 132] | Branch (3883:33): [True: 0, False: 0] ------------------ 3884| 0| found->typepair == DNS_TYPEPAIR(dns_rdatatype_cname)) ------------------ | | 52| 0|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 0| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 0| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3884:6): [True: 0, False: 0] ------------------ 3885| 0| { 3886| | /* 3887| | * We weren't doing an ANY query and we found a CNAME instead 3888| | * of the type we were looking for, so we need to indicate 3889| | * that result to the caller. 3890| | */ 3891| 0| result = DNS_R_CNAME; 3892| 132| } else if (search.zonecut != NULL) { ------------------ | Branch (3892:13): [True: 0, False: 132] ------------------ 3893| | /* 3894| | * If we're beneath a zone cut, we must indicate that the 3895| | * result is glue, unless we're actually at the zone cut 3896| | * and the type is NSEC. 3897| | */ 3898| 0| if (search.zonecut == node) { ------------------ | Branch (3898:7): [True: 0, False: 0] ------------------ 3899| 0| if (dns_rdatatype_isnsec(type)) { ------------------ | Branch (3899:8): [True: 0, False: 0] ------------------ 3900| 0| result = ISC_R_SUCCESS; 3901| 0| } else if (type == dns_rdatatype_any) { ------------------ | | 205| 0|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3901:15): [True: 0, False: 0] ------------------ 3902| 0| result = DNS_R_ZONECUT; 3903| 0| } else { 3904| 0| result = DNS_R_GLUE; 3905| 0| } 3906| 0| } else { 3907| 0| result = DNS_R_GLUE; 3908| 0| } 3909| 132| } else { 3910| | /* 3911| | * An ordinary successful query! 3912| | */ 3913| 132| result = ISC_R_SUCCESS; 3914| 132| } 3915| | 3916| 132| if (nodep != NULL) { ------------------ | Branch (3916:6): [True: 132, False: 0] ------------------ 3917| 132| if (!at_zonecut) { ------------------ | Branch (3917:7): [True: 132, False: 0] ------------------ 3918| 132| qpznode_acquire(node DNS__DB_FLARG_PASS); 3919| 132| } else { 3920| 0| search.need_cleanup = false; 3921| 0| } 3922| 132| *nodep = (dns_dbnode_t *)node; 3923| 132| } 3924| | 3925| 132| if (type != dns_rdatatype_any) { ------------------ | | 205| 132|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3925:6): [True: 132, False: 0] ------------------ 3926| 132| bindrdataset(search.qpdb, found, rdataset DNS__DB_FLARG_PASS); 3927| 132| if (foundsig != NULL) { ------------------ | Branch (3927:7): [True: 0, False: 132] ------------------ 3928| 0| bindrdataset(search.qpdb, foundsig, 3929| 0| sigrdataset DNS__DB_FLARG_PASS); 3930| 0| } 3931| 132| } 3932| | 3933| 132| if (wild) { ------------------ | Branch (3933:6): [True: 0, False: 132] ------------------ 3934| 0| foundname->attributes.wildcard = true; 3935| 0| } 3936| | 3937| 132|node_exit: 3938| 132| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 132| { \ | | 38| 132| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 132| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 132| { \ | | | | 39| 132| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 132| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 132| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 132| { \ | | | | | | 283| 132| switch (type) { \ | | | | | | 284| 132| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 132, False: 0] | | | | | | ------------------ | | | | | | 285| 132| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 132| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 132] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 132] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 132| } \ | | | | | | 293| 132| } | | | | ------------------ | | | | 42| 132| } | | ------------------ | | 40| 132| *tp = isc_rwlocktype_none; \ | | 41| 132| } ------------------ 3939| | 3940| 209|tree_exit: 3941| 209| dns_qpread_destroy(qpdb->tree, &search.qpr); 3942| | 3943| | /* 3944| | * If we found a zonecut but aren't going to use it, we have to 3945| | * let go of it. 3946| | */ 3947| 209| if (search.need_cleanup) { ------------------ | Branch (3947:6): [True: 0, False: 209] ------------------ 3948| 0| node = search.zonecut; 3949| 0| INSIST(node != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3950| 0| nlock = qpzone_get_lock(node); 3951| | 3952| 0| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 0|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 0| { \ | | | | 32| 0| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 0| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 0| { \ | | | | | | 31| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 0| (t), __FILE__, __LINE__)); \ | | | | | | 33| 0| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 0| { \ | | | | | | | | 253| 0| switch (type) { \ | | | | | | | | 254| 0| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 0| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 0| } \ | | | | | | | | 263| 0| } | | | | | | ------------------ | | | | | | 34| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 0| } | | | | ------------------ | | | | 34| 0| *tp = t; \ | | | | 35| 0| } | | ------------------ ------------------ 3953| 0| (void)qpznode_release(node DNS__DB_FLARG_PASS); 3954| 0| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 0| { \ | | 38| 0| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 0| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3955| 0| } 3956| | 3957| 209| if (close_version) { ------------------ | Branch (3957:6): [True: 209, False: 0] ------------------ 3958| 209| closeversion(db, &version, false DNS__DB_FLARG_PASS); 3959| 209| } 3960| | 3961| 209| return result; 3962| 209|} qpzone.c:qpz_search_init: 3436| 209| unsigned int options) { 3437| | /* 3438| | * qpz_search_t contains two structures with large buffers (dns_qpiter_t 3439| | * and dns_qpchain_t). Those two structures will be initialized later by 3440| | * dns_qp_lookup anyway. 3441| | * To avoid the overhead of zero initialization, we avoid designated 3442| | * initializers and initialize all "small" fields manually. 3443| | */ 3444| 209| search->qpdb = db; 3445| 209| search->version = version; 3446| 209| search->qpr = (dns_qpread_t){}; 3447| 209| search->serial = version->serial; 3448| 209| search->options = options; 3449| | /* 3450| | * qpch->in -- init in dns_qp_lookup 3451| | * qpiter -- init in dns_qp_lookup 3452| | */ 3453| 209| search->copy_name = false; 3454| 209| search->need_cleanup = false; 3455| 209| search->wild = false; 3456| 209| search->zonecut = NULL; 3457| 209| search->zonecut_header = NULL; 3458| | search->zonecut_sigheader = NULL; 3459| 209| dns_fixedname_init(&search->zonecut_name); 3460| 209|} qpzone.c:qpzone_check_zonecut: 3319| 77|qpzone_check_zonecut(qpznode_t *node, void *arg DNS__DB_FLARG) { 3320| 77| qpz_search_t *search = arg; 3321| 77| dns_vecheader_t *dname_header = NULL, *sigdname_header = NULL; 3322| 77| dns_vecheader_t *ns_header = NULL; 3323| 77| dns_vecheader_t *found = NULL; 3324| 77| isc_result_t result = DNS_R_CONTINUE; 3325| 77| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 3326| 77| isc_rwlock_t *nlock = qpzone_get_lock(node); 3327| | 3328| 77| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 77|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 77| { \ | | | | 32| 77| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 77| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 77| { \ | | | | | | 31| 77| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 77| (t), __FILE__, __LINE__)); \ | | | | | | 33| 77| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 77| { \ | | | | | | | | 253| 77| switch (type) { \ | | | | | | | | 254| 77| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 77, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 77| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 77| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 77] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 77] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 77| } \ | | | | | | | | 263| 77| } | | | | | | ------------------ | | | | | | 34| 77| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 77| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 77| } | | | | ------------------ | | | | 34| 77| *tp = t; \ | | | | 35| 77| } | | ------------------ ------------------ 3329| | 3330| | /* 3331| | * Look for an NS or DNAME rdataset active in our version. 3332| | */ 3333| 231| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 77| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 77| for (typeof(first) elt = first, \ | | | | 64| 77| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 77|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 77, False: 0] | | | | ------------------ | | | | 65| 308| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 231, False: 77] | | | | ------------------ | | | | 66| 231| elt = elt##_next, \ | | | | 67| 231| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 154|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 154, False: 77] | | | | ------------------ | | ------------------ ------------------ 3334| 231| if (top->typepair == DNS_TYPEPAIR(dns_rdatatype_ns) || ------------------ | | 52| 231|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 462| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 462| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3334:7): [True: 77, False: 154] ------------------ 3335| 231| top->typepair == DNS_TYPEPAIR(dns_rdatatype_dname) || ------------------ | | 52| 154|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 385| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 385| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3335:7): [True: 0, False: 154] ------------------ 3336| 154| top->typepair == DNS_SIGTYPEPAIR(dns_rdatatype_dname)) ------------------ | | 53| 154|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 154| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 154| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3336:7): [True: 0, False: 154] ------------------ 3337| 77| { 3338| 77| dns_vecheader_t *header = 3339| 77| first_existing_header(top, search->serial); 3340| 77| if (header != NULL) { ------------------ | Branch (3340:8): [True: 77, False: 0] ------------------ 3341| 77| if (top->typepair == ------------------ | Branch (3341:9): [True: 0, False: 77] ------------------ 3342| 77| DNS_TYPEPAIR(dns_rdatatype_dname)) ------------------ | | 52| 77|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 44| 77| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 77| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3343| 0| { 3344| 0| dname_header = header; 3345| 77| } else if (top->typepair == ------------------ | Branch (3345:16): [True: 0, False: 77] ------------------ 3346| 77| DNS_SIGTYPEPAIR(dns_rdatatype_dname)) ------------------ | | 53| 77|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 44| 77| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 77| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3347| 0| { 3348| 0| sigdname_header = header; 3349| 77| } else if (node != search->qpdb->origin || ------------------ | Branch (3349:16): [True: 0, False: 77] ------------------ 3350| 77| IS_STUB(search->qpdb)) ------------------ | | 84| 77|#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0) | | ------------------ | | | Branch (84:22): [True: 0, False: 77] | | ------------------ ------------------ 3351| 0| { 3352| | /* 3353| | * We've found an NS rdataset that 3354| | * isn't at the origin node. 3355| | */ 3356| 0| ns_header = header; 3357| 0| } 3358| 77| } 3359| 77| } 3360| 231| } 3361| | 3362| | /* 3363| | * Did we find anything? 3364| | */ 3365| 77| if (!IS_STUB(search->qpdb) && ns_header != NULL) { ------------------ | | 84| 154|#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0) ------------------ | Branch (3365:6): [True: 77, False: 0] | Branch (3365:32): [True: 0, False: 77] ------------------ 3366| | /* 3367| | * Note that NS has precedence over DNAME if both exist 3368| | * in a zone. Otherwise DNAME take precedence over NS. 3369| | */ 3370| 0| found = ns_header; 3371| 0| search->zonecut_sigheader = NULL; 3372| 77| } else if (dname_header != NULL) { ------------------ | Branch (3372:13): [True: 0, False: 77] ------------------ 3373| 0| found = dname_header; 3374| 0| search->zonecut_sigheader = sigdname_header; 3375| 77| } else if (ns_header != NULL) { ------------------ | Branch (3375:13): [True: 0, False: 77] ------------------ 3376| 0| found = ns_header; 3377| 0| search->zonecut_sigheader = NULL; 3378| 0| } 3379| | 3380| 77| if (found != NULL) { ------------------ | Branch (3380:6): [True: 0, False: 77] ------------------ 3381| | /* 3382| | * We increment the reference count on node to ensure that 3383| | * search->zonecut_header will still be valid later. 3384| | */ 3385| 0| qpznode_acquire(node DNS__DB_FLARG_PASS); 3386| 0| search->zonecut = node; 3387| 0| search->zonecut_header = found; 3388| 0| search->need_cleanup = true; 3389| | /* 3390| | * Since we've found a zonecut, anything beneath it is 3391| | * glue and is not subject to wildcard matching, so we 3392| | * may clear search->wild. 3393| | */ 3394| 0| search->wild = false; 3395| 0| if ((search->options & DNS_DBFIND_GLUEOK) == 0) { ------------------ | Branch (3395:7): [True: 0, False: 0] ------------------ 3396| | /* 3397| | * If the caller does not want to find glue, then 3398| | * this is the best answer and the search should 3399| | * stop now. 3400| | */ 3401| 0| result = DNS_R_PARTIALMATCH; 3402| 0| } else { 3403| 0| dns_name_t *zcname = NULL; 3404| | 3405| | /* 3406| | * The search will continue beneath the zone cut. 3407| | * This may or may not be the best match. In case it 3408| | * is, we need to remember the node name. 3409| | */ 3410| 0| zcname = dns_fixedname_name(&search->zonecut_name); 3411| 0| dns_name_copy(&node->name, zcname); 3412| 0| search->copy_name = true; 3413| 0| } 3414| 77| } else { 3415| | /* 3416| | * There is no zonecut at this node which is active in this 3417| | * version. 3418| | * 3419| | * If this is a "wild" node and the caller hasn't disabled 3420| | * wildcard matching, remember that we've seen a wild node 3421| | * in case we need to go searching for wildcard matches 3422| | * later on. 3423| | */ 3424| 77| if (node->wild && (search->options & DNS_DBFIND_NOWILD) == 0) { ------------------ | Branch (3424:7): [True: 0, False: 77] | Branch (3424:21): [True: 0, False: 0] ------------------ 3425| 0| search->wild = true; 3426| 0| } 3427| 77| } 3428| | 3429| 77| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 77| { \ | | 38| 77| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 77| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 77| { \ | | | | 39| 77| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 77| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 77| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 77| { \ | | | | | | 283| 77| switch (type) { \ | | | | | | 284| 77| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 77, False: 0] | | | | | | ------------------ | | | | | | 285| 77| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 77| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 77] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 77] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 77| } \ | | | | | | 293| 77| } | | | | ------------------ | | | | 42| 77| } | | ------------------ | | 40| 77| *tp = isc_rwlocktype_none; \ | | 41| 77| } ------------------ 3430| | 3431| 77| return result; 3432| 77|} qpzone.c:step: 2811| 77| qpznode_t **node_p) { 2812| 77| REQUIRE(node_p != NULL && *node_p == NULL); ------------------ | | 194| 77|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 154| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 77, False: 0] | | | | | Branch (42:11): [True: 77, False: 0] | | | | ------------------ | | | | 43| 77| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2813| | 2814| 77| qpznode_t *node = NULL, *previous_node = NULL; 2815| 77| isc_result_t result = ISC_R_SUCCESS; 2816| | 2817| 77| result = dns_qpiter_current(it, (void **)&node, NULL); 2818| 231| while (result == ISC_R_SUCCESS) { ------------------ | Branch (2818:9): [True: 154, False: 77] ------------------ 2819| 154| previous_node = node; 2820| | 2821| 154| isc_rwlock_t *nlock = qpzone_get_lock(node); 2822| 154| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 2823| 154| dns_vecheader_t *found = NULL; 2824| | 2825| 154| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 154|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 154| { \ | | | | 32| 154| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 154| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 154| { \ | | | | | | 31| 154| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 154| (t), __FILE__, __LINE__)); \ | | | | | | 33| 154| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 154| { \ | | | | | | | | 253| 154| switch (type) { \ | | | | | | | | 254| 154| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 154, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 154| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 154| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 154] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 154] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 154| } \ | | | | | | | | 263| 154| } | | | | | | ------------------ | | | | | | 34| 154| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 154| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 154| } | | | | ------------------ | | | | 34| 154| *tp = t; \ | | | | 35| 154| } | | ------------------ ------------------ 2826| 154| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 154| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 154| for (typeof(first) elt = first, \ | | | | 64| 154| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 0|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 0, False: 154] | | | | ------------------ | | | | 65| 154| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 0, False: 154] | | | | ------------------ | | | | 66| 154| elt = elt##_next, \ | | | | 67| 0| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 0|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2827| 0| found = first_existing_header(top, search->serial); 2828| 0| } 2829| 154| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 154| { \ | | 38| 154| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 154| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 154| { \ | | | | 39| 154| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 154| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 154| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 154| { \ | | | | | | 283| 154| switch (type) { \ | | | | | | 284| 154| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 154, False: 0] | | | | | | ------------------ | | | | | | 285| 154| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 154| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 154] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 154] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 154| } \ | | | | | | 293| 154| } | | | | ------------------ | | | | 42| 154| } | | ------------------ | | 40| 154| *tp = isc_rwlocktype_none; \ | | 41| 154| } ------------------ 2830| 154| if (found != NULL) { ------------------ | Branch (2830:7): [True: 0, False: 154] ------------------ 2831| 0| break; 2832| 0| } 2833| | 2834| 154| if (direction == FORWARD) { ------------------ | Branch (2834:7): [True: 154, False: 0] ------------------ 2835| 154| result = dns_qpiter_next(it, (void **)&node, NULL); 2836| 154| } else { 2837| 0| result = dns_qpiter_prev(it, (void **)&node, NULL); 2838| 0| } 2839| 154| }; 2840| | 2841| 77| if (result == ISC_R_SUCCESS) { ------------------ | Branch (2841:6): [True: 0, False: 77] ------------------ 2842| 0| if (previous_node != NULL) { ------------------ | Branch (2842:7): [True: 0, False: 0] ------------------ 2843| 0| *node_p = previous_node; 2844| 0| } 2845| 0| return true; 2846| 0| } 2847| | 2848| 77| return false; 2849| 77|} qpzone.c:activeempty: 2852| 77|activeempty(qpz_search_t *search, dns_qpiter_t *it, const dns_name_t *current) { 2853| 77| qpznode_t *next_node = NULL; 2854| | 2855| | /* 2856| | * The iterator is currently pointed at the predecessor 2857| | * of the name we were searching for. Step the iterator 2858| | * forward, then step() will continue forward until it 2859| | * finds a node with active data. If that node is a 2860| | * subdomain of the one we were looking for, then we're 2861| | * at an active empty nonterminal node. 2862| | */ 2863| 77| isc_result_t result = dns_qpiter_next(it, NULL, NULL); 2864| 77| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2864:6): [True: 0, False: 77] ------------------ 2865| | /* An ENT at the end of the zone is impossible */ 2866| 0| return false; 2867| 0| } 2868| 77| return step(search, it, FORWARD, &next_node) && ------------------ | Branch (2868:9): [True: 0, False: 77] ------------------ 2869| 0| dns_name_issubdomain(&next_node->name, current); ------------------ | Branch (2869:9): [True: 0, False: 0] ------------------ 2870| 77|} qpzone.c:setgluecachestats: 2571| 2|setgluecachestats(dns_db_t *db, isc_stats_t *stats) { 2572| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2573| | 2574| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2575| 2| REQUIRE(!IS_STUB(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2576| 2| REQUIRE(stats != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2577| | 2578| 2| isc_stats_attach(stats, &qpdb->gluecachestats); 2579| 2| return ISC_R_SUCCESS; 2580| 2|} qpzone.c:setmaxrrperset: 5482| 2|setmaxrrperset(dns_db_t *db, uint32_t value) { 5483| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 5484| | 5485| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5486| | 5487| 2| qpdb->maxrrperset = value; 5488| 2|} qpzone.c:setmaxtypepername: 5491| 2|setmaxtypepername(dns_db_t *db, uint32_t value) { 5492| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 5493| | 5494| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5495| | 5496| 2| qpdb->maxtypepername = value; 5497| 2|} dns_secalg_fromtext: 357| 2|dns_secalg_fromtext(dns_secalg_t *secalgp, isc_textregion_t *source) { 358| 2| unsigned int value; 359| 2| RETERR(dns_mnemonic_fromtext(&value, source, secalgs, 0xff)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 360| 2| *secalgp = value; 361| 2| return ISC_R_SUCCESS; 362| 2|} dns_secproto_fromtext: 444| 2|dns_secproto_fromtext(dns_secproto_t *secprotop, isc_textregion_t *source) { 445| 2| unsigned int value; 446| 2| RETERR(dns_mnemonic_fromtext(&value, source, secprotos, 0xff)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 447| 2| *secprotop = value; 448| 2| return ISC_R_SUCCESS; 449| 2|} dns_keyflags_fromtext: 465| 2|dns_keyflags_fromtext(dns_keyflags_t *flagsp, isc_textregion_t *source) { 466| 2| isc_result_t result; 467| 2| char *text, *end; 468| 2| unsigned int value = 0; 469| |#ifdef notyet 470| | unsigned int mask = 0; 471| |#endif /* ifdef notyet */ 472| | 473| 2| result = maybe_numeric(&value, source, 0xffff, true); 474| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (474:6): [True: 2, False: 0] ------------------ 475| 2| *flagsp = value; 476| 2| return ISC_R_SUCCESS; 477| 2| } 478| 0| if (result != ISC_R_BADNUMBER) { ------------------ | Branch (478:6): [True: 0, False: 0] ------------------ 479| 0| return result; 480| 0| } 481| | 482| 0| text = source->base; 483| 0| end = source->base + source->length; 484| | 485| 0| while (text < end) { ------------------ | Branch (485:9): [True: 0, False: 0] ------------------ 486| 0| struct keyflag *p; 487| 0| unsigned int len; 488| 0| char *delim = memchr(text, '|', end - text); 489| 0| if (delim != NULL) { ------------------ | Branch (489:7): [True: 0, False: 0] ------------------ 490| 0| len = (unsigned int)(delim - text); 491| 0| } else { 492| 0| len = (unsigned int)(end - text); 493| 0| } 494| 0| for (p = keyflags; p->name != NULL; p++) { ------------------ | Branch (494:22): [True: 0, False: 0] ------------------ 495| 0| if (strncasecmp(p->name, text, len) == 0) { ------------------ | Branch (495:8): [True: 0, False: 0] ------------------ 496| 0| break; 497| 0| } 498| 0| } 499| 0| if (p->name == NULL) { ------------------ | Branch (499:7): [True: 0, False: 0] ------------------ 500| 0| return DNS_R_UNKNOWNFLAG; 501| 0| } 502| 0| value |= p->value; 503| |#ifdef notyet 504| | if ((mask & p->mask) != 0) { 505| | warn("overlapping key flags"); 506| | } 507| | mask |= p->mask; 508| |#endif /* ifdef notyet */ 509| 0| text += len; 510| 0| if (delim != NULL) { ------------------ | Branch (510:7): [True: 0, False: 0] ------------------ 511| 0| text++; /* Skip "|" */ 512| 0| } 513| 0| } 514| 0| *flagsp = value; 515| 0| return ISC_R_SUCCESS; 516| 0|} dns_rdataclass_fromtext: 587| 12|dns_rdataclass_fromtext(dns_rdataclass_t *classp, isc_textregion_t *source) { 588| 12|#define COMPARE(string, rdclass) \ 589| 12| if (((sizeof(string) - 1) == source->length) && \ 590| 12| (strncasecmp(source->base, string, source->length) == 0)) \ 591| 12| { \ 592| 12| *classp = rdclass; \ 593| 12| return (ISC_R_SUCCESS); \ 594| 12| } 595| | 596| 12| switch (isc_ascii_tolower(source->base[0])) { ------------------ | | 31| 12|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] | | ------------------ | | | Branch (31:30): [True: 6, False: 6] | | ------------------ ------------------ 597| 0| case 'a': ------------------ | Branch (597:2): [True: 0, False: 12] ------------------ 598| 0| COMPARE("any", dns_rdataclass_any); ------------------ | | 589| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 0, False: 0] | | ------------------ | | 590| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 0, False: 0] | | ------------------ | | 591| 0| { \ | | 592| 0| *classp = rdclass; \ | | 593| 0| return (ISC_R_SUCCESS); \ | | 594| 0| } ------------------ 599| 0| break; 600| 0| case 'c': ------------------ | Branch (600:2): [True: 0, False: 12] ------------------ 601| | /* 602| | * RFC1035 says the mnemonic for the CHAOS class is CH, 603| | * but historical BIND practice is to call it CHAOS. 604| | * We will accept both forms, but only generate CH. 605| | */ 606| 0| COMPARE("ch", dns_rdataclass_chaos); ------------------ | | 589| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 0, False: 0] | | ------------------ | | 590| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 0, False: 0] | | ------------------ | | 591| 0| { \ | | 592| 0| *classp = rdclass; \ | | 593| 0| return (ISC_R_SUCCESS); \ | | 594| 0| } ------------------ 607| 0| COMPARE("chaos", dns_rdataclass_chaos); ------------------ | | 589| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 0, False: 0] | | ------------------ | | 590| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 0, False: 0] | | ------------------ | | 591| 0| { \ | | 592| 0| *classp = rdclass; \ | | 593| 0| return (ISC_R_SUCCESS); \ | | 594| 0| } ------------------ 608| | 609| 0| if (source->length > 5 && ------------------ | Branch (609:7): [True: 0, False: 0] ------------------ 610| 0| source->length < (5 + sizeof("65000")) && ------------------ | Branch (610:7): [True: 0, False: 0] ------------------ 611| 0| strncasecmp("class", source->base, 5) == 0) ------------------ | Branch (611:7): [True: 0, False: 0] ------------------ 612| 0| { 613| 0| char buf[sizeof("65000")]; 614| 0| char *endp; 615| 0| unsigned int val; 616| | 617| | /* 618| | * source->base is not required to be NUL terminated. 619| | * Copy up to remaining bytes and NUL terminate. 620| | */ 621| 0| snprintf(buf, sizeof(buf), "%.*s", 622| 0| (int)(source->length - 5), source->base + 5); 623| 0| val = strtoul(buf, &endp, 10); 624| 0| if (*endp == '\0' && val <= 0xffff) { ------------------ | Branch (624:8): [True: 0, False: 0] | Branch (624:25): [True: 0, False: 0] ------------------ 625| 0| *classp = (dns_rdataclass_t)val; 626| 0| return ISC_R_SUCCESS; 627| 0| } 628| 0| } 629| 0| break; 630| 0| case 'h': ------------------ | Branch (630:2): [True: 0, False: 12] ------------------ 631| 0| COMPARE("hs", dns_rdataclass_hs); ------------------ | | 589| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 0, False: 0] | | ------------------ | | 590| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 0, False: 0] | | ------------------ | | 591| 0| { \ | | 592| 0| *classp = rdclass; \ | | 593| 0| return (ISC_R_SUCCESS); \ | | 594| 0| } ------------------ 632| 0| COMPARE("hesiod", dns_rdataclass_hs); ------------------ | | 589| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 0, False: 0] | | ------------------ | | 590| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 0, False: 0] | | ------------------ | | 591| 0| { \ | | 592| 0| *classp = rdclass; \ | | 593| 0| return (ISC_R_SUCCESS); \ | | 594| 0| } ------------------ 633| 0| break; 634| 6| case 'i': ------------------ | Branch (634:2): [True: 6, False: 6] ------------------ 635| 6| COMPARE("in", dns_rdataclass_in); ------------------ | | 589| 6| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 6, False: 0] | | ------------------ | | 590| 6| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 6, False: 0] | | ------------------ | | 591| 6| { \ | | 592| 6| *classp = rdclass; \ | | 593| 6| return (ISC_R_SUCCESS); \ | | 594| 6| } ------------------ 636| 0| break; 637| 0| case 'n': ------------------ | Branch (637:2): [True: 0, False: 12] ------------------ 638| 0| COMPARE("none", dns_rdataclass_none); ------------------ | | 589| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 0, False: 0] | | ------------------ | | 590| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 0, False: 0] | | ------------------ | | 591| 0| { \ | | 592| 0| *classp = rdclass; \ | | 593| 0| return (ISC_R_SUCCESS); \ | | 594| 0| } ------------------ 639| 0| break; 640| 0| case 'r': ------------------ | Branch (640:2): [True: 0, False: 12] ------------------ 641| 0| COMPARE("reserved0", dns_rdataclass_reserved0); ------------------ | | 589| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (589:6): [True: 0, False: 0] | | ------------------ | | 590| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (590:6): [True: 0, False: 0] | | ------------------ | | 591| 0| { \ | | 592| 0| *classp = rdclass; \ | | 593| 0| return (ISC_R_SUCCESS); \ | | 594| 0| } ------------------ 642| 0| break; 643| 12| } 644| | 645| 6|#undef COMPARE 646| | 647| 6| return DNS_R_UNKNOWN; 648| 12|} dns_rdataclass_totext: 651| 10|dns_rdataclass_totext(dns_rdataclass_t rdclass, isc_buffer_t *target) { 652| 10| switch (rdclass) { 653| 0| case dns_rdataclass_any: ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (653:2): [True: 0, False: 10] ------------------ 654| 0| return str_totext("ANY", target); 655| 0| case dns_rdataclass_chaos: ------------------ | | 26| 0|#define dns_rdataclass_chaos ((dns_rdataclass_t)dns_rdataclass_chaos) ------------------ | Branch (655:2): [True: 0, False: 10] ------------------ 656| 0| return str_totext("CH", target); 657| 0| case dns_rdataclass_hs: ------------------ | | 30| 0|#define dns_rdataclass_hs ((dns_rdataclass_t)dns_rdataclass_hs) ------------------ | Branch (657:2): [True: 0, False: 10] ------------------ 658| 0| return str_totext("HS", target); 659| 8| case dns_rdataclass_in: ------------------ | | 24| 8|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (659:2): [True: 8, False: 2] ------------------ 660| 8| return str_totext("IN", target); 661| 2| case dns_rdataclass_none: ------------------ | | 32| 2|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (661:2): [True: 2, False: 8] ------------------ 662| 2| return str_totext("NONE", target); 663| 0| case dns_rdataclass_reserved0: ------------------ | | 22| 0| ((dns_rdataclass_t)dns_rdataclass_reserved0) ------------------ | Branch (663:2): [True: 0, False: 10] ------------------ 664| 0| return str_totext("RESERVED0", target); 665| 0| default: ------------------ | Branch (665:2): [True: 0, False: 10] ------------------ 666| 0| return dns_rdataclass_tounknowntext(rdclass, target); 667| 10| } 668| 10|} rcode.c:dns_mnemonic_fromtext: 280| 4| struct tbl *table, unsigned int max) { 281| 4| isc_result_t result; 282| 4| int i; 283| | 284| 4| result = maybe_numeric(valuep, source, max, false); 285| 4| if (result != ISC_R_BADNUMBER) { ------------------ | Branch (285:6): [True: 4, False: 0] ------------------ 286| 4| return result; 287| 4| } 288| | 289| 0| for (i = 0; table[i].name != NULL; i++) { ------------------ | Branch (289:14): [True: 0, False: 0] ------------------ 290| 0| unsigned int n; 291| 0| n = strlen(table[i].name); 292| 0| if (n == source->length && (table[i].flags & TOTEXTONLY) == 0 && ------------------ | | 44| 0|#define TOTEXTONLY 0x01 ------------------ | Branch (292:7): [True: 0, False: 0] | Branch (292:30): [True: 0, False: 0] ------------------ 293| 0| strncasecmp(source->base, table[i].name, n) == 0) ------------------ | Branch (293:7): [True: 0, False: 0] ------------------ 294| 0| { 295| 0| *valuep = table[i].value; 296| 0| return ISC_R_SUCCESS; 297| 0| } 298| 0| } 299| 0| return DNS_R_UNKNOWN; 300| 0|} rcode.c:maybe_numeric: 240| 6| bool hex_allowed) { 241| 6| isc_result_t result; 242| 6| uint32_t n; 243| 6| char buffer[NUMBERSIZE]; 244| 6| int v; 245| | 246| 6| if (!isdigit((unsigned char)source->base[0]) || ------------------ | Branch (246:6): [True: 0, False: 6] ------------------ 247| 6| source->length > NUMBERSIZE - 1) ------------------ | | 42| 6|#define NUMBERSIZE sizeof("037777777777") /* 2^32-1 octal + NUL */ ------------------ | Branch (247:6): [True: 0, False: 6] ------------------ 248| 0| { 249| 0| return ISC_R_BADNUMBER; 250| 0| } 251| | 252| | /* 253| | * We have a potential number. Try to parse it with 254| | * isc_parse_uint32(). isc_parse_uint32() requires 255| | * null termination, so we must make a copy. 256| | */ 257| 6| v = snprintf(buffer, sizeof(buffer), "%.*s", (int)source->length, 258| 6| source->base); 259| 6| if (v < 0 || (unsigned int)v != source->length) { ------------------ | Branch (259:6): [True: 0, False: 6] | Branch (259:15): [True: 0, False: 6] ------------------ 260| 0| return ISC_R_BADNUMBER; 261| 0| } 262| 6| INSIST(buffer[source->length] == '\0'); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 263| | 264| 6| result = isc_parse_uint32(&n, buffer, 10); 265| 6| if (result == ISC_R_BADNUMBER && hex_allowed) { ------------------ | Branch (265:6): [True: 0, False: 6] | Branch (265:35): [True: 0, False: 0] ------------------ 266| 0| result = isc_parse_uint32(&n, buffer, 16); 267| 0| } 268| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (268:6): [True: 0, False: 6] ------------------ 269| 0| return result; 270| 0| } 271| 6| if (n > max) { ------------------ | Branch (271:6): [True: 0, False: 6] ------------------ 272| 0| return ISC_R_RANGE; 273| 0| } 274| 6| *valuep = n; 275| 6| return ISC_R_SUCCESS; 276| 6|} rcode.c:str_totext: 222| 10|str_totext(const char *source, isc_buffer_t *target) { 223| 10| unsigned int l; 224| 10| isc_region_t region; 225| | 226| 10| isc_buffer_availableregion(target, ®ion); 227| 10| l = strlen(source); 228| | 229| 10| if (l > region.length) { ------------------ | Branch (229:6): [True: 0, False: 10] ------------------ 230| 0| return ISC_R_NOSPACE; 231| 0| } 232| | 233| 10| memmove(region.base, source, l); 234| 10| isc_buffer_add(target, l); 235| 10| return ISC_R_SUCCESS; 236| 10|} dns_rdata_init: 800| 1.80k|dns_rdata_init(dns_rdata_t *rdata) { 801| 1.80k| REQUIRE(rdata != NULL); ------------------ | | 194| 1.80k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.80k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.80k, False: 0] | | | | ------------------ | | | | 43| 1.80k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 802| | 803| 1.80k| rdata->data = NULL; 804| 1.80k| rdata->length = 0; 805| 1.80k| rdata->rdclass = 0; 806| 1.80k| rdata->type = dns_rdatatype_none; ------------------ | | 114| 1.80k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 807| 1.80k| rdata->flags = 0; 808| 1.80k| ISC_LINK_INIT(rdata, link); ------------------ | | 57| 1.80k|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 1.80k| do { \ | | | | 54| 1.80k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 1.80k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 1.80k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 1.80k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 1.80k| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 1.80k] | | | | ------------------ | | ------------------ ------------------ 809| | /* ISC_LIST_INIT(rdata->list); */ 810| 1.80k|} dns_rdata_reset: 813| 572|dns_rdata_reset(dns_rdata_t *rdata) { 814| 572| REQUIRE(rdata != NULL); ------------------ | | 194| 572|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 572| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 572, False: 0] | | | | ------------------ | | | | 43| 572| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 815| | 816| 572| REQUIRE(!ISC_LINK_LINKED(rdata, link)); ------------------ | | 194| 572|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 572| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 572, False: 0] | | | | ------------------ | | | | 43| 572| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 817| 572| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 194| 572|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 572| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 572, False: 0] | | | | ------------------ | | | | 43| 572| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 818| | 819| 572| rdata->data = NULL; 820| 572| rdata->length = 0; 821| 572| rdata->rdclass = 0; 822| 572| rdata->type = dns_rdatatype_none; ------------------ | | 114| 572|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 823| 572| rdata->flags = 0; 824| 572|} dns_rdata_clone: 831| 1.28k|dns_rdata_clone(const dns_rdata_t *src, dns_rdata_t *target) { 832| 1.28k| REQUIRE(src != NULL); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.28k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 833| 1.28k| REQUIRE(target != NULL); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.28k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 834| | 835| 1.28k| REQUIRE(DNS_RDATA_INITIALIZED(target)); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12.8k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | | Branch (42:11): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 836| | 837| 1.28k| REQUIRE(DNS_RDATA_VALIDFLAGS(src)); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.28k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 838| 1.28k| REQUIRE(DNS_RDATA_VALIDFLAGS(target)); ------------------ | | 194| 1.28k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.28k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.28k, False: 0] | | | | ------------------ | | | | 43| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 839| | 840| 1.28k| target->data = src->data; 841| 1.28k| target->length = src->length; 842| 1.28k| target->rdclass = src->rdclass; 843| 1.28k| target->type = src->type; 844| 1.28k| target->flags = src->flags; 845| 1.28k|} dns_rdata_fromregion: 923| 1.47k| dns_rdatatype_t type, isc_region_t *r) { 924| 1.47k| REQUIRE(rdata != NULL); ------------------ | | 194| 1.47k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.47k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.47k, False: 0] | | | | ------------------ | | | | 43| 1.47k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 925| 1.47k| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 194| 1.47k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.47k, False: 0] | | | | | Branch (42:11): [True: 1.47k, False: 0] | | | | | Branch (42:11): [True: 1.47k, False: 0] | | | | | Branch (42:11): [True: 1.47k, False: 0] | | | | | Branch (42:11): [True: 1.47k, False: 0] | | | | | Branch (42:11): [True: 1.47k, False: 0] | | | | ------------------ | | | | 43| 1.47k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 926| 1.47k| REQUIRE(r != NULL); ------------------ | | 194| 1.47k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.47k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.47k, False: 0] | | | | ------------------ | | | | 43| 1.47k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 927| | 928| 1.47k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 194| 1.47k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.47k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.47k, False: 0] | | | | ------------------ | | | | 43| 1.47k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 929| | 930| 1.47k| rdata->data = r->base; 931| 1.47k| rdata->length = r->length; 932| 1.47k| rdata->rdclass = rdclass; 933| 1.47k| rdata->type = type; 934| 1.47k| rdata->flags = 0; 935| 1.47k|} dns_rdata_toregion: 938| 2.19k|dns_rdata_toregion(const dns_rdata_t *rdata, isc_region_t *r) { 939| 2.19k| REQUIRE(rdata != NULL); ------------------ | | 194| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.19k, False: 0] | | | | ------------------ | | | | 43| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 940| 2.19k| REQUIRE(r != NULL); ------------------ | | 194| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.19k, False: 0] | | | | ------------------ | | | | 43| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 941| 2.19k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 194| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.19k, False: 0] | | | | ------------------ | | | | 43| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 942| | 943| 2.19k| r->base = rdata->data; 944| 2.19k| r->length = rdata->length; 945| 2.19k|} dns_rdata_fromwire: 950| 1.94k| dns_decompress_t dctx, isc_buffer_t *target) { 951| 1.94k| isc_result_t result = ISC_R_NOTIMPLEMENTED; 952| 1.94k| isc_region_t region; 953| 1.94k| isc_buffer_t ss; 954| 1.94k| isc_buffer_t st; 955| 1.94k| bool use_default = false; 956| 1.94k| uint32_t activelength; 957| 1.94k| unsigned int length; 958| | 959| 1.94k| if (rdata != NULL) { ------------------ | Branch (959:6): [True: 1.94k, False: 0] ------------------ 960| 1.94k| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 194| 1.94k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 19.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.94k, False: 0] | | | | | Branch (42:11): [True: 1.94k, False: 0] | | | | | Branch (42:11): [True: 1.94k, False: 0] | | | | | Branch (42:11): [True: 1.94k, False: 0] | | | | | Branch (42:11): [True: 1.94k, False: 0] | | | | | Branch (42:11): [True: 1.94k, False: 0] | | | | ------------------ | | | | 43| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 961| 1.94k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 194| 1.94k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.94k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.94k, False: 0] | | | | ------------------ | | | | 43| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 962| 1.94k| } 963| 1.94k| REQUIRE(source != NULL); ------------------ | | 194| 1.94k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.94k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.94k, False: 0] | | | | ------------------ | | | | 43| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 964| 1.94k| REQUIRE(target != NULL); ------------------ | | 194| 1.94k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.94k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.94k, False: 0] | | | | ------------------ | | | | 43| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 965| | 966| 1.94k| if (type == dns_rdatatype_none) { ------------------ | | 114| 1.94k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (966:6): [True: 0, False: 1.94k] ------------------ 967| 0| return DNS_R_FORMERR; 968| 0| } 969| | 970| 1.94k| ss = *source; 971| 1.94k| st = *target; 972| | 973| 1.94k| activelength = isc_buffer_activelength(source); ------------------ | | 160| 1.94k|#define isc_buffer_activelength(b) ((b)->active - (b)->current) /* c-b */ ------------------ 974| 1.94k| INSIST(activelength < 65536); ------------------ | | 198| 1.94k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.94k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.94k, False: 0] | | | | ------------------ | | | | 55| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 975| | 976| 1.94k| FROMWIRESWITCH ------------------ | | 438| 1.94k| switch (type) { \ | | 439| 0| case 1: switch (rdclass) { \ | | ------------------ | | | Branch (439:2): [True: 0, False: 1.94k] | | ------------------ | | 440| 0| case 1: result = fromwire_in_a(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (440:3): [True: 0, False: 0] | | ------------------ | | 441| 0| case 3: result = fromwire_ch_a(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (441:3): [True: 0, False: 0] | | ------------------ | | 442| 0| case 4: result = fromwire_hs_a(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (442:3): [True: 0, False: 0] | | ------------------ | | 443| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (443:3): [True: 0, False: 0] | | ------------------ | | 444| 0| } \ | | 445| 0| break; \ | | 446| 0| case 2: result = fromwire_ns(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (446:2): [True: 0, False: 1.94k] | | ------------------ | | 447| 0| case 3: result = fromwire_md(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (447:2): [True: 0, False: 1.94k] | | ------------------ | | 448| 0| case 4: result = fromwire_mf(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (448:2): [True: 0, False: 1.94k] | | ------------------ | | 449| 0| case 5: result = fromwire_cname(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (449:2): [True: 0, False: 1.94k] | | ------------------ | | 450| 0| case 6: result = fromwire_soa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (450:2): [True: 0, False: 1.94k] | | ------------------ | | 451| 0| case 7: result = fromwire_mb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (451:2): [True: 0, False: 1.94k] | | ------------------ | | 452| 0| case 8: result = fromwire_mg(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (452:2): [True: 0, False: 1.94k] | | ------------------ | | 453| 0| case 9: result = fromwire_mr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (453:2): [True: 0, False: 1.94k] | | ------------------ | | 454| 0| case 10: result = fromwire_null(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (454:2): [True: 0, False: 1.94k] | | ------------------ | | 455| 0| case 11: switch (rdclass) { \ | | ------------------ | | | Branch (455:2): [True: 0, False: 1.94k] | | ------------------ | | 456| 0| case 1: result = fromwire_in_wks(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (456:3): [True: 0, False: 0] | | ------------------ | | 457| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (457:3): [True: 0, False: 0] | | ------------------ | | 458| 0| } \ | | 459| 0| break; \ | | 460| 0| case 12: result = fromwire_ptr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (460:2): [True: 0, False: 1.94k] | | ------------------ | | 461| 0| case 13: result = fromwire_hinfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (461:2): [True: 0, False: 1.94k] | | ------------------ | | 462| 0| case 14: result = fromwire_minfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (462:2): [True: 0, False: 1.94k] | | ------------------ | | 463| 0| case 15: result = fromwire_mx(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (463:2): [True: 0, False: 1.94k] | | ------------------ | | 464| 0| case 16: result = fromwire_txt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (464:2): [True: 0, False: 1.94k] | | ------------------ | | 465| 0| case 17: result = fromwire_rp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (465:2): [True: 0, False: 1.94k] | | ------------------ | | 466| 0| case 18: result = fromwire_afsdb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (466:2): [True: 0, False: 1.94k] | | ------------------ | | 467| 0| case 19: result = fromwire_x25(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (467:2): [True: 0, False: 1.94k] | | ------------------ | | 468| 0| case 20: result = fromwire_isdn(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (468:2): [True: 0, False: 1.94k] | | ------------------ | | 469| 0| case 21: result = fromwire_rt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (469:2): [True: 0, False: 1.94k] | | ------------------ | | 470| 0| case 22: switch (rdclass) { \ | | ------------------ | | | Branch (470:2): [True: 0, False: 1.94k] | | ------------------ | | 471| 0| case 1: result = fromwire_in_nsap(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (471:3): [True: 0, False: 0] | | ------------------ | | 472| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (472:3): [True: 0, False: 0] | | ------------------ | | 473| 0| } \ | | 474| 0| break; \ | | 475| 0| case 23: switch (rdclass) { \ | | ------------------ | | | Branch (475:2): [True: 0, False: 1.94k] | | ------------------ | | 476| 0| case 1: result = fromwire_in_nsap_ptr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (476:3): [True: 0, False: 0] | | ------------------ | | 477| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (477:3): [True: 0, False: 0] | | ------------------ | | 478| 0| } \ | | 479| 0| break; \ | | 480| 824| case 24: result = fromwire_sig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (480:2): [True: 824, False: 1.12k] | | ------------------ | | 481| 0| case 25: result = fromwire_key(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (481:2): [True: 0, False: 1.94k] | | ------------------ | | 482| 0| case 26: switch (rdclass) { \ | | ------------------ | | | Branch (482:2): [True: 0, False: 1.94k] | | ------------------ | | 483| 0| case 1: result = fromwire_in_px(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (483:3): [True: 0, False: 0] | | ------------------ | | 484| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (484:3): [True: 0, False: 0] | | ------------------ | | 485| 0| } \ | | 486| 0| break; \ | | 487| 0| case 27: result = fromwire_gpos(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (487:2): [True: 0, False: 1.94k] | | ------------------ | | 488| 0| case 28: switch (rdclass) { \ | | ------------------ | | | Branch (488:2): [True: 0, False: 1.94k] | | ------------------ | | 489| 0| case 1: result = fromwire_in_aaaa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (489:3): [True: 0, False: 0] | | ------------------ | | 490| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (490:3): [True: 0, False: 0] | | ------------------ | | 491| 0| } \ | | 492| 0| break; \ | | 493| 0| case 29: result = fromwire_loc(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (493:2): [True: 0, False: 1.94k] | | ------------------ | | 494| 0| case 30: result = fromwire_nxt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (494:2): [True: 0, False: 1.94k] | | ------------------ | | 495| 0| case 31: switch (rdclass) { \ | | ------------------ | | | Branch (495:2): [True: 0, False: 1.94k] | | ------------------ | | 496| 0| case 1: result = fromwire_in_eid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (496:3): [True: 0, False: 0] | | ------------------ | | 497| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (497:3): [True: 0, False: 0] | | ------------------ | | 498| 0| } \ | | 499| 0| break; \ | | 500| 0| case 32: switch (rdclass) { \ | | ------------------ | | | Branch (500:2): [True: 0, False: 1.94k] | | ------------------ | | 501| 0| case 1: result = fromwire_in_nimloc(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (501:3): [True: 0, False: 0] | | ------------------ | | 502| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (502:3): [True: 0, False: 0] | | ------------------ | | 503| 0| } \ | | 504| 0| break; \ | | 505| 0| case 33: switch (rdclass) { \ | | ------------------ | | | Branch (505:2): [True: 0, False: 1.94k] | | ------------------ | | 506| 0| case 1: result = fromwire_in_srv(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (506:3): [True: 0, False: 0] | | ------------------ | | 507| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (507:3): [True: 0, False: 0] | | ------------------ | | 508| 0| } \ | | 509| 0| break; \ | | 510| 0| case 34: switch (rdclass) { \ | | ------------------ | | | Branch (510:2): [True: 0, False: 1.94k] | | ------------------ | | 511| 0| case 1: result = fromwire_in_atma(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (511:3): [True: 0, False: 0] | | ------------------ | | 512| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (512:3): [True: 0, False: 0] | | ------------------ | | 513| 0| } \ | | 514| 0| break; \ | | 515| 0| case 35: result = fromwire_naptr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (515:2): [True: 0, False: 1.94k] | | ------------------ | | 516| 0| case 36: switch (rdclass) { \ | | ------------------ | | | Branch (516:2): [True: 0, False: 1.94k] | | ------------------ | | 517| 0| case 1: result = fromwire_in_kx(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (517:3): [True: 0, False: 0] | | ------------------ | | 518| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (518:3): [True: 0, False: 0] | | ------------------ | | 519| 0| } \ | | 520| 0| break; \ | | 521| 0| case 37: result = fromwire_cert(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (521:2): [True: 0, False: 1.94k] | | ------------------ | | 522| 0| case 38: switch (rdclass) { \ | | ------------------ | | | Branch (522:2): [True: 0, False: 1.94k] | | ------------------ | | 523| 0| case 1: result = fromwire_in_a6(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (523:3): [True: 0, False: 0] | | ------------------ | | 524| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (524:3): [True: 0, False: 0] | | ------------------ | | 525| 0| } \ | | 526| 0| break; \ | | 527| 0| case 39: result = fromwire_dname(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (527:2): [True: 0, False: 1.94k] | | ------------------ | | 528| 0| case 40: result = fromwire_sink(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (528:2): [True: 0, False: 1.94k] | | ------------------ | | 529| 0| case 41: result = fromwire_opt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (529:2): [True: 0, False: 1.94k] | | ------------------ | | 530| 0| case 42: switch (rdclass) { \ | | ------------------ | | | Branch (530:2): [True: 0, False: 1.94k] | | ------------------ | | 531| 0| case 1: result = fromwire_in_apl(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (531:3): [True: 0, False: 0] | | ------------------ | | 532| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (532:3): [True: 0, False: 0] | | ------------------ | | 533| 0| } \ | | 534| 0| break; \ | | 535| 0| case 43: result = fromwire_ds(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (535:2): [True: 0, False: 1.94k] | | ------------------ | | 536| 0| case 44: result = fromwire_sshfp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (536:2): [True: 0, False: 1.94k] | | ------------------ | | 537| 0| case 45: result = fromwire_ipseckey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (537:2): [True: 0, False: 1.94k] | | ------------------ | | 538| 0| case 46: result = fromwire_rrsig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (538:2): [True: 0, False: 1.94k] | | ------------------ | | 539| 0| case 47: result = fromwire_nsec(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (539:2): [True: 0, False: 1.94k] | | ------------------ | | 540| 0| case 48: result = fromwire_dnskey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (540:2): [True: 0, False: 1.94k] | | ------------------ | | 541| 0| case 49: switch (rdclass) { \ | | ------------------ | | | Branch (541:2): [True: 0, False: 1.94k] | | ------------------ | | 542| 0| case 1: result = fromwire_in_dhcid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (542:3): [True: 0, False: 0] | | ------------------ | | 543| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (543:3): [True: 0, False: 0] | | ------------------ | | 544| 0| } \ | | 545| 0| break; \ | | 546| 0| case 50: result = fromwire_nsec3(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (546:2): [True: 0, False: 1.94k] | | ------------------ | | 547| 0| case 51: result = fromwire_nsec3param(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (547:2): [True: 0, False: 1.94k] | | ------------------ | | 548| 0| case 52: result = fromwire_tlsa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (548:2): [True: 0, False: 1.94k] | | ------------------ | | 549| 0| case 53: result = fromwire_smimea(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (549:2): [True: 0, False: 1.94k] | | ------------------ | | 550| 0| case 55: result = fromwire_hip(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (550:2): [True: 0, False: 1.94k] | | ------------------ | | 551| 0| case 56: result = fromwire_ninfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (551:2): [True: 0, False: 1.94k] | | ------------------ | | 552| 0| case 57: result = fromwire_rkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (552:2): [True: 0, False: 1.94k] | | ------------------ | | 553| 0| case 58: result = fromwire_talink(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (553:2): [True: 0, False: 1.94k] | | ------------------ | | 554| 0| case 59: result = fromwire_cds(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (554:2): [True: 0, False: 1.94k] | | ------------------ | | 555| 0| case 60: result = fromwire_cdnskey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (555:2): [True: 0, False: 1.94k] | | ------------------ | | 556| 0| case 61: result = fromwire_openpgpkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (556:2): [True: 0, False: 1.94k] | | ------------------ | | 557| 0| case 62: result = fromwire_csync(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (557:2): [True: 0, False: 1.94k] | | ------------------ | | 558| 0| case 63: result = fromwire_zonemd(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (558:2): [True: 0, False: 1.94k] | | ------------------ | | 559| 0| case 64: switch (rdclass) { \ | | ------------------ | | | Branch (559:2): [True: 0, False: 1.94k] | | ------------------ | | 560| 0| case 1: result = fromwire_in_svcb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (560:3): [True: 0, False: 0] | | ------------------ | | 561| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (561:3): [True: 0, False: 0] | | ------------------ | | 562| 0| } \ | | 563| 0| break; \ | | 564| 0| case 65: switch (rdclass) { \ | | ------------------ | | | Branch (564:2): [True: 0, False: 1.94k] | | ------------------ | | 565| 0| case 1: result = fromwire_in_https(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (565:3): [True: 0, False: 0] | | ------------------ | | 566| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (566:3): [True: 0, False: 0] | | ------------------ | | 567| 0| } \ | | 568| 0| break; \ | | 569| 0| case 66: result = fromwire_dsync(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (569:2): [True: 0, False: 1.94k] | | ------------------ | | 570| 0| case 67: result = fromwire_hhit(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (570:2): [True: 0, False: 1.94k] | | ------------------ | | 571| 0| case 68: result = fromwire_brid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (571:2): [True: 0, False: 1.94k] | | ------------------ | | 572| 0| case 99: result = fromwire_spf(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (572:2): [True: 0, False: 1.94k] | | ------------------ | | 573| 0| case 104: result = fromwire_nid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (573:2): [True: 0, False: 1.94k] | | ------------------ | | 574| 0| case 105: result = fromwire_l32(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (574:2): [True: 0, False: 1.94k] | | ------------------ | | 575| 0| case 106: result = fromwire_l64(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (575:2): [True: 0, False: 1.94k] | | ------------------ | | 576| 0| case 107: result = fromwire_lp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (576:2): [True: 0, False: 1.94k] | | ------------------ | | 577| 0| case 108: result = fromwire_eui48(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (577:2): [True: 0, False: 1.94k] | | ------------------ | | 578| 0| case 109: result = fromwire_eui64(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (578:2): [True: 0, False: 1.94k] | | ------------------ | | 579| 0| case 249: result = fromwire_tkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (579:2): [True: 0, False: 1.94k] | | ------------------ | | 580| 1.12k| case 250: switch (rdclass) { \ | | ------------------ | | | Branch (580:2): [True: 1.12k, False: 824] | | ------------------ | | 581| 1.12k| case 255: result = fromwire_any_tsig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (581:3): [True: 1.12k, False: 0] | | ------------------ | | 582| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (582:3): [True: 0, False: 1.12k] | | ------------------ | | 583| 1.12k| } \ | | 584| 1.12k| break; \ | | 585| 1.12k| case 256: result = fromwire_uri(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (585:2): [True: 0, False: 1.94k] | | ------------------ | | 586| 1.12k| case 257: result = fromwire_caa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (586:2): [True: 0, False: 1.94k] | | ------------------ | | 587| 1.12k| case 258: result = fromwire_avc(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (587:2): [True: 0, False: 1.94k] | | ------------------ | | 588| 1.12k| case 259: result = fromwire_doa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (588:2): [True: 0, False: 1.94k] | | ------------------ | | 589| 1.12k| case 260: result = fromwire_amtrelay(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (589:2): [True: 0, False: 1.94k] | | ------------------ | | 590| 1.12k| case 261: result = fromwire_resinfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (590:2): [True: 0, False: 1.94k] | | ------------------ | | 591| 1.12k| case 262: result = fromwire_wallet(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (591:2): [True: 0, False: 1.94k] | | ------------------ | | 592| 1.12k| case 32768: result = fromwire_ta(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (592:2): [True: 0, False: 1.94k] | | ------------------ | | 593| 1.12k| case 32769: result = fromwire_dlv(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (593:2): [True: 0, False: 1.94k] | | ------------------ | | 594| 1.12k| case 65533: result = fromwire_keydata(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (594:2): [True: 0, False: 1.94k] | | ------------------ | | 595| 1.12k| default: use_default = true; break; \ | | ------------------ | | | Branch (595:2): [True: 0, False: 1.94k] | | ------------------ | | 596| 1.94k| } ------------------ 977| | 978| 1.94k| if (use_default) { ------------------ | Branch (978:6): [True: 0, False: 1.94k] ------------------ 979| 0| if (activelength > isc_buffer_availablelength(target)) { ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (979:7): [True: 0, False: 0] ------------------ 980| 0| result = ISC_R_NOSPACE; 981| 0| } else { 982| 0| isc_buffer_putmem(target, isc_buffer_current(source), ------------------ | | 145| 0| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 983| 0| activelength); 984| 0| isc_buffer_forward(source, activelength); 985| 0| result = ISC_R_SUCCESS; 986| 0| } 987| 0| } 988| | 989| | /* 990| | * Reject any rdata that expands out to more than DNS_RDATA_MAXLENGTH 991| | * as we cannot transmit it. 992| | */ 993| 1.94k| length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 157| 1.94k|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 157| 1.94k|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 994| 1.94k| if (result == ISC_R_SUCCESS && length > DNS_RDATA_MAXLENGTH) { ------------------ | | 181| 1.24k|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (994:6): [True: 1.24k, False: 706] | Branch (994:33): [True: 6, False: 1.23k] ------------------ 995| 6| result = DNS_R_FORMERR; 996| 6| } 997| | 998| | /* 999| | * We should have consumed all of our buffer. 1000| | */ 1001| 1.94k| if (result == ISC_R_SUCCESS && !buffer_empty(source)) { ------------------ | Branch (1001:6): [True: 1.23k, False: 712] | Branch (1001:33): [True: 109, False: 1.12k] ------------------ 1002| 109| result = DNS_R_EXTRADATA; 1003| 109| } 1004| | 1005| 1.94k| if (rdata != NULL && result == ISC_R_SUCCESS) { ------------------ | Branch (1005:6): [True: 1.94k, False: 0] | Branch (1005:23): [True: 1.12k, False: 821] ------------------ 1006| 1.12k| region.base = isc_buffer_used(&st); ------------------ | | 149| 1.12k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1007| 1.12k| region.length = length; 1008| 1.12k| dns_rdata_fromregion(rdata, rdclass, type, ®ion); 1009| 1.12k| } 1010| | 1011| 1.94k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1011:6): [True: 821, False: 1.12k] ------------------ 1012| 821| *source = ss; 1013| 821| *target = st; 1014| 821| } 1015| 1.94k| return result; 1016| 1.94k|} dns_rdata_fromtext: 1122| 6| dns_rdatacallbacks_t *callbacks) { 1123| 6| isc_result_t result = ISC_R_NOTIMPLEMENTED; 1124| 6| isc_region_t region; 1125| 6| isc_buffer_t st; 1126| 6| isc_token_t token; 1127| 6| unsigned int lexoptions = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 62| 6|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ unsigned int lexoptions = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 63| 6|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ 1128| 6| ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 77| 6|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 81| 6|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 1129| 6| char *name; 1130| 6| unsigned long line; 1131| 6| void (*callback)(dns_rdatacallbacks_t *, const char *, ...); 1132| 6| isc_result_t tresult; 1133| 6| unsigned int length; 1134| 6| bool unknown; 1135| | 1136| 6| REQUIRE(origin == NULL || dns_name_isabsolute(origin)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 6] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1137| 6| if (rdata != NULL) { ------------------ | Branch (1137:6): [True: 6, False: 0] ------------------ 1138| 6| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 60| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1139| 6| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1140| 6| } 1141| 6| if (callbacks != NULL) { ------------------ | Branch (1141:6): [True: 6, False: 0] ------------------ 1142| 6| REQUIRE(callbacks->warn != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1143| 6| REQUIRE(callbacks->error != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1144| 6| } 1145| | 1146| 6| st = *target; 1147| | 1148| 6| if (callbacks != NULL) { ------------------ | Branch (1148:6): [True: 6, False: 0] ------------------ 1149| 6| callback = callbacks->error; 1150| 6| } else { 1151| 0| callback = default_fromtext_callback; 1152| 0| } 1153| | 1154| 6| result = isc_lex_getmastertoken(lexer, &token, isc_tokentype_qstring, 1155| 6| true); 1156| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1156:6): [True: 0, False: 6] ------------------ 1157| 0| name = isc_lex_getsourcename(lexer); 1158| 0| line = isc_lex_getsourceline(lexer); 1159| 0| fromtext_error(callback, callbacks, name, line, NULL, result); 1160| 0| return result; 1161| 0| } 1162| | 1163| 6| unknown = false; 1164| 6| if (token.type == isc_tokentype_string && ------------------ | Branch (1164:6): [True: 6, False: 0] ------------------ 1165| 6| strcmp(DNS_AS_STR(token), "\\#") == 0) ------------------ | | 73| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1165:6): [True: 0, False: 6] ------------------ 1166| 0| { 1167| | /* 1168| | * If this is a TXT record '\#' could be a escaped '#'. 1169| | * Look to see if the next token is a number and if so 1170| | * treat it as a unknown record format. 1171| | */ 1172| 0| if (type == dns_rdatatype_txt) { ------------------ | | 130| 0|#define dns_rdatatype_txt ((dns_rdatatype_t)dns_rdatatype_txt) ------------------ | Branch (1172:7): [True: 0, False: 0] ------------------ 1173| 0| result = isc_lex_getmastertoken( 1174| 0| lexer, &token, isc_tokentype_number, false); 1175| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1175:8): [True: 0, False: 0] ------------------ 1176| 0| isc_lex_ungettoken(lexer, &token); 1177| 0| } 1178| 0| } 1179| | 1180| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1180:7): [True: 0, False: 0] ------------------ 1181| 0| unknown = true; 1182| 0| result = unknown_fromtext(rdclass, type, lexer, mctx, 1183| 0| target); 1184| 0| } else { 1185| 0| options |= DNS_RDATA_UNKNOWNESCAPE; ------------------ | | 215| 0|#define DNS_RDATA_UNKNOWNESCAPE 0x80000000 ------------------ 1186| 0| } 1187| 6| } else { 1188| 6| isc_lex_ungettoken(lexer, &token); 1189| 6| } 1190| | 1191| 6| if (!unknown) { ------------------ | Branch (1191:6): [True: 6, False: 0] ------------------ 1192| 6| FROMTEXTSWITCH ------------------ | | 116| 6| switch (type) { \ | | 117| 0| case 1: switch (rdclass) { \ | | ------------------ | | | Branch (117:2): [True: 0, False: 6] | | ------------------ | | 118| 0| case 1: result = fromtext_in_a(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (118:3): [True: 0, False: 0] | | ------------------ | | 119| 0| case 3: result = fromtext_ch_a(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (119:3): [True: 0, False: 0] | | ------------------ | | 120| 0| case 4: result = fromtext_hs_a(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (120:3): [True: 0, False: 0] | | ------------------ | | 121| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (121:3): [True: 0, False: 0] | | ------------------ | | 122| 0| } \ | | 123| 0| break; \ | | 124| 2| case 2: result = fromtext_ns(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (124:2): [True: 2, False: 4] | | ------------------ | | 125| 0| case 3: result = fromtext_md(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (125:2): [True: 0, False: 6] | | ------------------ | | 126| 0| case 4: result = fromtext_mf(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (126:2): [True: 0, False: 6] | | ------------------ | | 127| 0| case 5: result = fromtext_cname(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (127:2): [True: 0, False: 6] | | ------------------ | | 128| 2| case 6: result = fromtext_soa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (128:2): [True: 2, False: 4] | | ------------------ | | 129| 0| case 7: result = fromtext_mb(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (129:2): [True: 0, False: 6] | | ------------------ | | 130| 0| case 8: result = fromtext_mg(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (130:2): [True: 0, False: 6] | | ------------------ | | 131| 0| case 9: result = fromtext_mr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (131:2): [True: 0, False: 6] | | ------------------ | | 132| 0| case 10: result = fromtext_null(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (132:2): [True: 0, False: 6] | | ------------------ | | 133| 0| case 11: switch (rdclass) { \ | | ------------------ | | | Branch (133:2): [True: 0, False: 6] | | ------------------ | | 134| 0| case 1: result = fromtext_in_wks(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (134:3): [True: 0, False: 0] | | ------------------ | | 135| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (135:3): [True: 0, False: 0] | | ------------------ | | 136| 0| } \ | | 137| 0| break; \ | | 138| 0| case 12: result = fromtext_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (138:2): [True: 0, False: 6] | | ------------------ | | 139| 0| case 13: result = fromtext_hinfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (139:2): [True: 0, False: 6] | | ------------------ | | 140| 0| case 14: result = fromtext_minfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (140:2): [True: 0, False: 6] | | ------------------ | | 141| 0| case 15: result = fromtext_mx(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (141:2): [True: 0, False: 6] | | ------------------ | | 142| 0| case 16: result = fromtext_txt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (142:2): [True: 0, False: 6] | | ------------------ | | 143| 0| case 17: result = fromtext_rp(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (143:2): [True: 0, False: 6] | | ------------------ | | 144| 0| case 18: result = fromtext_afsdb(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (144:2): [True: 0, False: 6] | | ------------------ | | 145| 0| case 19: result = fromtext_x25(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (145:2): [True: 0, False: 6] | | ------------------ | | 146| 0| case 20: result = fromtext_isdn(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (146:2): [True: 0, False: 6] | | ------------------ | | 147| 0| case 21: result = fromtext_rt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (147:2): [True: 0, False: 6] | | ------------------ | | 148| 0| case 22: switch (rdclass) { \ | | ------------------ | | | Branch (148:2): [True: 0, False: 6] | | ------------------ | | 149| 0| case 1: result = fromtext_in_nsap(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (149:3): [True: 0, False: 0] | | ------------------ | | 150| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (150:3): [True: 0, False: 0] | | ------------------ | | 151| 0| } \ | | 152| 0| break; \ | | 153| 0| case 23: switch (rdclass) { \ | | ------------------ | | | Branch (153:2): [True: 0, False: 6] | | ------------------ | | 154| 0| case 1: result = fromtext_in_nsap_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (154:3): [True: 0, False: 0] | | ------------------ | | 155| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (155:3): [True: 0, False: 0] | | ------------------ | | 156| 0| } \ | | 157| 0| break; \ | | 158| 0| case 24: result = fromtext_sig(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (158:2): [True: 0, False: 6] | | ------------------ | | 159| 2| case 25: result = fromtext_key(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (159:2): [True: 2, False: 4] | | ------------------ | | 160| 0| case 26: switch (rdclass) { \ | | ------------------ | | | Branch (160:2): [True: 0, False: 6] | | ------------------ | | 161| 0| case 1: result = fromtext_in_px(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (161:3): [True: 0, False: 0] | | ------------------ | | 162| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (162:3): [True: 0, False: 0] | | ------------------ | | 163| 0| } \ | | 164| 0| break; \ | | 165| 0| case 27: result = fromtext_gpos(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (165:2): [True: 0, False: 6] | | ------------------ | | 166| 0| case 28: switch (rdclass) { \ | | ------------------ | | | Branch (166:2): [True: 0, False: 6] | | ------------------ | | 167| 0| case 1: result = fromtext_in_aaaa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (167:3): [True: 0, False: 0] | | ------------------ | | 168| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (168:3): [True: 0, False: 0] | | ------------------ | | 169| 0| } \ | | 170| 0| break; \ | | 171| 0| case 29: result = fromtext_loc(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (171:2): [True: 0, False: 6] | | ------------------ | | 172| 0| case 30: result = fromtext_nxt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (172:2): [True: 0, False: 6] | | ------------------ | | 173| 0| case 31: switch (rdclass) { \ | | ------------------ | | | Branch (173:2): [True: 0, False: 6] | | ------------------ | | 174| 0| case 1: result = fromtext_in_eid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (174:3): [True: 0, False: 0] | | ------------------ | | 175| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (175:3): [True: 0, False: 0] | | ------------------ | | 176| 0| } \ | | 177| 0| break; \ | | 178| 0| case 32: switch (rdclass) { \ | | ------------------ | | | Branch (178:2): [True: 0, False: 6] | | ------------------ | | 179| 0| case 1: result = fromtext_in_nimloc(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (179:3): [True: 0, False: 0] | | ------------------ | | 180| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (180:3): [True: 0, False: 0] | | ------------------ | | 181| 0| } \ | | 182| 0| break; \ | | 183| 0| case 33: switch (rdclass) { \ | | ------------------ | | | Branch (183:2): [True: 0, False: 6] | | ------------------ | | 184| 0| case 1: result = fromtext_in_srv(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (184:3): [True: 0, False: 0] | | ------------------ | | 185| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (185:3): [True: 0, False: 0] | | ------------------ | | 186| 0| } \ | | 187| 0| break; \ | | 188| 0| case 34: switch (rdclass) { \ | | ------------------ | | | Branch (188:2): [True: 0, False: 6] | | ------------------ | | 189| 0| case 1: result = fromtext_in_atma(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (189:3): [True: 0, False: 0] | | ------------------ | | 190| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (190:3): [True: 0, False: 0] | | ------------------ | | 191| 0| } \ | | 192| 0| break; \ | | 193| 0| case 35: result = fromtext_naptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (193:2): [True: 0, False: 6] | | ------------------ | | 194| 0| case 36: switch (rdclass) { \ | | ------------------ | | | Branch (194:2): [True: 0, False: 6] | | ------------------ | | 195| 0| case 1: result = fromtext_in_kx(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (195:3): [True: 0, False: 0] | | ------------------ | | 196| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (196:3): [True: 0, False: 0] | | ------------------ | | 197| 0| } \ | | 198| 0| break; \ | | 199| 0| case 37: result = fromtext_cert(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (199:2): [True: 0, False: 6] | | ------------------ | | 200| 0| case 38: switch (rdclass) { \ | | ------------------ | | | Branch (200:2): [True: 0, False: 6] | | ------------------ | | 201| 0| case 1: result = fromtext_in_a6(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (201:3): [True: 0, False: 0] | | ------------------ | | 202| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (202:3): [True: 0, False: 0] | | ------------------ | | 203| 0| } \ | | 204| 0| break; \ | | 205| 0| case 39: result = fromtext_dname(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (205:2): [True: 0, False: 6] | | ------------------ | | 206| 0| case 40: result = fromtext_sink(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (206:2): [True: 0, False: 6] | | ------------------ | | 207| 0| case 41: result = fromtext_opt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (207:2): [True: 0, False: 6] | | ------------------ | | 208| 0| case 42: switch (rdclass) { \ | | ------------------ | | | Branch (208:2): [True: 0, False: 6] | | ------------------ | | 209| 0| case 1: result = fromtext_in_apl(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (209:3): [True: 0, False: 0] | | ------------------ | | 210| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (210:3): [True: 0, False: 0] | | ------------------ | | 211| 0| } \ | | 212| 0| break; \ | | 213| 0| case 43: result = fromtext_ds(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (213:2): [True: 0, False: 6] | | ------------------ | | 214| 0| case 44: result = fromtext_sshfp(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (214:2): [True: 0, False: 6] | | ------------------ | | 215| 0| case 45: result = fromtext_ipseckey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (215:2): [True: 0, False: 6] | | ------------------ | | 216| 0| case 46: result = fromtext_rrsig(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (216:2): [True: 0, False: 6] | | ------------------ | | 217| 0| case 47: result = fromtext_nsec(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (217:2): [True: 0, False: 6] | | ------------------ | | 218| 0| case 48: result = fromtext_dnskey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (218:2): [True: 0, False: 6] | | ------------------ | | 219| 0| case 49: switch (rdclass) { \ | | ------------------ | | | Branch (219:2): [True: 0, False: 6] | | ------------------ | | 220| 0| case 1: result = fromtext_in_dhcid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (220:3): [True: 0, False: 0] | | ------------------ | | 221| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (221:3): [True: 0, False: 0] | | ------------------ | | 222| 0| } \ | | 223| 0| break; \ | | 224| 0| case 50: result = fromtext_nsec3(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (224:2): [True: 0, False: 6] | | ------------------ | | 225| 0| case 51: result = fromtext_nsec3param(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (225:2): [True: 0, False: 6] | | ------------------ | | 226| 0| case 52: result = fromtext_tlsa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (226:2): [True: 0, False: 6] | | ------------------ | | 227| 0| case 53: result = fromtext_smimea(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (227:2): [True: 0, False: 6] | | ------------------ | | 228| 0| case 55: result = fromtext_hip(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (228:2): [True: 0, False: 6] | | ------------------ | | 229| 0| case 56: result = fromtext_ninfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (229:2): [True: 0, False: 6] | | ------------------ | | 230| 0| case 57: result = fromtext_rkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (230:2): [True: 0, False: 6] | | ------------------ | | 231| 0| case 58: result = fromtext_talink(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (231:2): [True: 0, False: 6] | | ------------------ | | 232| 0| case 59: result = fromtext_cds(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (232:2): [True: 0, False: 6] | | ------------------ | | 233| 0| case 60: result = fromtext_cdnskey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (233:2): [True: 0, False: 6] | | ------------------ | | 234| 0| case 61: result = fromtext_openpgpkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (234:2): [True: 0, False: 6] | | ------------------ | | 235| 0| case 62: result = fromtext_csync(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (235:2): [True: 0, False: 6] | | ------------------ | | 236| 0| case 63: result = fromtext_zonemd(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (236:2): [True: 0, False: 6] | | ------------------ | | 237| 0| case 64: switch (rdclass) { \ | | ------------------ | | | Branch (237:2): [True: 0, False: 6] | | ------------------ | | 238| 0| case 1: result = fromtext_in_svcb(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (238:3): [True: 0, False: 0] | | ------------------ | | 239| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (239:3): [True: 0, False: 0] | | ------------------ | | 240| 0| } \ | | 241| 0| break; \ | | 242| 0| case 65: switch (rdclass) { \ | | ------------------ | | | Branch (242:2): [True: 0, False: 6] | | ------------------ | | 243| 0| case 1: result = fromtext_in_https(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (243:3): [True: 0, False: 0] | | ------------------ | | 244| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (244:3): [True: 0, False: 0] | | ------------------ | | 245| 0| } \ | | 246| 0| break; \ | | 247| 0| case 66: result = fromtext_dsync(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (247:2): [True: 0, False: 6] | | ------------------ | | 248| 0| case 67: result = fromtext_hhit(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (248:2): [True: 0, False: 6] | | ------------------ | | 249| 0| case 68: result = fromtext_brid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (249:2): [True: 0, False: 6] | | ------------------ | | 250| 0| case 99: result = fromtext_spf(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (250:2): [True: 0, False: 6] | | ------------------ | | 251| 0| case 104: result = fromtext_nid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (251:2): [True: 0, False: 6] | | ------------------ | | 252| 0| case 105: result = fromtext_l32(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (252:2): [True: 0, False: 6] | | ------------------ | | 253| 0| case 106: result = fromtext_l64(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (253:2): [True: 0, False: 6] | | ------------------ | | 254| 0| case 107: result = fromtext_lp(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (254:2): [True: 0, False: 6] | | ------------------ | | 255| 0| case 108: result = fromtext_eui48(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (255:2): [True: 0, False: 6] | | ------------------ | | 256| 0| case 109: result = fromtext_eui64(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (256:2): [True: 0, False: 6] | | ------------------ | | 257| 0| case 249: result = fromtext_tkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (257:2): [True: 0, False: 6] | | ------------------ | | 258| 0| case 250: switch (rdclass) { \ | | ------------------ | | | Branch (258:2): [True: 0, False: 6] | | ------------------ | | 259| 0| case 255: result = fromtext_any_tsig(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (259:3): [True: 0, False: 0] | | ------------------ | | 260| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (260:3): [True: 0, False: 0] | | ------------------ | | 261| 0| } \ | | 262| 0| break; \ | | 263| 0| case 256: result = fromtext_uri(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (263:2): [True: 0, False: 6] | | ------------------ | | 264| 0| case 257: result = fromtext_caa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (264:2): [True: 0, False: 6] | | ------------------ | | 265| 0| case 258: result = fromtext_avc(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (265:2): [True: 0, False: 6] | | ------------------ | | 266| 0| case 259: result = fromtext_doa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (266:2): [True: 0, False: 6] | | ------------------ | | 267| 0| case 260: result = fromtext_amtrelay(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (267:2): [True: 0, False: 6] | | ------------------ | | 268| 0| case 261: result = fromtext_resinfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (268:2): [True: 0, False: 6] | | ------------------ | | 269| 0| case 262: result = fromtext_wallet(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (269:2): [True: 0, False: 6] | | ------------------ | | 270| 0| case 32768: result = fromtext_ta(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (270:2): [True: 0, False: 6] | | ------------------ | | 271| 0| case 32769: result = fromtext_dlv(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (271:2): [True: 0, False: 6] | | ------------------ | | 272| 0| case 65533: result = fromtext_keydata(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (272:2): [True: 0, False: 6] | | ------------------ | | 273| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (273:2): [True: 0, False: 6] | | ------------------ | | 274| 6| } ------------------ 1193| | 1194| | /* 1195| | * Consume to end of line / file. 1196| | * If not at end of line initially set error code. 1197| | * Call callback via fromtext_error once if there was an error. 1198| | */ 1199| 6| } 1200| 6| do { 1201| 6| name = isc_lex_getsourcename(lexer); 1202| 6| line = isc_lex_getsourceline(lexer); 1203| 6| tresult = isc_lex_gettoken(lexer, lexoptions, &token); 1204| 6| if (tresult != ISC_R_SUCCESS) { ------------------ | Branch (1204:7): [True: 0, False: 6] ------------------ 1205| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1205:8): [True: 0, False: 0] ------------------ 1206| 0| result = tresult; 1207| 0| } 1208| 0| if (callback != NULL) { ------------------ | Branch (1208:8): [True: 0, False: 0] ------------------ 1209| 0| fromtext_error(callback, callbacks, name, line, 1210| 0| NULL, result); 1211| 0| } 1212| 0| break; 1213| 6| } else if (token.type != isc_tokentype_eol && ------------------ | Branch (1213:14): [True: 0, False: 6] ------------------ 1214| 0| token.type != isc_tokentype_eof) ------------------ | Branch (1214:7): [True: 0, False: 0] ------------------ 1215| 0| { 1216| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1216:8): [True: 0, False: 0] ------------------ 1217| 0| result = DNS_R_EXTRATOKEN; 1218| 0| } 1219| 0| if (callback != NULL) { ------------------ | Branch (1219:8): [True: 0, False: 0] ------------------ 1220| 0| fromtext_error(callback, callbacks, name, line, 1221| 0| &token, result); 1222| 0| callback = NULL; 1223| 0| } 1224| 6| } else if (result != ISC_R_SUCCESS && callback != NULL) { ------------------ | Branch (1224:14): [True: 0, False: 6] | Branch (1224:41): [True: 0, False: 0] ------------------ 1225| 0| fromtext_error(callback, callbacks, name, line, &token, 1226| 0| result); 1227| 0| break; 1228| 6| } else { 1229| 6| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1229:8): [True: 0, False: 6] ------------------ 1230| 0| fromtext_warneof(lexer, callbacks); 1231| 0| } 1232| 6| break; 1233| 6| } 1234| 6| } while (1); ------------------ | Branch (1234:11): [True: 0, Folded] ------------------ 1235| | 1236| 6| length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 157| 6|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 157| 6|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1237| 6| if (result == ISC_R_SUCCESS && length > DNS_RDATA_MAXLENGTH) { ------------------ | | 181| 6|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (1237:6): [True: 6, False: 0] | Branch (1237:33): [True: 0, False: 6] ------------------ 1238| 0| result = ISC_R_NOSPACE; 1239| 0| } 1240| | 1241| 6| if (rdata != NULL && result == ISC_R_SUCCESS) { ------------------ | Branch (1241:6): [True: 6, False: 0] | Branch (1241:23): [True: 6, False: 0] ------------------ 1242| 6| region.base = isc_buffer_used(&st); ------------------ | | 149| 6| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1243| 6| region.length = length; 1244| 6| dns_rdata_fromregion(rdata, rdclass, type, ®ion); 1245| 6| } 1246| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1246:6): [True: 0, False: 6] ------------------ 1247| 0| *target = st; 1248| 0| } 1249| 6| return result; 1250| 6|} dns_rdata_tostruct: 1414| 1.41k|dns_rdata_tostruct(const dns_rdata_t *rdata, void *target, isc_mem_t *mctx) { 1415| 1.41k| isc_result_t result = ISC_R_NOTIMPLEMENTED; 1416| 1.41k| bool use_default = false; 1417| | 1418| 1.41k| REQUIRE(rdata != NULL); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1419| 1.41k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1420| 1.41k| REQUIRE((rdata->flags & DNS_RDATA_UPDATE) == 0); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1421| | 1422| 1.41k| TOSTRUCTSWITCH ------------------ | | 1243| 1.41k| switch (rdata->type) { \ | | 1244| 0| case 1: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1244:2): [True: 0, False: 1.41k] | | ------------------ | | 1245| 0| case 1: result = tostruct_in_a(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1245:3): [True: 0, False: 0] | | ------------------ | | 1246| 0| case 3: result = tostruct_ch_a(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1246:3): [True: 0, False: 0] | | ------------------ | | 1247| 0| case 4: result = tostruct_hs_a(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1247:3): [True: 0, False: 0] | | ------------------ | | 1248| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1248:3): [True: 0, False: 0] | | ------------------ | | 1249| 0| } \ | | 1250| 0| break; \ | | 1251| 2| case 2: result = tostruct_ns(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1251:2): [True: 2, False: 1.40k] | | ------------------ | | 1252| 0| case 3: result = tostruct_md(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1252:2): [True: 0, False: 1.41k] | | ------------------ | | 1253| 0| case 4: result = tostruct_mf(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1253:2): [True: 0, False: 1.41k] | | ------------------ | | 1254| 0| case 5: result = tostruct_cname(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1254:2): [True: 0, False: 1.41k] | | ------------------ | | 1255| 2| case 6: result = tostruct_soa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1255:2): [True: 2, False: 1.40k] | | ------------------ | | 1256| 0| case 7: result = tostruct_mb(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1256:2): [True: 0, False: 1.41k] | | ------------------ | | 1257| 0| case 8: result = tostruct_mg(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1257:2): [True: 0, False: 1.41k] | | ------------------ | | 1258| 0| case 9: result = tostruct_mr(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1258:2): [True: 0, False: 1.41k] | | ------------------ | | 1259| 0| case 10: result = tostruct_null(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1259:2): [True: 0, False: 1.41k] | | ------------------ | | 1260| 0| case 11: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1260:2): [True: 0, False: 1.41k] | | ------------------ | | 1261| 0| case 1: result = tostruct_in_wks(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1261:3): [True: 0, False: 0] | | ------------------ | | 1262| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1262:3): [True: 0, False: 0] | | ------------------ | | 1263| 0| } \ | | 1264| 0| break; \ | | 1265| 0| case 12: result = tostruct_ptr(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1265:2): [True: 0, False: 1.41k] | | ------------------ | | 1266| 0| case 13: result = tostruct_hinfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1266:2): [True: 0, False: 1.41k] | | ------------------ | | 1267| 0| case 14: result = tostruct_minfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1267:2): [True: 0, False: 1.41k] | | ------------------ | | 1268| 0| case 15: result = tostruct_mx(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1268:2): [True: 0, False: 1.41k] | | ------------------ | | 1269| 0| case 16: result = tostruct_txt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1269:2): [True: 0, False: 1.41k] | | ------------------ | | 1270| 0| case 17: result = tostruct_rp(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1270:2): [True: 0, False: 1.41k] | | ------------------ | | 1271| 0| case 18: result = tostruct_afsdb(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1271:2): [True: 0, False: 1.41k] | | ------------------ | | 1272| 0| case 19: result = tostruct_x25(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1272:2): [True: 0, False: 1.41k] | | ------------------ | | 1273| 0| case 20: result = tostruct_isdn(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1273:2): [True: 0, False: 1.41k] | | ------------------ | | 1274| 0| case 21: result = tostruct_rt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1274:2): [True: 0, False: 1.41k] | | ------------------ | | 1275| 0| case 22: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1275:2): [True: 0, False: 1.41k] | | ------------------ | | 1276| 0| case 1: result = tostruct_in_nsap(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1276:3): [True: 0, False: 0] | | ------------------ | | 1277| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1277:3): [True: 0, False: 0] | | ------------------ | | 1278| 0| } \ | | 1279| 0| break; \ | | 1280| 0| case 23: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1280:2): [True: 0, False: 1.41k] | | ------------------ | | 1281| 0| case 1: result = tostruct_in_nsap_ptr(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1281:3): [True: 0, False: 0] | | ------------------ | | 1282| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1282:3): [True: 0, False: 0] | | ------------------ | | 1283| 0| } \ | | 1284| 0| break; \ | | 1285| 536| case 24: result = tostruct_sig(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1285:2): [True: 536, False: 875] | | ------------------ | | 1286| 132| case 25: result = tostruct_key(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1286:2): [True: 132, False: 1.27k] | | ------------------ | | 1287| 0| case 26: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1287:2): [True: 0, False: 1.41k] | | ------------------ | | 1288| 0| case 1: result = tostruct_in_px(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1288:3): [True: 0, False: 0] | | ------------------ | | 1289| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1289:3): [True: 0, False: 0] | | ------------------ | | 1290| 0| } \ | | 1291| 0| break; \ | | 1292| 0| case 27: result = tostruct_gpos(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1292:2): [True: 0, False: 1.41k] | | ------------------ | | 1293| 0| case 28: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1293:2): [True: 0, False: 1.41k] | | ------------------ | | 1294| 0| case 1: result = tostruct_in_aaaa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1294:3): [True: 0, False: 0] | | ------------------ | | 1295| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1295:3): [True: 0, False: 0] | | ------------------ | | 1296| 0| } \ | | 1297| 0| break; \ | | 1298| 0| case 29: result = tostruct_loc(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1298:2): [True: 0, False: 1.41k] | | ------------------ | | 1299| 0| case 30: result = tostruct_nxt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1299:2): [True: 0, False: 1.41k] | | ------------------ | | 1300| 0| case 31: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1300:2): [True: 0, False: 1.41k] | | ------------------ | | 1301| 0| case 1: result = tostruct_in_eid(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1301:3): [True: 0, False: 0] | | ------------------ | | 1302| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1302:3): [True: 0, False: 0] | | ------------------ | | 1303| 0| } \ | | 1304| 0| break; \ | | 1305| 0| case 32: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1305:2): [True: 0, False: 1.41k] | | ------------------ | | 1306| 0| case 1: result = tostruct_in_nimloc(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1306:3): [True: 0, False: 0] | | ------------------ | | 1307| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1307:3): [True: 0, False: 0] | | ------------------ | | 1308| 0| } \ | | 1309| 0| break; \ | | 1310| 0| case 33: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1310:2): [True: 0, False: 1.41k] | | ------------------ | | 1311| 0| case 1: result = tostruct_in_srv(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1311:3): [True: 0, False: 0] | | ------------------ | | 1312| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1312:3): [True: 0, False: 0] | | ------------------ | | 1313| 0| } \ | | 1314| 0| break; \ | | 1315| 0| case 34: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1315:2): [True: 0, False: 1.41k] | | ------------------ | | 1316| 0| case 1: result = tostruct_in_atma(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1316:3): [True: 0, False: 0] | | ------------------ | | 1317| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1317:3): [True: 0, False: 0] | | ------------------ | | 1318| 0| } \ | | 1319| 0| break; \ | | 1320| 0| case 35: result = tostruct_naptr(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1320:2): [True: 0, False: 1.41k] | | ------------------ | | 1321| 0| case 36: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1321:2): [True: 0, False: 1.41k] | | ------------------ | | 1322| 0| case 1: result = tostruct_in_kx(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1322:3): [True: 0, False: 0] | | ------------------ | | 1323| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1323:3): [True: 0, False: 0] | | ------------------ | | 1324| 0| } \ | | 1325| 0| break; \ | | 1326| 0| case 37: result = tostruct_cert(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1326:2): [True: 0, False: 1.41k] | | ------------------ | | 1327| 0| case 38: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1327:2): [True: 0, False: 1.41k] | | ------------------ | | 1328| 0| case 1: result = tostruct_in_a6(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1328:3): [True: 0, False: 0] | | ------------------ | | 1329| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1329:3): [True: 0, False: 0] | | ------------------ | | 1330| 0| } \ | | 1331| 0| break; \ | | 1332| 0| case 39: result = tostruct_dname(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1332:2): [True: 0, False: 1.41k] | | ------------------ | | 1333| 0| case 40: result = tostruct_sink(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1333:2): [True: 0, False: 1.41k] | | ------------------ | | 1334| 0| case 41: result = tostruct_opt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1334:2): [True: 0, False: 1.41k] | | ------------------ | | 1335| 0| case 42: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1335:2): [True: 0, False: 1.41k] | | ------------------ | | 1336| 0| case 1: result = tostruct_in_apl(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1336:3): [True: 0, False: 0] | | ------------------ | | 1337| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1337:3): [True: 0, False: 0] | | ------------------ | | 1338| 0| } \ | | 1339| 0| break; \ | | 1340| 0| case 43: result = tostruct_ds(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1340:2): [True: 0, False: 1.41k] | | ------------------ | | 1341| 0| case 44: result = tostruct_sshfp(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1341:2): [True: 0, False: 1.41k] | | ------------------ | | 1342| 0| case 45: result = tostruct_ipseckey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1342:2): [True: 0, False: 1.41k] | | ------------------ | | 1343| 0| case 46: result = tostruct_rrsig(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1343:2): [True: 0, False: 1.41k] | | ------------------ | | 1344| 0| case 47: result = tostruct_nsec(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1344:2): [True: 0, False: 1.41k] | | ------------------ | | 1345| 0| case 48: result = tostruct_dnskey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1345:2): [True: 0, False: 1.41k] | | ------------------ | | 1346| 0| case 49: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1346:2): [True: 0, False: 1.41k] | | ------------------ | | 1347| 0| case 1: result = tostruct_in_dhcid(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1347:3): [True: 0, False: 0] | | ------------------ | | 1348| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1348:3): [True: 0, False: 0] | | ------------------ | | 1349| 0| } \ | | 1350| 0| break; \ | | 1351| 0| case 50: result = tostruct_nsec3(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1351:2): [True: 0, False: 1.41k] | | ------------------ | | 1352| 0| case 51: result = tostruct_nsec3param(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1352:2): [True: 0, False: 1.41k] | | ------------------ | | 1353| 0| case 52: result = tostruct_tlsa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1353:2): [True: 0, False: 1.41k] | | ------------------ | | 1354| 0| case 53: result = tostruct_smimea(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1354:2): [True: 0, False: 1.41k] | | ------------------ | | 1355| 0| case 55: result = tostruct_hip(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1355:2): [True: 0, False: 1.41k] | | ------------------ | | 1356| 0| case 56: result = tostruct_ninfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1356:2): [True: 0, False: 1.41k] | | ------------------ | | 1357| 0| case 57: result = tostruct_rkey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1357:2): [True: 0, False: 1.41k] | | ------------------ | | 1358| 0| case 58: result = tostruct_talink(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1358:2): [True: 0, False: 1.41k] | | ------------------ | | 1359| 0| case 59: result = tostruct_cds(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1359:2): [True: 0, False: 1.41k] | | ------------------ | | 1360| 0| case 60: result = tostruct_cdnskey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1360:2): [True: 0, False: 1.41k] | | ------------------ | | 1361| 0| case 61: result = tostruct_openpgpkey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1361:2): [True: 0, False: 1.41k] | | ------------------ | | 1362| 0| case 62: result = tostruct_csync(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1362:2): [True: 0, False: 1.41k] | | ------------------ | | 1363| 0| case 63: result = tostruct_zonemd(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1363:2): [True: 0, False: 1.41k] | | ------------------ | | 1364| 0| case 64: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1364:2): [True: 0, False: 1.41k] | | ------------------ | | 1365| 0| case 1: result = tostruct_in_svcb(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1365:3): [True: 0, False: 0] | | ------------------ | | 1366| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1366:3): [True: 0, False: 0] | | ------------------ | | 1367| 0| } \ | | 1368| 0| break; \ | | 1369| 0| case 65: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1369:2): [True: 0, False: 1.41k] | | ------------------ | | 1370| 0| case 1: result = tostruct_in_https(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1370:3): [True: 0, False: 0] | | ------------------ | | 1371| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1371:3): [True: 0, False: 0] | | ------------------ | | 1372| 0| } \ | | 1373| 0| break; \ | | 1374| 0| case 66: result = tostruct_dsync(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1374:2): [True: 0, False: 1.41k] | | ------------------ | | 1375| 0| case 67: result = tostruct_hhit(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1375:2): [True: 0, False: 1.41k] | | ------------------ | | 1376| 0| case 68: result = tostruct_brid(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1376:2): [True: 0, False: 1.41k] | | ------------------ | | 1377| 0| case 99: result = tostruct_spf(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1377:2): [True: 0, False: 1.41k] | | ------------------ | | 1378| 0| case 104: result = tostruct_nid(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1378:2): [True: 0, False: 1.41k] | | ------------------ | | 1379| 0| case 105: result = tostruct_l32(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1379:2): [True: 0, False: 1.41k] | | ------------------ | | 1380| 0| case 106: result = tostruct_l64(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1380:2): [True: 0, False: 1.41k] | | ------------------ | | 1381| 0| case 107: result = tostruct_lp(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1381:2): [True: 0, False: 1.41k] | | ------------------ | | 1382| 0| case 108: result = tostruct_eui48(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1382:2): [True: 0, False: 1.41k] | | ------------------ | | 1383| 0| case 109: result = tostruct_eui64(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1383:2): [True: 0, False: 1.41k] | | ------------------ | | 1384| 0| case 249: result = tostruct_tkey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1384:2): [True: 0, False: 1.41k] | | ------------------ | | 1385| 739| case 250: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1385:2): [True: 739, False: 672] | | ------------------ | | 1386| 739| case 255: result = tostruct_any_tsig(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1386:3): [True: 739, False: 0] | | ------------------ | | 1387| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1387:3): [True: 0, False: 739] | | ------------------ | | 1388| 739| } \ | | 1389| 739| break; \ | | 1390| 739| case 256: result = tostruct_uri(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1390:2): [True: 0, False: 1.41k] | | ------------------ | | 1391| 739| case 257: result = tostruct_caa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1391:2): [True: 0, False: 1.41k] | | ------------------ | | 1392| 739| case 258: result = tostruct_avc(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1392:2): [True: 0, False: 1.41k] | | ------------------ | | 1393| 739| case 259: result = tostruct_doa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1393:2): [True: 0, False: 1.41k] | | ------------------ | | 1394| 739| case 260: result = tostruct_amtrelay(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1394:2): [True: 0, False: 1.41k] | | ------------------ | | 1395| 739| case 261: result = tostruct_resinfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1395:2): [True: 0, False: 1.41k] | | ------------------ | | 1396| 739| case 262: result = tostruct_wallet(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1396:2): [True: 0, False: 1.41k] | | ------------------ | | 1397| 739| case 32768: result = tostruct_ta(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1397:2): [True: 0, False: 1.41k] | | ------------------ | | 1398| 739| case 32769: result = tostruct_dlv(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1398:2): [True: 0, False: 1.41k] | | ------------------ | | 1399| 739| case 65533: result = tostruct_keydata(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1399:2): [True: 0, False: 1.41k] | | ------------------ | | 1400| 739| default: use_default = true; break; \ | | ------------------ | | | Branch (1400:2): [True: 0, False: 1.41k] | | ------------------ | | 1401| 1.41k| } ------------------ 1423| | 1424| 1.41k| if (use_default) { ------------------ | Branch (1424:6): [True: 0, False: 1.41k] ------------------ 1425| 0| (void)NULL; 1426| 0| } 1427| | 1428| 1.41k| return result; 1429| 1.41k|} dns_rdata_freestruct: 1432| 536|dns_rdata_freestruct(void *source) { 1433| 536| dns_rdatacommon_t *common = source; 1434| 536| REQUIRE(common != NULL); ------------------ | | 194| 536|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 536| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 536, False: 0] | | | | ------------------ | | | | 43| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1435| | 1436| 536| FREESTRUCTSWITCH ------------------ | | 1404| 536| switch (common->rdtype) { \ | | 1405| 0| case 1: switch (common->rdclass) { \ | | ------------------ | | | Branch (1405:2): [True: 0, False: 536] | | ------------------ | | 1406| 0| case 1: freestruct_in_a(source); break; \ | | ------------------ | | | Branch (1406:3): [True: 0, False: 0] | | ------------------ | | 1407| 0| case 3: freestruct_ch_a(source); break; \ | | ------------------ | | | Branch (1407:3): [True: 0, False: 0] | | ------------------ | | 1408| 0| case 4: freestruct_hs_a(source); break; \ | | ------------------ | | | Branch (1408:3): [True: 0, False: 0] | | ------------------ | | 1409| 0| default: break; \ | | ------------------ | | | Branch (1409:3): [True: 0, False: 0] | | ------------------ | | 1410| 0| } \ | | 1411| 0| break; \ | | 1412| 0| case 2: freestruct_ns(source); break; \ | | ------------------ | | | Branch (1412:2): [True: 0, False: 536] | | ------------------ | | 1413| 0| case 3: freestruct_md(source); break; \ | | ------------------ | | | Branch (1413:2): [True: 0, False: 536] | | ------------------ | | 1414| 0| case 4: freestruct_mf(source); break; \ | | ------------------ | | | Branch (1414:2): [True: 0, False: 536] | | ------------------ | | 1415| 0| case 5: freestruct_cname(source); break; \ | | ------------------ | | | Branch (1415:2): [True: 0, False: 536] | | ------------------ | | 1416| 0| case 6: freestruct_soa(source); break; \ | | ------------------ | | | Branch (1416:2): [True: 0, False: 536] | | ------------------ | | 1417| 0| case 7: freestruct_mb(source); break; \ | | ------------------ | | | Branch (1417:2): [True: 0, False: 536] | | ------------------ | | 1418| 0| case 8: freestruct_mg(source); break; \ | | ------------------ | | | Branch (1418:2): [True: 0, False: 536] | | ------------------ | | 1419| 0| case 9: freestruct_mr(source); break; \ | | ------------------ | | | Branch (1419:2): [True: 0, False: 536] | | ------------------ | | 1420| 0| case 10: freestruct_null(source); break; \ | | ------------------ | | | Branch (1420:2): [True: 0, False: 536] | | ------------------ | | 1421| 0| case 11: switch (common->rdclass) { \ | | ------------------ | | | Branch (1421:2): [True: 0, False: 536] | | ------------------ | | 1422| 0| case 1: freestruct_in_wks(source); break; \ | | ------------------ | | | Branch (1422:3): [True: 0, False: 0] | | ------------------ | | 1423| 0| default: break; \ | | ------------------ | | | Branch (1423:3): [True: 0, False: 0] | | ------------------ | | 1424| 0| } \ | | 1425| 0| break; \ | | 1426| 0| case 12: freestruct_ptr(source); break; \ | | ------------------ | | | Branch (1426:2): [True: 0, False: 536] | | ------------------ | | 1427| 0| case 13: freestruct_hinfo(source); break; \ | | ------------------ | | | Branch (1427:2): [True: 0, False: 536] | | ------------------ | | 1428| 0| case 14: freestruct_minfo(source); break; \ | | ------------------ | | | Branch (1428:2): [True: 0, False: 536] | | ------------------ | | 1429| 0| case 15: freestruct_mx(source); break; \ | | ------------------ | | | Branch (1429:2): [True: 0, False: 536] | | ------------------ | | 1430| 0| case 16: freestruct_txt(source); break; \ | | ------------------ | | | Branch (1430:2): [True: 0, False: 536] | | ------------------ | | 1431| 0| case 17: freestruct_rp(source); break; \ | | ------------------ | | | Branch (1431:2): [True: 0, False: 536] | | ------------------ | | 1432| 0| case 18: freestruct_afsdb(source); break; \ | | ------------------ | | | Branch (1432:2): [True: 0, False: 536] | | ------------------ | | 1433| 0| case 19: freestruct_x25(source); break; \ | | ------------------ | | | Branch (1433:2): [True: 0, False: 536] | | ------------------ | | 1434| 0| case 20: freestruct_isdn(source); break; \ | | ------------------ | | | Branch (1434:2): [True: 0, False: 536] | | ------------------ | | 1435| 0| case 21: freestruct_rt(source); break; \ | | ------------------ | | | Branch (1435:2): [True: 0, False: 536] | | ------------------ | | 1436| 0| case 22: switch (common->rdclass) { \ | | ------------------ | | | Branch (1436:2): [True: 0, False: 536] | | ------------------ | | 1437| 0| case 1: freestruct_in_nsap(source); break; \ | | ------------------ | | | Branch (1437:3): [True: 0, False: 0] | | ------------------ | | 1438| 0| default: break; \ | | ------------------ | | | Branch (1438:3): [True: 0, False: 0] | | ------------------ | | 1439| 0| } \ | | 1440| 0| break; \ | | 1441| 0| case 23: switch (common->rdclass) { \ | | ------------------ | | | Branch (1441:2): [True: 0, False: 536] | | ------------------ | | 1442| 0| case 1: freestruct_in_nsap_ptr(source); break; \ | | ------------------ | | | Branch (1442:3): [True: 0, False: 0] | | ------------------ | | 1443| 0| default: break; \ | | ------------------ | | | Branch (1443:3): [True: 0, False: 0] | | ------------------ | | 1444| 0| } \ | | 1445| 0| break; \ | | 1446| 536| case 24: freestruct_sig(source); break; \ | | ------------------ | | | Branch (1446:2): [True: 536, False: 0] | | ------------------ | | 1447| 0| case 25: freestruct_key(source); break; \ | | ------------------ | | | Branch (1447:2): [True: 0, False: 536] | | ------------------ | | 1448| 0| case 26: switch (common->rdclass) { \ | | ------------------ | | | Branch (1448:2): [True: 0, False: 536] | | ------------------ | | 1449| 0| case 1: freestruct_in_px(source); break; \ | | ------------------ | | | Branch (1449:3): [True: 0, False: 0] | | ------------------ | | 1450| 0| default: break; \ | | ------------------ | | | Branch (1450:3): [True: 0, False: 0] | | ------------------ | | 1451| 0| } \ | | 1452| 0| break; \ | | 1453| 0| case 27: freestruct_gpos(source); break; \ | | ------------------ | | | Branch (1453:2): [True: 0, False: 536] | | ------------------ | | 1454| 0| case 28: switch (common->rdclass) { \ | | ------------------ | | | Branch (1454:2): [True: 0, False: 536] | | ------------------ | | 1455| 0| case 1: freestruct_in_aaaa(source); break; \ | | ------------------ | | | Branch (1455:3): [True: 0, False: 0] | | ------------------ | | 1456| 0| default: break; \ | | ------------------ | | | Branch (1456:3): [True: 0, False: 0] | | ------------------ | | 1457| 0| } \ | | 1458| 0| break; \ | | 1459| 0| case 29: freestruct_loc(source); break; \ | | ------------------ | | | Branch (1459:2): [True: 0, False: 536] | | ------------------ | | 1460| 0| case 30: freestruct_nxt(source); break; \ | | ------------------ | | | Branch (1460:2): [True: 0, False: 536] | | ------------------ | | 1461| 0| case 31: switch (common->rdclass) { \ | | ------------------ | | | Branch (1461:2): [True: 0, False: 536] | | ------------------ | | 1462| 0| case 1: freestruct_in_eid(source); break; \ | | ------------------ | | | Branch (1462:3): [True: 0, False: 0] | | ------------------ | | 1463| 0| default: break; \ | | ------------------ | | | Branch (1463:3): [True: 0, False: 0] | | ------------------ | | 1464| 0| } \ | | 1465| 0| break; \ | | 1466| 0| case 32: switch (common->rdclass) { \ | | ------------------ | | | Branch (1466:2): [True: 0, False: 536] | | ------------------ | | 1467| 0| case 1: freestruct_in_nimloc(source); break; \ | | ------------------ | | | Branch (1467:3): [True: 0, False: 0] | | ------------------ | | 1468| 0| default: break; \ | | ------------------ | | | Branch (1468:3): [True: 0, False: 0] | | ------------------ | | 1469| 0| } \ | | 1470| 0| break; \ | | 1471| 0| case 33: switch (common->rdclass) { \ | | ------------------ | | | Branch (1471:2): [True: 0, False: 536] | | ------------------ | | 1472| 0| case 1: freestruct_in_srv(source); break; \ | | ------------------ | | | Branch (1472:3): [True: 0, False: 0] | | ------------------ | | 1473| 0| default: break; \ | | ------------------ | | | Branch (1473:3): [True: 0, False: 0] | | ------------------ | | 1474| 0| } \ | | 1475| 0| break; \ | | 1476| 0| case 34: switch (common->rdclass) { \ | | ------------------ | | | Branch (1476:2): [True: 0, False: 536] | | ------------------ | | 1477| 0| case 1: freestruct_in_atma(source); break; \ | | ------------------ | | | Branch (1477:3): [True: 0, False: 0] | | ------------------ | | 1478| 0| default: break; \ | | ------------------ | | | Branch (1478:3): [True: 0, False: 0] | | ------------------ | | 1479| 0| } \ | | 1480| 0| break; \ | | 1481| 0| case 35: freestruct_naptr(source); break; \ | | ------------------ | | | Branch (1481:2): [True: 0, False: 536] | | ------------------ | | 1482| 0| case 36: switch (common->rdclass) { \ | | ------------------ | | | Branch (1482:2): [True: 0, False: 536] | | ------------------ | | 1483| 0| case 1: freestruct_in_kx(source); break; \ | | ------------------ | | | Branch (1483:3): [True: 0, False: 0] | | ------------------ | | 1484| 0| default: break; \ | | ------------------ | | | Branch (1484:3): [True: 0, False: 0] | | ------------------ | | 1485| 0| } \ | | 1486| 0| break; \ | | 1487| 0| case 37: freestruct_cert(source); break; \ | | ------------------ | | | Branch (1487:2): [True: 0, False: 536] | | ------------------ | | 1488| 0| case 38: switch (common->rdclass) { \ | | ------------------ | | | Branch (1488:2): [True: 0, False: 536] | | ------------------ | | 1489| 0| case 1: freestruct_in_a6(source); break; \ | | ------------------ | | | Branch (1489:3): [True: 0, False: 0] | | ------------------ | | 1490| 0| default: break; \ | | ------------------ | | | Branch (1490:3): [True: 0, False: 0] | | ------------------ | | 1491| 0| } \ | | 1492| 0| break; \ | | 1493| 0| case 39: freestruct_dname(source); break; \ | | ------------------ | | | Branch (1493:2): [True: 0, False: 536] | | ------------------ | | 1494| 0| case 40: freestruct_sink(source); break; \ | | ------------------ | | | Branch (1494:2): [True: 0, False: 536] | | ------------------ | | 1495| 0| case 41: freestruct_opt(source); break; \ | | ------------------ | | | Branch (1495:2): [True: 0, False: 536] | | ------------------ | | 1496| 0| case 42: switch (common->rdclass) { \ | | ------------------ | | | Branch (1496:2): [True: 0, False: 536] | | ------------------ | | 1497| 0| case 1: freestruct_in_apl(source); break; \ | | ------------------ | | | Branch (1497:3): [True: 0, False: 0] | | ------------------ | | 1498| 0| default: break; \ | | ------------------ | | | Branch (1498:3): [True: 0, False: 0] | | ------------------ | | 1499| 0| } \ | | 1500| 0| break; \ | | 1501| 0| case 43: freestruct_ds(source); break; \ | | ------------------ | | | Branch (1501:2): [True: 0, False: 536] | | ------------------ | | 1502| 0| case 44: freestruct_sshfp(source); break; \ | | ------------------ | | | Branch (1502:2): [True: 0, False: 536] | | ------------------ | | 1503| 0| case 45: freestruct_ipseckey(source); break; \ | | ------------------ | | | Branch (1503:2): [True: 0, False: 536] | | ------------------ | | 1504| 0| case 46: freestruct_rrsig(source); break; \ | | ------------------ | | | Branch (1504:2): [True: 0, False: 536] | | ------------------ | | 1505| 0| case 47: freestruct_nsec(source); break; \ | | ------------------ | | | Branch (1505:2): [True: 0, False: 536] | | ------------------ | | 1506| 0| case 48: freestruct_dnskey(source); break; \ | | ------------------ | | | Branch (1506:2): [True: 0, False: 536] | | ------------------ | | 1507| 0| case 49: switch (common->rdclass) { \ | | ------------------ | | | Branch (1507:2): [True: 0, False: 536] | | ------------------ | | 1508| 0| case 1: freestruct_in_dhcid(source); break; \ | | ------------------ | | | Branch (1508:3): [True: 0, False: 0] | | ------------------ | | 1509| 0| default: break; \ | | ------------------ | | | Branch (1509:3): [True: 0, False: 0] | | ------------------ | | 1510| 0| } \ | | 1511| 0| break; \ | | 1512| 0| case 50: freestruct_nsec3(source); break; \ | | ------------------ | | | Branch (1512:2): [True: 0, False: 536] | | ------------------ | | 1513| 0| case 51: freestruct_nsec3param(source); break; \ | | ------------------ | | | Branch (1513:2): [True: 0, False: 536] | | ------------------ | | 1514| 0| case 52: freestruct_tlsa(source); break; \ | | ------------------ | | | Branch (1514:2): [True: 0, False: 536] | | ------------------ | | 1515| 0| case 53: freestruct_smimea(source); break; \ | | ------------------ | | | Branch (1515:2): [True: 0, False: 536] | | ------------------ | | 1516| 0| case 55: freestruct_hip(source); break; \ | | ------------------ | | | Branch (1516:2): [True: 0, False: 536] | | ------------------ | | 1517| 0| case 56: freestruct_ninfo(source); break; \ | | ------------------ | | | Branch (1517:2): [True: 0, False: 536] | | ------------------ | | 1518| 0| case 57: freestruct_rkey(source); break; \ | | ------------------ | | | Branch (1518:2): [True: 0, False: 536] | | ------------------ | | 1519| 0| case 58: freestruct_talink(source); break; \ | | ------------------ | | | Branch (1519:2): [True: 0, False: 536] | | ------------------ | | 1520| 0| case 59: freestruct_cds(source); break; \ | | ------------------ | | | Branch (1520:2): [True: 0, False: 536] | | ------------------ | | 1521| 0| case 60: freestruct_cdnskey(source); break; \ | | ------------------ | | | Branch (1521:2): [True: 0, False: 536] | | ------------------ | | 1522| 0| case 61: freestruct_openpgpkey(source); break; \ | | ------------------ | | | Branch (1522:2): [True: 0, False: 536] | | ------------------ | | 1523| 0| case 62: freestruct_csync(source); break; \ | | ------------------ | | | Branch (1523:2): [True: 0, False: 536] | | ------------------ | | 1524| 0| case 63: freestruct_zonemd(source); break; \ | | ------------------ | | | Branch (1524:2): [True: 0, False: 536] | | ------------------ | | 1525| 0| case 64: switch (common->rdclass) { \ | | ------------------ | | | Branch (1525:2): [True: 0, False: 536] | | ------------------ | | 1526| 0| case 1: freestruct_in_svcb(source); break; \ | | ------------------ | | | Branch (1526:3): [True: 0, False: 0] | | ------------------ | | 1527| 0| default: break; \ | | ------------------ | | | Branch (1527:3): [True: 0, False: 0] | | ------------------ | | 1528| 0| } \ | | 1529| 0| break; \ | | 1530| 0| case 65: switch (common->rdclass) { \ | | ------------------ | | | Branch (1530:2): [True: 0, False: 536] | | ------------------ | | 1531| 0| case 1: freestruct_in_https(source); break; \ | | ------------------ | | | Branch (1531:3): [True: 0, False: 0] | | ------------------ | | 1532| 0| default: break; \ | | ------------------ | | | Branch (1532:3): [True: 0, False: 0] | | ------------------ | | 1533| 0| } \ | | 1534| 0| break; \ | | 1535| 0| case 66: freestruct_dsync(source); break; \ | | ------------------ | | | Branch (1535:2): [True: 0, False: 536] | | ------------------ | | 1536| 0| case 67: freestruct_hhit(source); break; \ | | ------------------ | | | Branch (1536:2): [True: 0, False: 536] | | ------------------ | | 1537| 0| case 68: freestruct_brid(source); break; \ | | ------------------ | | | Branch (1537:2): [True: 0, False: 536] | | ------------------ | | 1538| 0| case 99: freestruct_spf(source); break; \ | | ------------------ | | | Branch (1538:2): [True: 0, False: 536] | | ------------------ | | 1539| 0| case 104: freestruct_nid(source); break; \ | | ------------------ | | | Branch (1539:2): [True: 0, False: 536] | | ------------------ | | 1540| 0| case 105: freestruct_l32(source); break; \ | | ------------------ | | | Branch (1540:2): [True: 0, False: 536] | | ------------------ | | 1541| 0| case 106: freestruct_l64(source); break; \ | | ------------------ | | | Branch (1541:2): [True: 0, False: 536] | | ------------------ | | 1542| 0| case 107: freestruct_lp(source); break; \ | | ------------------ | | | Branch (1542:2): [True: 0, False: 536] | | ------------------ | | 1543| 0| case 108: freestruct_eui48(source); break; \ | | ------------------ | | | Branch (1543:2): [True: 0, False: 536] | | ------------------ | | 1544| 0| case 109: freestruct_eui64(source); break; \ | | ------------------ | | | Branch (1544:2): [True: 0, False: 536] | | ------------------ | | 1545| 0| case 249: freestruct_tkey(source); break; \ | | ------------------ | | | Branch (1545:2): [True: 0, False: 536] | | ------------------ | | 1546| 0| case 250: switch (common->rdclass) { \ | | ------------------ | | | Branch (1546:2): [True: 0, False: 536] | | ------------------ | | 1547| 0| case 255: freestruct_any_tsig(source); break; \ | | ------------------ | | | Branch (1547:3): [True: 0, False: 0] | | ------------------ | | 1548| 0| default: break; \ | | ------------------ | | | Branch (1548:3): [True: 0, False: 0] | | ------------------ | | 1549| 0| } \ | | 1550| 0| break; \ | | 1551| 0| case 256: freestruct_uri(source); break; \ | | ------------------ | | | Branch (1551:2): [True: 0, False: 536] | | ------------------ | | 1552| 0| case 257: freestruct_caa(source); break; \ | | ------------------ | | | Branch (1552:2): [True: 0, False: 536] | | ------------------ | | 1553| 0| case 258: freestruct_avc(source); break; \ | | ------------------ | | | Branch (1553:2): [True: 0, False: 536] | | ------------------ | | 1554| 0| case 259: freestruct_doa(source); break; \ | | ------------------ | | | Branch (1554:2): [True: 0, False: 536] | | ------------------ | | 1555| 0| case 260: freestruct_amtrelay(source); break; \ | | ------------------ | | | Branch (1555:2): [True: 0, False: 536] | | ------------------ | | 1556| 0| case 261: freestruct_resinfo(source); break; \ | | ------------------ | | | Branch (1556:2): [True: 0, False: 536] | | ------------------ | | 1557| 0| case 262: freestruct_wallet(source); break; \ | | ------------------ | | | Branch (1557:2): [True: 0, False: 536] | | ------------------ | | 1558| 0| case 32768: freestruct_ta(source); break; \ | | ------------------ | | | Branch (1558:2): [True: 0, False: 536] | | ------------------ | | 1559| 0| case 32769: freestruct_dlv(source); break; \ | | ------------------ | | | Branch (1559:2): [True: 0, False: 536] | | ------------------ | | 1560| 0| case 65533: freestruct_keydata(source); break; \ | | ------------------ | | | Branch (1560:2): [True: 0, False: 536] | | ------------------ | | 1561| 0| default: break; \ | | ------------------ | | | Branch (1561:2): [True: 0, False: 536] | | ------------------ | | 1562| 536| } ------------------ 1437| 536|} dns_rdatatype_attributes: 1507| 113|dns_rdatatype_attributes(dns_rdatatype_t type) { 1508| 113| RDATATYPE_ATTRIBUTE_SW ------------------ | | 2467| 113| switch (type) { \ | | ------------------ | | | Branch (2467:10): [True: 113, False: 0] | | ------------------ | | 2468| 0| case 1: return (RRTYPE_A_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_A_ATTRIBUTES (0) | | ------------------ | | | Branch (2468:2): [True: 0, False: 113] | | ------------------ | | 2469| 6| case 2: return (RRTYPE_NS_ATTRIBUTES); \ | | ------------------ | | | | 17| 6|#define RRTYPE_NS_ATTRIBUTES (DNS_RDATATYPEATTR_ZONECUTAUTH) | | ------------------ | | | Branch (2469:2): [True: 6, False: 107] | | ------------------ | | 2470| 0| case 3: return (RRTYPE_MD_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MD_ATTRIBUTES (0) | | ------------------ | | | Branch (2470:2): [True: 0, False: 113] | | ------------------ | | 2471| 0| case 4: return (RRTYPE_MF_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MF_ATTRIBUTES (0) | | ------------------ | | | Branch (2471:2): [True: 0, False: 113] | | ------------------ | | 2472| 0| case 5: return (RRTYPE_CNAME_ATTRIBUTES); \ | | ------------------ | | | | 18| 0| (DNS_RDATATYPEATTR_EXCLUSIVE | DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2472:2): [True: 0, False: 113] | | ------------------ | | 2473| 6| case 6: return (RRTYPE_SOA_ATTRIBUTES); \ | | ------------------ | | | | 17| 6|#define RRTYPE_SOA_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2473:2): [True: 6, False: 107] | | ------------------ | | 2474| 0| case 7: return (RRTYPE_MB_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MB_ATTRIBUTES (0) | | ------------------ | | | Branch (2474:2): [True: 0, False: 113] | | ------------------ | | 2475| 0| case 8: return (RRTYPE_MG_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MG_ATTRIBUTES (0) | | ------------------ | | | Branch (2475:2): [True: 0, False: 113] | | ------------------ | | 2476| 0| case 9: return (RRTYPE_MR_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MR_ATTRIBUTES (0) | | ------------------ | | | Branch (2476:2): [True: 0, False: 113] | | ------------------ | | 2477| 0| case 10: return (RRTYPE_NULL_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_NULL_ATTRIBUTES (0) | | ------------------ | | | Branch (2477:2): [True: 0, False: 113] | | ------------------ | | 2478| 0| case 11: return (RRTYPE_WKS_ATTRIBUTES); \ | | ------------------ | | | | 24| 0|#define RRTYPE_WKS_ATTRIBUTES (0) | | ------------------ | | | Branch (2478:2): [True: 0, False: 113] | | ------------------ | | 2479| 0| case 12: return (RRTYPE_PTR_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_PTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2479:2): [True: 0, False: 113] | | ------------------ | | 2480| 0| case 13: return (RRTYPE_HINFO_ATTRIBUTES); \ | | ------------------ | | | | 16| 0|#define RRTYPE_HINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2480:2): [True: 0, False: 113] | | ------------------ | | 2481| 0| case 14: return (RRTYPE_MINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2481:2): [True: 0, False: 113] | | ------------------ | | 2482| 0| case 15: return (RRTYPE_MX_ATTRIBUTES); \ | | ------------------ | | | | 23| 0|#define RRTYPE_MX_ATTRIBUTES (0) | | ------------------ | | | Branch (2482:2): [True: 0, False: 113] | | ------------------ | | 2483| 0| case 16: return (RRTYPE_TXT_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_TXT_ATTRIBUTES (0) | | ------------------ | | | Branch (2483:2): [True: 0, False: 113] | | ------------------ | | 2484| 0| case 17: return (RRTYPE_RP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_RP_ATTRIBUTES (0) | | ------------------ | | | Branch (2484:2): [True: 0, False: 113] | | ------------------ | | 2485| 0| case 18: return (RRTYPE_AFSDB_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_AFSDB_ATTRIBUTES (0) | | ------------------ | | | Branch (2485:2): [True: 0, False: 113] | | ------------------ | | 2486| 0| case 19: return (RRTYPE_X25_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_X25_ATTRIBUTES (0) | | ------------------ | | | Branch (2486:2): [True: 0, False: 113] | | ------------------ | | 2487| 0| case 20: return (RRTYPE_ISDN_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ISDN_ATTRIBUTES (0) | | ------------------ | | | Branch (2487:2): [True: 0, False: 113] | | ------------------ | | 2488| 0| case 21: return (RRTYPE_RT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_RT_ATTRIBUTES (0) | | ------------------ | | | Branch (2488:2): [True: 0, False: 113] | | ------------------ | | 2489| 0| case 22: return (RRTYPE_NSAP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NSAP_ATTRIBUTES (0) | | ------------------ | | | Branch (2489:2): [True: 0, False: 113] | | ------------------ | | 2490| 0| case 23: return (RRTYPE_NSAP_PTR_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NSAP_PTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2490:2): [True: 0, False: 113] | | ------------------ | | 2491| 95| case 24: return (RRTYPE_SIG_ATTRIBUTES); \ | | ------------------ | | | | 19| 95|#define RRTYPE_SIG_ATTRIBUTES (0) | | ------------------ | | | Branch (2491:2): [True: 95, False: 18] | | ------------------ | | 2492| 6| case 25: return (RRTYPE_KEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 6|#define RRTYPE_KEY_ATTRIBUTES (0) | | ------------------ | | | Branch (2492:2): [True: 6, False: 107] | | ------------------ | | 2493| 0| case 26: return (RRTYPE_PX_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_PX_ATTRIBUTES (0) | | ------------------ | | | Branch (2493:2): [True: 0, False: 113] | | ------------------ | | 2494| 0| case 27: return (RRTYPE_GPOS_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_GPOS_ATTRIBUTES (0) | | ------------------ | | | Branch (2494:2): [True: 0, False: 113] | | ------------------ | | 2495| 0| case 28: return (RRTYPE_AAAA_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_AAAA_ATTRIBUTES (0) | | ------------------ | | | Branch (2495:2): [True: 0, False: 113] | | ------------------ | | 2496| 0| case 29: return (RRTYPE_LOC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_LOC_ATTRIBUTES (0) | | ------------------ | | | Branch (2496:2): [True: 0, False: 113] | | ------------------ | | 2497| 0| case 30: return (RRTYPE_NXT_ATTRIBUTES); \ | | ------------------ | | | | 23| 0|#define RRTYPE_NXT_ATTRIBUTES (0) | | ------------------ | | | Branch (2497:2): [True: 0, False: 113] | | ------------------ | | 2498| 0| case 31: return (RRTYPE_EID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EID_ATTRIBUTES (0) | | ------------------ | | | Branch (2498:2): [True: 0, False: 113] | | ------------------ | | 2499| 0| case 32: return (RRTYPE_NIMLOC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NIMLOC_ATTRIBUTES (0) | | ------------------ | | | Branch (2499:2): [True: 0, False: 113] | | ------------------ | | 2500| 0| case 33: return (RRTYPE_SRV_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SRV_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2500:2): [True: 0, False: 113] | | ------------------ | | 2501| 0| case 34: return (RRTYPE_ATMA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ATMA_ATTRIBUTES (0) | | ------------------ | | | Branch (2501:2): [True: 0, False: 113] | | ------------------ | | 2502| 0| case 35: return (RRTYPE_NAPTR_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NAPTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2502:2): [True: 0, False: 113] | | ------------------ | | 2503| 0| case 36: return (RRTYPE_KX_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_KX_ATTRIBUTES (0) | | ------------------ | | | Branch (2503:2): [True: 0, False: 113] | | ------------------ | | 2504| 0| case 37: return (RRTYPE_CERT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CERT_ATTRIBUTES (0) | | ------------------ | | | Branch (2504:2): [True: 0, False: 113] | | ------------------ | | 2505| 0| case 38: return (RRTYPE_A6_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_A6_ATTRIBUTES (0) | | ------------------ | | | Branch (2505:2): [True: 0, False: 113] | | ------------------ | | 2506| 0| case 39: return (RRTYPE_DNAME_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DNAME_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2506:2): [True: 0, False: 113] | | ------------------ | | 2507| 0| case 40: return (RRTYPE_SINK_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SINK_ATTRIBUTES (0) | | ------------------ | | | Branch (2507:2): [True: 0, False: 113] | | ------------------ | | 2508| 0| case 41: return (RRTYPE_OPT_ATTRIBUTES); \ | | ------------------ | | | | 20| 0| (DNS_RDATATYPEATTR_SINGLETON | DNS_RDATATYPEATTR_META | \ | | | | 21| 0| DNS_RDATATYPEATTR_NOTQUESTION) | | ------------------ | | | Branch (2508:2): [True: 0, False: 113] | | ------------------ | | 2509| 0| case 42: return (RRTYPE_APL_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_APL_ATTRIBUTES (0) | | ------------------ | | | Branch (2509:2): [True: 0, False: 113] | | ------------------ | | 2510| 0| case 43: return (RRTYPE_DS_ATTRIBUTES); \ | | ------------------ | | | | 20| 0| (DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \ | | | | 21| 0| DNS_RDATATYPEATTR_ATPARENT) | | ------------------ | | | Branch (2510:2): [True: 0, False: 113] | | ------------------ | | 2511| 0| case 44: return (RRTYPE_SSHFP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SSHFP_ATTRIBUTES (0) | | ------------------ | | | Branch (2511:2): [True: 0, False: 113] | | ------------------ | | 2512| 0| case 45: return (RRTYPE_IPSECKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_IPSECKEY_ATTRIBUTES (0) | | ------------------ | | | Branch (2512:2): [True: 0, False: 113] | | ------------------ | | 2513| 0| case 46: return (RRTYPE_RRSIG_ATTRIBUTES); \ | | ------------------ | | | | 20| 0| (DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \ | | | | 21| 0| DNS_RDATATYPEATTR_ATCNAME) | | ------------------ | | | Branch (2513:2): [True: 0, False: 113] | | ------------------ | | 2514| 0| case 47: return (RRTYPE_NSEC_ATTRIBUTES); \ | | ------------------ | | | | 24| 0| (DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \ | | | | 25| 0| DNS_RDATATYPEATTR_ATCNAME) | | ------------------ | | | Branch (2514:2): [True: 0, False: 113] | | ------------------ | | 2515| 0| case 48: return (RRTYPE_DNSKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_DNSKEY_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC) | | ------------------ | | | Branch (2515:2): [True: 0, False: 113] | | ------------------ | | 2516| 0| case 49: return (RRTYPE_DHCID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DHCID_ATTRIBUTES 0 | | ------------------ | | | Branch (2516:2): [True: 0, False: 113] | | ------------------ | | 2517| 0| case 50: return (RRTYPE_NSEC3_ATTRIBUTES); \ | | ------------------ | | | | 40| 0|#define RRTYPE_NSEC3_ATTRIBUTES DNS_RDATATYPEATTR_DNSSEC | | ------------------ | | | Branch (2517:2): [True: 0, False: 113] | | ------------------ | | 2518| 0| case 51: return (RRTYPE_NSEC3PARAM_ATTRIBUTES); \ | | ------------------ | | | | 38| 0|#define RRTYPE_NSEC3PARAM_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC) | | ------------------ | | | Branch (2518:2): [True: 0, False: 113] | | ------------------ | | 2519| 0| case 52: return (RRTYPE_TLSA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TLSA_ATTRIBUTES 0 | | ------------------ | | | Branch (2519:2): [True: 0, False: 113] | | ------------------ | | 2520| 0| case 53: return (RRTYPE_SMIMEA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_SMIMEA_ATTRIBUTES 0 | | ------------------ | | | Branch (2520:2): [True: 0, False: 113] | | ------------------ | | 2521| 0| case 55: return (RRTYPE_HIP_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_HIP_ATTRIBUTES (0) | | ------------------ | | | Branch (2521:2): [True: 0, False: 113] | | ------------------ | | 2522| 0| case 56: return (RRTYPE_NINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_NINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2522:2): [True: 0, False: 113] | | ------------------ | | 2523| 0| case 57: return (RRTYPE_RKEY_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_RKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2523:2): [True: 0, False: 113] | | ------------------ | | 2524| 0| case 58: return (RRTYPE_TALINK_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_TALINK_ATTRIBUTES 0 | | ------------------ | | | Branch (2524:2): [True: 0, False: 113] | | ------------------ | | 2525| 0| case 59: return (RRTYPE_CDS_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CDS_ATTRIBUTES 0 | | ------------------ | | | Branch (2525:2): [True: 0, False: 113] | | ------------------ | | 2526| 0| case 60: return (RRTYPE_CDNSKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_CDNSKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2526:2): [True: 0, False: 113] | | ------------------ | | 2527| 0| case 61: return (RRTYPE_OPENPGPKEY_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_OPENPGPKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2527:2): [True: 0, False: 113] | | ------------------ | | 2528| 0| case 62: return (RRTYPE_CSYNC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CSYNC_ATTRIBUTES 0 | | ------------------ | | | Branch (2528:2): [True: 0, False: 113] | | ------------------ | | 2529| 0| case 63: return (RRTYPE_ZONEMD_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ZONEMD_ATTRIBUTES 0 | | ------------------ | | | Branch (2529:2): [True: 0, False: 113] | | ------------------ | | 2530| 0| case 64: return (RRTYPE_SVCB_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SVCB_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2530:2): [True: 0, False: 113] | | ------------------ | | 2531| 0| case 65: return (RRTYPE_HTTPS_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_HTTPS_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2531:2): [True: 0, False: 113] | | ------------------ | | 2532| 0| case 66: return (RRTYPE_DSYNC_ATTRIBUTES); \ | | ------------------ | | | | 24| 0|#define RRTYPE_DSYNC_ATTRIBUTES (0) | | ------------------ | | | Branch (2532:2): [True: 0, False: 113] | | ------------------ | | 2533| 0| case 67: return (RRTYPE_HHIT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_HHIT_ATTRIBUTES (0) | | ------------------ | | | Branch (2533:2): [True: 0, False: 113] | | ------------------ | | 2534| 0| case 68: return (RRTYPE_BRID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_BRID_ATTRIBUTES (0) | | ------------------ | | | Branch (2534:2): [True: 0, False: 113] | | ------------------ | | 2535| 0| case 99: return (RRTYPE_SPF_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_SPF_ATTRIBUTES (0) | | ------------------ | | | Branch (2535:2): [True: 0, False: 113] | | ------------------ | | 2536| 0| case 100: return (0); \ | | ------------------ | | | Branch (2536:2): [True: 0, False: 113] | | ------------------ | | 2537| 0| case 101: return (0); \ | | ------------------ | | | Branch (2537:2): [True: 0, False: 113] | | ------------------ | | 2538| 0| case 102: return (0); \ | | ------------------ | | | Branch (2538:2): [True: 0, False: 113] | | ------------------ | | 2539| 0| case 103: return (0); \ | | ------------------ | | | Branch (2539:2): [True: 0, False: 113] | | ------------------ | | 2540| 0| case 104: return (RRTYPE_NID_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_NID_ATTRIBUTES (0) | | ------------------ | | | Branch (2540:2): [True: 0, False: 113] | | ------------------ | | 2541| 0| case 105: return (RRTYPE_L32_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_L32_ATTRIBUTES (0) | | ------------------ | | | Branch (2541:2): [True: 0, False: 113] | | ------------------ | | 2542| 0| case 106: return (RRTYPE_L64_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_L64_ATTRIBUTES (0) | | ------------------ | | | Branch (2542:2): [True: 0, False: 113] | | ------------------ | | 2543| 0| case 107: return (RRTYPE_LP_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_LP_ATTRIBUTES (0) | | ------------------ | | | Branch (2543:2): [True: 0, False: 113] | | ------------------ | | 2544| 0| case 108: return (RRTYPE_EUI48_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EUI48_ATTRIBUTES (0) | | ------------------ | | | Branch (2544:2): [True: 0, False: 113] | | ------------------ | | 2545| 0| case 109: return (RRTYPE_EUI64_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EUI64_ATTRIBUTES (0) | | ------------------ | | | Branch (2545:2): [True: 0, False: 113] | | ------------------ | | 2546| 0| case 249: return (RRTYPE_TKEY_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TKEY_ATTRIBUTES (DNS_RDATATYPEATTR_META) | | ------------------ | | | Branch (2546:2): [True: 0, False: 113] | | ------------------ | | 2547| 0| case 250: return (RRTYPE_TSIG_ATTRIBUTES); \ | | ------------------ | | | | 18| 0| (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_NOTQUESTION) | | ------------------ | | | Branch (2547:2): [True: 0, False: 113] | | ------------------ | | 2548| 0| case 251: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2548:2): [True: 0, False: 113] | | ------------------ | | 2549| 0| case 252: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2549:2): [True: 0, False: 113] | | ------------------ | | 2550| 0| case 253: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2550:2): [True: 0, False: 113] | | ------------------ | | 2551| 0| case 254: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2551:2): [True: 0, False: 113] | | ------------------ | | 2552| 0| case 255: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2552:2): [True: 0, False: 113] | | ------------------ | | 2553| 0| case 256: return (RRTYPE_URI_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_URI_ATTRIBUTES (0) | | ------------------ | | | Branch (2553:2): [True: 0, False: 113] | | ------------------ | | 2554| 0| case 257: return (RRTYPE_CAA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_CAA_ATTRIBUTES (0) | | ------------------ | | | Branch (2554:2): [True: 0, False: 113] | | ------------------ | | 2555| 0| case 258: return (RRTYPE_AVC_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_AVC_ATTRIBUTES (0) | | ------------------ | | | Branch (2555:2): [True: 0, False: 113] | | ------------------ | | 2556| 0| case 259: return (RRTYPE_DOA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_DOA_ATTRIBUTES (0) | | ------------------ | | | Branch (2556:2): [True: 0, False: 113] | | ------------------ | | 2557| 0| case 260: return (RRTYPE_AMTRELAY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_AMTRELAY_ATTRIBUTES (0) | | ------------------ | | | Branch (2557:2): [True: 0, False: 113] | | ------------------ | | 2558| 0| case 261: return (RRTYPE_RESINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_RESINFO_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2558:2): [True: 0, False: 113] | | ------------------ | | 2559| 0| case 262: return (RRTYPE_WALLET_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_WALLET_ATTRIBUTES (0) | | ------------------ | | | Branch (2559:2): [True: 0, False: 113] | | ------------------ | | 2560| 0| case 32768: return (RRTYPE_TA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TA_ATTRIBUTES 0 | | ------------------ | | | Branch (2560:2): [True: 0, False: 113] | | ------------------ | | 2561| 0| case 32769: return (RRTYPE_DLV_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DLV_ATTRIBUTES 0 | | ------------------ | | | Branch (2561:2): [True: 0, False: 113] | | ------------------ | | 2562| 0| case 65533: return (RRTYPE_KEYDATA_ATTRIBUTES); \ | | ------------------ | | | | 22| 0|#define RRTYPE_KEYDATA_ATTRIBUTES (0) | | ------------------ | | | Branch (2562:2): [True: 0, False: 113] | | ------------------ | | 2563| 113| } ------------------ 1509| 0| if (type >= (dns_rdatatype_t)128 && type <= (dns_rdatatype_t)255) { ------------------ | Branch (1509:6): [True: 0, False: 0] | Branch (1509:38): [True: 0, False: 0] ------------------ 1510| 0| return DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META; 1511| 0| } 1512| 0| return DNS_RDATATYPEATTR_UNKNOWN; 1513| 0|} dns_rdatatype_fromtext: 1516| 6|dns_rdatatype_fromtext(dns_rdatatype_t *typep, isc_textregion_t *source) { 1517| 6| unsigned int hash; 1518| 6| unsigned int n; 1519| 6| unsigned char a, b; 1520| | 1521| 6| n = source->length; 1522| | 1523| 6| if (n == 0) { ------------------ | Branch (1523:6): [True: 0, False: 6] ------------------ 1524| 0| return DNS_R_UNKNOWN; 1525| 0| } 1526| | 1527| 6| a = isc_ascii_tolower(source->base[0]); ------------------ | | 31| 6|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 1528| 6| b = isc_ascii_tolower(source->base[n - 1]); ------------------ | | 31| 6|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 1529| | 1530| 6| hash = ((a + n) * b) % 256; 1531| | 1532| | /* 1533| | * This switch block is inlined via \#define, and will use "return" 1534| | * to return a result to the caller if it is a valid (known) 1535| | * rdatatype name. 1536| | */ 1537| 6| RDATATYPE_FROMTEXT_SW(hash, source->base, n, typep); ------------------ | | 2219| 6| switch (_hash) { \ | | ------------------ | | | Branch (2219:10): [True: 6, False: 0] | | ------------------ | | 2220| 0| case 34: \ | | ------------------ | | | Branch (2220:3): [True: 0, False: 6] | | ------------------ | | 2221| 0| RDATATYPE_COMPARE("a", 1, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2222| 0| break; \ | | 2223| 2| case 80: \ | | ------------------ | | | Branch (2223:3): [True: 2, False: 4] | | ------------------ | | 2224| 2| RDATATYPE_COMPARE("ns", 2, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 2| do { \ | | | | 2209| 2| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 2, False: 0] | | | | ------------------ | | | | 2210| 2| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 2, False: 0] | | | | ------------------ | | | | 2211| 2| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 2] | | | | ------------------ | | | | 2212| 2| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 2| *(_tp) = _d; \ | | | | 2214| 2| return (ISC_R_SUCCESS); \ | | | | 2215| 2| } \ | | | | 2216| 2| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2225| 2| break; \ | | 2226| 2| case 92: \ | | ------------------ | | | Branch (2226:3): [True: 0, False: 6] | | ------------------ | | 2227| 0| RDATATYPE_COMPARE("md", 3, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2228| 0| break; \ | | 2229| 0| case 58: \ | | ------------------ | | | Branch (2229:3): [True: 0, False: 6] | | ------------------ | | 2230| 0| RDATATYPE_COMPARE("mf", 4, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2231| 0| break; \ | | 2232| 0| case 8: \ | | ------------------ | | | Branch (2232:3): [True: 0, False: 6] | | ------------------ | | 2233| 0| RDATATYPE_COMPARE("cname", 5, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2234| 0| RDATATYPE_COMPARE("mx", 15, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2235| 0| break; \ | | 2236| 2| case 182: \ | | ------------------ | | | Branch (2236:3): [True: 2, False: 4] | | ------------------ | | 2237| 2| RDATATYPE_COMPARE("soa", 6, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 2| do { \ | | | | 2209| 2| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 2, False: 0] | | | | ------------------ | | | | 2210| 2| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 2, False: 0] | | | | ------------------ | | | | 2211| 2| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 2] | | | | ------------------ | | | | 2212| 2| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 2| *(_tp) = _d; \ | | | | 2214| 2| return (ISC_R_SUCCESS); \ | | | | 2215| 2| } \ | | | | 2216| 2| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2238| 2| RDATATYPE_COMPARE("ta", 32768, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2239| 0| break; \ | | 2240| 0| case 126: \ | | ------------------ | | | Branch (2240:3): [True: 0, False: 6] | | ------------------ | | 2241| 0| RDATATYPE_COMPARE("mb", 7, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2242| 0| break; \ | | 2243| 0| case 169: \ | | ------------------ | | | Branch (2243:3): [True: 0, False: 6] | | ------------------ | | 2244| 0| RDATATYPE_COMPARE("mg", 8, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2245| 0| break; \ | | 2246| 0| case 110: \ | | ------------------ | | | Branch (2246:3): [True: 0, False: 6] | | ------------------ | | 2247| 0| RDATATYPE_COMPARE("mr", 9, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2248| 0| RDATATYPE_COMPARE("minfo", 14, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2249| 0| break; \ | | 2250| 0| case 24: \ | | ------------------ | | | Branch (2250:3): [True: 0, False: 6] | | ------------------ | | 2251| 0| RDATATYPE_COMPARE("null", 10, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2252| 0| RDATATYPE_COMPARE("kx", 36, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2253| 0| RDATATYPE_COMPARE("nsec3param", 51, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2254| 0| break; \ | | 2255| 0| case 206: \ | | ------------------ | | | Branch (2255:3): [True: 0, False: 6] | | ------------------ | | 2256| 0| RDATATYPE_COMPARE("wks", 11, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2257| 0| break; \ | | 2258| 0| case 54: \ | | ------------------ | | | Branch (2258:3): [True: 0, False: 6] | | ------------------ | | 2259| 0| RDATATYPE_COMPARE("ptr", 12, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2260| 0| RDATATYPE_COMPARE("naptr", 35, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2261| 0| break; \ | | 2262| 0| case 67: \ | | ------------------ | | | Branch (2262:3): [True: 0, False: 6] | | ------------------ | | 2263| 0| RDATATYPE_COMPARE("hinfo", 13, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2264| 0| break; \ | | 2265| 0| case 236: \ | | ------------------ | | | Branch (2265:3): [True: 0, False: 6] | | ------------------ | | 2266| 0| RDATATYPE_COMPARE("txt", 16, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2267| 0| break; \ | | 2268| 0| case 192: \ | | ------------------ | | | Branch (2268:3): [True: 0, False: 6] | | ------------------ | | 2269| 0| RDATATYPE_COMPARE("rp", 17, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2270| 0| break; \ | | 2271| 0| case 12: \ | | ------------------ | | | Branch (2271:3): [True: 0, False: 6] | | ------------------ | | 2272| 0| RDATATYPE_COMPARE("afsdb", 18, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2273| 0| break; \ | | 2274| 0| case 119: \ | | ------------------ | | | Branch (2274:3): [True: 0, False: 6] | | ------------------ | | 2275| 0| RDATATYPE_COMPARE("x25", 19, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2276| 0| RDATATYPE_COMPARE("resinfo", 261, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2277| 0| break; \ | | 2278| 0| case 214: \ | | ------------------ | | | Branch (2278:3): [True: 0, False: 6] | | ------------------ | | 2279| 0| RDATATYPE_COMPARE("isdn", 20, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2280| 0| break; \ | | 2281| 0| case 144: \ | | ------------------ | | | Branch (2281:3): [True: 0, False: 6] | | ------------------ | | 2282| 0| RDATATYPE_COMPARE("rt", 21, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2283| 0| break; \ | | 2284| 0| case 224: \ | | ------------------ | | | Branch (2284:3): [True: 0, False: 6] | | ------------------ | | 2285| 0| RDATATYPE_COMPARE("nsap", 22, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2286| 0| RDATATYPE_COMPARE("uid", 101, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2287| 0| break; \ | | 2288| 0| case 140: \ | | ------------------ | | | Branch (2288:3): [True: 0, False: 6] | | ------------------ | | 2289| 0| RDATATYPE_COMPARE("nsap-ptr", 23, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2290| 0| RDATATYPE_COMPARE("l64", 106, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2291| 0| break; \ | | 2292| 0| case 122: \ | | ------------------ | | | Branch (2292:3): [True: 0, False: 6] | | ------------------ | | 2293| 0| RDATATYPE_COMPARE("sig", 24, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2294| 0| RDATATYPE_COMPARE("dlv", 32769, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2295| 0| break; \ | | 2296| 2| case 254: \ | | ------------------ | | | Branch (2296:3): [True: 2, False: 4] | | ------------------ | | 2297| 2| RDATATYPE_COMPARE("key", 25, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 2| do { \ | | | | 2209| 2| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 2, False: 0] | | | | ------------------ | | | | 2210| 2| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 2, False: 0] | | | | ------------------ | | | | 2211| 2| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 2] | | | | ------------------ | | | | 2212| 2| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 2| *(_tp) = _d; \ | | | | 2214| 2| return (ISC_R_SUCCESS); \ | | | | 2215| 2| } \ | | | | 2216| 2| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2298| 2| RDATATYPE_COMPARE("talink", 58, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2299| 0| break; \ | | 2300| 0| case 112: \ | | ------------------ | | | Branch (2300:3): [True: 0, False: 6] | | ------------------ | | 2301| 0| RDATATYPE_COMPARE("px", 26, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2302| 0| break; \ | | 2303| 0| case 17: \ | | ------------------ | | | Branch (2303:3): [True: 0, False: 6] | | ------------------ | | 2304| 0| RDATATYPE_COMPARE("gpos", 27, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2305| 0| break; \ | | 2306| 0| case 69: \ | | ------------------ | | | Branch (2306:3): [True: 0, False: 6] | | ------------------ | | 2307| 0| RDATATYPE_COMPARE("aaaa", 28, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2308| 0| RDATATYPE_COMPARE("atma", 34, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2309| 0| break; \ | | 2310| 0| case 237: \ | | ------------------ | | | Branch (2310:3): [True: 0, False: 6] | | ------------------ | | 2311| 0| RDATATYPE_COMPARE("loc", 29, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2312| 0| break; \ | | 2313| 0| case 52: \ | | ------------------ | | | Branch (2313:3): [True: 0, False: 6] | | ------------------ | | 2314| 0| RDATATYPE_COMPARE("nxt", 30, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2315| 0| break; \ | | 2316| 0| case 160: \ | | ------------------ | | | Branch (2316:3): [True: 0, False: 6] | | ------------------ | | 2317| 0| RDATATYPE_COMPARE("eid", 31, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2318| 0| break; \ | | 2319| 0| case 220: \ | | ------------------ | | | Branch (2319:3): [True: 0, False: 6] | | ------------------ | | 2320| 0| RDATATYPE_COMPARE("nimloc", 32, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2321| 0| break; \ | | 2322| 0| case 100: \ | | ------------------ | | | Branch (2322:3): [True: 0, False: 6] | | ------------------ | | 2323| 0| RDATATYPE_COMPARE("srv", 33, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2324| 0| break; \ | | 2325| 0| case 172: \ | | ------------------ | | | Branch (2325:3): [True: 0, False: 6] | | ------------------ | | 2326| 0| RDATATYPE_COMPARE("cert", 37, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2327| 0| RDATATYPE_COMPARE("avc", 258, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2328| 0| break; \ | | 2329| 0| case 226: \ | | ------------------ | | | Branch (2329:3): [True: 0, False: 6] | | ------------------ | | 2330| 0| RDATATYPE_COMPARE("a6", 38, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2331| 0| break; \ | | 2332| 0| case 109: \ | | ------------------ | | | Branch (2332:3): [True: 0, False: 6] | | ------------------ | | 2333| 0| RDATATYPE_COMPARE("dname", 39, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2334| 0| break; \ | | 2335| 0| case 189: \ | | ------------------ | | | Branch (2335:3): [True: 0, False: 6] | | ------------------ | | 2336| 0| RDATATYPE_COMPARE("sink", 40, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2337| 0| break; \ | | 2338| 0| case 168: \ | | ------------------ | | | Branch (2338:3): [True: 0, False: 6] | | ------------------ | | 2339| 0| RDATATYPE_COMPARE("opt", 41, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2340| 0| break; \ | | 2341| 0| case 48: \ | | ------------------ | | | Branch (2341:3): [True: 0, False: 6] | | ------------------ | | 2342| 0| RDATATYPE_COMPARE("apl", 42, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2343| 0| RDATATYPE_COMPARE("eui48", 108, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2344| 0| break; \ | | 2345| 0| case 210: \ | | ------------------ | | | Branch (2345:3): [True: 0, False: 6] | | ------------------ | | 2346| 0| RDATATYPE_COMPARE("ds", 43, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2347| 0| RDATATYPE_COMPARE("cds", 59, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2348| 0| break; \ | | 2349| 0| case 128: \ | | ------------------ | | | Branch (2349:3): [True: 0, False: 6] | | ------------------ | | 2350| 0| RDATATYPE_COMPARE("sshfp", 44, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2351| 0| break; \ | | 2352| 0| case 105: \ | | ------------------ | | | Branch (2352:3): [True: 0, False: 6] | | ------------------ | | 2353| 0| RDATATYPE_COMPARE("ipseckey", 45, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2354| 0| break; \ | | 2355| 0| case 225: \ | | ------------------ | | | Branch (2355:3): [True: 0, False: 6] | | ------------------ | | 2356| 0| RDATATYPE_COMPARE("rrsig", 46, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2357| 0| break; \ | | 2358| 0| case 22: \ | | ------------------ | | | Branch (2358:3): [True: 0, False: 6] | | ------------------ | | 2359| 0| RDATATYPE_COMPARE("nsec", 47, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2360| 0| break; \ | | 2361| 0| case 26: \ | | ------------------ | | | Branch (2361:3): [True: 0, False: 6] | | ------------------ | | 2362| 0| RDATATYPE_COMPARE("dnskey", 48, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2363| 0| RDATATYPE_COMPARE("cdnskey", 60, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2364| 0| break; \ | | 2365| 0| case 4: \ | | ------------------ | | | Branch (2365:3): [True: 0, False: 6] | | ------------------ | | 2366| 0| RDATATYPE_COMPARE("dhcid", 49, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2367| 0| RDATATYPE_COMPARE("spf", 99, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2368| 0| break; \ | | 2369| 0| case 233: \ | | ------------------ | | | Branch (2369:3): [True: 0, False: 6] | | ------------------ | | 2370| 0| RDATATYPE_COMPARE("nsec3", 50, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2371| 0| break; \ | | 2372| 0| case 120: \ | | ------------------ | | | Branch (2372:3): [True: 0, False: 6] | | ------------------ | | 2373| 0| RDATATYPE_COMPARE("tlsa", 52, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2374| 0| break; \ | | 2375| 0| case 217: \ | | ------------------ | | | Branch (2375:3): [True: 0, False: 6] | | ------------------ | | 2376| 0| RDATATYPE_COMPARE("smimea", 53, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2377| 0| break; \ | | 2378| 0| case 208: \ | | ------------------ | | | Branch (2378:3): [True: 0, False: 6] | | ------------------ | | 2379| 0| RDATATYPE_COMPARE("hip", 55, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2380| 0| break; \ | | 2381| 0| case 221: \ | | ------------------ | | | Branch (2381:3): [True: 0, False: 6] | | ------------------ | | 2382| 0| RDATATYPE_COMPARE("ninfo", 56, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2383| 0| break; \ | | 2384| 0| case 198: \ | | ------------------ | | | Branch (2384:3): [True: 0, False: 6] | | ------------------ | | 2385| 0| RDATATYPE_COMPARE("rkey", 57, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2386| 0| break; \ | | 2387| 0| case 49: \ | | ------------------ | | | Branch (2387:3): [True: 0, False: 6] | | ------------------ | | 2388| 0| RDATATYPE_COMPARE("openpgpkey", 61, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2389| 0| break; \ | | 2390| 0| case 56: \ | | ------------------ | | | Branch (2390:3): [True: 0, False: 6] | | ------------------ | | 2391| 0| RDATATYPE_COMPARE("csync", 62, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2392| 0| RDATATYPE_COMPARE("uri", 256, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2393| 0| break; \ | | 2394| 0| case 0: \ | | ------------------ | | | Branch (2394:3): [True: 0, False: 6] | | ------------------ | | 2395| 0| RDATATYPE_COMPARE("zonemd", 63, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2396| 0| break; \ | | 2397| 0| case 142: \ | | ------------------ | | | Branch (2397:3): [True: 0, False: 6] | | ------------------ | | 2398| 0| RDATATYPE_COMPARE("svcb", 64, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2399| 0| break; \ | | 2400| 0| case 247: \ | | ------------------ | | | Branch (2400:3): [True: 0, False: 6] | | ------------------ | | 2401| 0| RDATATYPE_COMPARE("https", 65, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2402| 0| break; \ | | 2403| 0| case 155: \ | | ------------------ | | | Branch (2403:3): [True: 0, False: 6] | | ------------------ | | 2404| 0| RDATATYPE_COMPARE("dsync", 66, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2405| 0| break; \ | | 2406| 0| case 240: \ | | ------------------ | | | Branch (2406:3): [True: 0, False: 6] | | ------------------ | | 2407| 0| RDATATYPE_COMPARE("hhit", 67, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2408| 0| break; \ | | 2409| 0| case 216: \ | | ------------------ | | | Branch (2409:3): [True: 0, False: 6] | | ------------------ | | 2410| 0| RDATATYPE_COMPARE("brid", 68, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2411| 0| break; \ | | 2412| 0| case 230: \ | | ------------------ | | | Branch (2412:3): [True: 0, False: 6] | | ------------------ | | 2413| 0| RDATATYPE_COMPARE("uinfo", 100, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2414| 0| break; \ | | 2415| 0| case 104: \ | | ------------------ | | | Branch (2415:3): [True: 0, False: 6] | | ------------------ | | 2416| 0| RDATATYPE_COMPARE("gid", 102, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2417| 0| break; \ | | 2418| 0| case 145: \ | | ------------------ | | | Branch (2418:3): [True: 0, False: 6] | | ------------------ | | 2419| 0| RDATATYPE_COMPARE("unspec", 103, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2420| 0| break; \ | | 2421| 0| case 36: \ | | ------------------ | | | Branch (2421:3): [True: 0, False: 6] | | ------------------ | | 2422| 0| RDATATYPE_COMPARE("nid", 104, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2423| 0| break; \ | | 2424| 0| case 174: \ | | ------------------ | | | Branch (2424:3): [True: 0, False: 6] | | ------------------ | | 2425| 0| RDATATYPE_COMPARE("l32", 105, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2426| 0| break; \ | | 2427| 0| case 32: \ | | ------------------ | | | Branch (2427:3): [True: 0, False: 6] | | ------------------ | | 2428| 0| RDATATYPE_COMPARE("lp", 107, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2429| 0| break; \ | | 2430| 0| case 136: \ | | ------------------ | | | Branch (2430:3): [True: 0, False: 6] | | ------------------ | | 2431| 0| RDATATYPE_COMPARE("eui64", 109, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2432| 0| break; \ | | 2433| 0| case 184: \ | | ------------------ | | | Branch (2433:3): [True: 0, False: 6] | | ------------------ | | 2434| 0| RDATATYPE_COMPARE("tkey", 249, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2435| 0| break; \ | | 2436| 0| case 72: \ | | ------------------ | | | Branch (2436:3): [True: 0, False: 6] | | ------------------ | | 2437| 0| RDATATYPE_COMPARE("tsig", 250, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2438| 0| break; \ | | 2439| 0| case 138: \ | | ------------------ | | | Branch (2439:3): [True: 0, False: 6] | | ------------------ | | 2440| 0| RDATATYPE_COMPARE("ixfr", 251, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2441| 0| break; \ | | 2442| 0| case 250: \ | | ------------------ | | | Branch (2442:3): [True: 0, False: 6] | | ------------------ | | 2443| 0| RDATATYPE_COMPARE("axfr", 252, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2444| 0| break; \ | | 2445| 0| case 164: \ | | ------------------ | | | Branch (2445:3): [True: 0, False: 6] | | ------------------ | | 2446| 0| RDATATYPE_COMPARE("mailb", 253, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2447| 0| RDATATYPE_COMPARE("wallet", 262, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2448| 0| break; \ | | 2449| 0| case 50: \ | | ------------------ | | | Branch (2449:3): [True: 0, False: 6] | | ------------------ | | 2450| 0| RDATATYPE_COMPARE("maila", 254, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2451| 0| RDATATYPE_COMPARE("keydata", 65533, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2452| 0| break; \ | | 2453| 0| case 68: \ | | ------------------ | | | Branch (2453:3): [True: 0, False: 6] | | ------------------ | | 2454| 0| RDATATYPE_COMPARE("any", 255, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2455| 0| break; \ | | 2456| 0| case 166: \ | | ------------------ | | | Branch (2456:3): [True: 0, False: 6] | | ------------------ | | 2457| 0| RDATATYPE_COMPARE("caa", 257, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2458| 0| break; \ | | 2459| 0| case 7: \ | | ------------------ | | | Branch (2459:3): [True: 0, False: 6] | | ------------------ | | 2460| 0| RDATATYPE_COMPARE("doa", 259, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2461| 0| break; \ | | 2462| 0| case 161: \ | | ------------------ | | | Branch (2462:3): [True: 0, False: 6] | | ------------------ | | 2463| 0| RDATATYPE_COMPARE("amtrelay", 260, _typename, _length, _typep); \ | | ------------------ | | | | 2208| 0| do { \ | | | | 2209| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2209:7): [True: 0, False: 0] | | | | ------------------ | | | | 2210| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2210:7): [True: 0, False: 0] | | | | ------------------ | | | | 2211| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2211:8): [True: 0, False: 0] | | | | ------------------ | | | | 2212| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2213| 0| *(_tp) = _d; \ | | | | 2214| 0| return (ISC_R_SUCCESS); \ | | | | 2215| 0| } \ | | | | 2216| 0| } while (0) | | | | ------------------ | | | | | Branch (2216:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2464| 0| break; \ | | 2465| 6| } ------------------ 1538| | 1539| 0| if (source->length > 4 && source->length < (4 + sizeof("65000")) && ------------------ | Branch (1539:6): [True: 0, False: 0] | Branch (1539:28): [True: 0, False: 0] ------------------ 1540| 0| strncasecmp("type", source->base, 4) == 0) ------------------ | Branch (1540:6): [True: 0, False: 0] ------------------ 1541| 0| { 1542| 0| char buf[sizeof("65000")]; 1543| 0| char *endp; 1544| 0| unsigned int val; 1545| | 1546| | /* 1547| | * source->base is not required to be NUL terminated. 1548| | * Copy up to remaining bytes and NUL terminate. 1549| | */ 1550| 0| snprintf(buf, sizeof(buf), "%.*s", (int)(source->length - 4), 1551| 0| source->base + 4); 1552| 0| val = strtoul(buf, &endp, 10); 1553| 0| if (*endp == '\0' && val <= 0xffff) { ------------------ | Branch (1553:7): [True: 0, False: 0] | Branch (1553:24): [True: 0, False: 0] ------------------ 1554| 0| *typep = (dns_rdatatype_t)val; 1555| 0| return ISC_R_SUCCESS; 1556| 0| } 1557| 0| } 1558| | 1559| 0| return DNS_R_UNKNOWN; 1560| 0|} dns_rdata_covers: 2327| 550|dns_rdata_covers(dns_rdata_t *rdata) { 2328| 550| if (rdata->type == dns_rdatatype_rrsig) { ------------------ | | 160| 550|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (2328:6): [True: 0, False: 550] ------------------ 2329| 0| return covers_rrsig(rdata); 2330| 0| } 2331| 550| return covers_sig(rdata); 2332| 550|} rdata.c:uint8_fromregion: 2171| 1.33k|uint8_fromregion(isc_region_t *region) { 2172| 1.33k| REQUIRE(region->length >= 1); ------------------ | | 194| 1.33k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.33k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.33k, False: 0] | | | | ------------------ | | | | 43| 1.33k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2173| | 2174| 1.33k| return region->base[0]; 2175| 1.33k|} rdata.c:name_length: 1608| 1.27k|name_length(const dns_name_t *name) { 1609| 1.27k| return name->length; 1610| 1.27k|} rdata.c:mem_tobuffer: 2186| 5.25k|mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length) { 2187| 5.25k| isc_region_t tr; 2188| | 2189| 5.25k| if (length == 0U) { ------------------ | Branch (2189:6): [True: 0, False: 5.25k] ------------------ 2190| 0| return ISC_R_SUCCESS; 2191| 0| } 2192| | 2193| 5.25k| isc_buffer_availableregion(target, &tr); 2194| 5.25k| if (length > tr.length) { ------------------ | Branch (2194:6): [True: 364, False: 4.89k] ------------------ 2195| 364| return ISC_R_NOSPACE; 2196| 364| } 2197| 4.89k| if (tr.base != base) { ------------------ | Branch (2197:6): [True: 4.89k, False: 0] ------------------ 2198| 4.89k| memmove(tr.base, base, length); 2199| 4.89k| } 2200| 4.89k| isc_buffer_add(target, length); 2201| 4.89k| return ISC_R_SUCCESS; 2202| 5.25k|} rdata.c:check_private: 586| 298|check_private(isc_buffer_t *source, dns_secalg_t alg) { 587| 298| isc_region_t sr; 588| 298| if (alg == DNS_KEYALG_PRIVATEDNS) { ------------------ | Branch (588:6): [True: 160, False: 138] ------------------ 589| 160| dns_fixedname_t fixed; 590| | 591| 160| RETERR(dns_name_fromwire(dns_fixedname_initname(&fixed), source, ------------------ | | 272| 160| { \ | | 273| 160| isc_result_t _r = (x); \ | | 274| 160| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 3, False: 157] | | ------------------ | | 275| 3| return ((_r)); \ | | 276| 3| } \ | | 277| 160| } ------------------ 592| 160| DNS_DECOMPRESS_DEFAULT, NULL)); 593| 157| } else if (alg == DNS_KEYALG_PRIVATEOID) { ------------------ | Branch (593:13): [True: 138, False: 0] ------------------ 594| | /* 595| | * Check that we can extract the OID from the start of the 596| | * key data. We have a length byte followed by the OID BER 597| | * encoded. 598| | */ 599| 138| const unsigned char *in = NULL; 600| 138| ASN1_OBJECT *obj = NULL; 601| | 602| 138| isc_buffer_activeregion(source, &sr); 603| 138| if (sr.length < 1 || (unsigned int)*sr.base + 1 > sr.length) { ------------------ | Branch (603:7): [True: 0, False: 138] | Branch (603:24): [True: 9, False: 129] ------------------ 604| 9| RETERR(DNS_R_FORMERR); ------------------ | | 272| 9| { \ | | 273| 9| isc_result_t _r = (x); \ | | 274| 9| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 9, False: 0] | | ------------------ | | 275| 9| return ((_r)); \ | | 276| 9| } \ | | 277| 9| } ------------------ 605| 0| } 606| 129| in = sr.base + 1; 607| 129| obj = d2i_ASN1_OBJECT(NULL, &in, *sr.base); 608| 129| if (obj == NULL) { ------------------ | Branch (608:7): [True: 36, False: 93] ------------------ 609| 36| ERR_clear_error(); 610| 36| RETERR(DNS_R_FORMERR); ------------------ | | 272| 36| { \ | | 273| 36| isc_result_t _r = (x); \ | | 274| 36| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 36, False: 0] | | ------------------ | | 275| 36| return ((_r)); \ | | 276| 36| } \ | | 277| 36| } ------------------ 611| 0| } 612| 93| ASN1_OBJECT_free(obj); 613| 93| if ((in - sr.base) != (*sr.base + 1)) { ------------------ | Branch (613:7): [True: 13, False: 80] ------------------ 614| 13| RETERR(DNS_R_FORMERR); ------------------ | | 272| 13| { \ | | 273| 13| isc_result_t _r = (x); \ | | 274| 13| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 13, False: 0] | | ------------------ | | 275| 13| return ((_r)); \ | | 276| 13| } \ | | 277| 13| } ------------------ 615| 0| } 616| 93| } 617| 237| return ISC_R_SUCCESS; 618| 298|} rdata.c:uint32_fromregion: 2144| 1.61k|uint32_fromregion(isc_region_t *region) { 2145| 1.61k| uint32_t value; 2146| | 2147| 1.61k| REQUIRE(region->length >= 4); ------------------ | | 194| 1.61k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.61k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.61k, False: 0] | | | | ------------------ | | | | 43| 1.61k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2148| 1.61k| value = (uint32_t)region->base[0] << 24; 2149| 1.61k| value |= (uint32_t)region->base[1] << 16; 2150| 1.61k| value |= (uint32_t)region->base[2] << 8; 2151| 1.61k| value |= (uint32_t)region->base[3]; 2152| 1.61k| return value; 2153| 1.61k|} rdata.c:buffer_fromregion: 2088| 6|buffer_fromregion(isc_buffer_t *buffer, isc_region_t *region) { 2089| 6| isc_buffer_init(buffer, region->base, region->length); 2090| 6| isc_buffer_add(buffer, region->length); 2091| 6| isc_buffer_setactive(buffer, region->length); 2092| 6|} rdata.c:uint16_tobuffer: 2107| 2|uint16_tobuffer(uint32_t value, isc_buffer_t *target) { 2108| 2| isc_region_t region; 2109| | 2110| 2| if (value > 0xffff) { ------------------ | Branch (2110:6): [True: 0, False: 2] ------------------ 2111| 0| return ISC_R_RANGE; 2112| 0| } 2113| 2| isc_buffer_availableregion(target, ®ion); 2114| 2| if (region.length < 2) { ------------------ | Branch (2114:6): [True: 0, False: 2] ------------------ 2115| 0| return ISC_R_NOSPACE; 2116| 0| } 2117| 2| isc_buffer_putuint16(target, (uint16_t)value); 2118| 2| return ISC_R_SUCCESS; 2119| 2|} rdata.c:uint32_tobuffer: 2095| 10|uint32_tobuffer(uint32_t value, isc_buffer_t *target) { 2096| 10| isc_region_t region; 2097| | 2098| 10| isc_buffer_availableregion(target, ®ion); 2099| 10| if (region.length < 4) { ------------------ | Branch (2099:6): [True: 0, False: 10] ------------------ 2100| 0| return ISC_R_NOSPACE; 2101| 0| } 2102| 10| isc_buffer_putuint32(target, value); 2103| 10| return ISC_R_SUCCESS; 2104| 10|} rdata.c:name_duporclone: 393| 1.28k|name_duporclone(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) { 394| 1.28k| if (mctx != NULL) { ------------------ | Branch (394:6): [True: 0, False: 1.28k] ------------------ 395| 0| dns_name_dup(source, mctx, target); 396| 1.28k| } else { 397| 1.28k| dns_name_clone(source, target); 398| 1.28k| } 399| 1.28k|} rdata.c:mem_maybedup: 402| 2.14k|mem_maybedup(isc_mem_t *mctx, void *source, size_t length) { 403| 2.14k| void *copy = NULL; 404| | 405| 2.14k| REQUIRE(source != NULL); ------------------ | | 194| 2.14k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.14k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.14k, False: 0] | | | | ------------------ | | | | 43| 2.14k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 406| | 407| 2.14k| if (mctx == NULL) { ------------------ | Branch (407:6): [True: 2.14k, False: 0] ------------------ 408| 2.14k| return source; 409| 2.14k| } 410| | 411| 0| copy = isc_mem_allocate(mctx, length); ------------------ | | 138| 0|#define isc_mem_allocate(c, s) isc__mem_allocate((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 412| 0| memmove(copy, source, length); 413| | 414| 0| return copy; 415| 2.14k|} rdata.c:buffer_empty: 2083| 1.23k|buffer_empty(isc_buffer_t *source) { 2084| 1.23k| return (source->current == source->active) ? true : false; ------------------ | Branch (2084:9): [True: 1.12k, False: 109] ------------------ 2085| 1.23k|} rdata.c:uint16_fromregion: 2164| 7.35k|uint16_fromregion(isc_region_t *region) { 2165| 7.35k| REQUIRE(region->length >= 2); ------------------ | | 194| 7.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 7.35k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 7.35k, False: 0] | | | | ------------------ | | | | 43| 7.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2166| | 2167| 7.35k| return (region->base[0] << 8) | region->base[1]; 2168| 7.35k|} rdata.c:fromwire_any_tsig: 255| 1.12k|fromwire_any_tsig(ARGS_FROMWIRE) { 256| 1.12k| isc_region_t sr; 257| 1.12k| dns_name_t name; 258| 1.12k| unsigned long n; 259| | 260| 1.12k| REQUIRE(type == dns_rdatatype_tsig); ------------------ | | 194| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.12k, False: 0] | | | | ------------------ | | | | 43| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 261| 1.12k| REQUIRE(rdclass == dns_rdataclass_any); ------------------ | | 194| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.12k, False: 0] | | | | ------------------ | | | | 43| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 262| | 263| 1.12k| UNUSED(type); ------------------ | | 65| 1.12k|#define UNUSED(x) (void)(x) ------------------ 264| 1.12k| UNUSED(rdclass); ------------------ | | 65| 1.12k|#define UNUSED(x) (void)(x) ------------------ 265| | 266| 1.12k| dctx = dns_decompress_setpermitted(dctx, false); 267| | 268| | /* 269| | * Algorithm Name. 270| | */ 271| 1.12k| dns_name_init(&name); 272| 1.12k| RETERR(dns_name_fromwire(&name, source, dctx, target)); ------------------ | | 272| 1.12k| { \ | | 273| 1.12k| isc_result_t _r = (x); \ | | 274| 1.12k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 42, False: 1.08k] | | ------------------ | | 275| 42| return ((_r)); \ | | 276| 42| } \ | | 277| 1.12k| } ------------------ 273| | 274| 1.08k| isc_buffer_activeregion(source, &sr); 275| | /* 276| | * Time Signed + Fudge. 277| | */ 278| 1.08k| if (sr.length < 8) { ------------------ | Branch (278:6): [True: 20, False: 1.06k] ------------------ 279| 20| return ISC_R_UNEXPECTEDEND; 280| 20| } 281| 1.06k| RETERR(mem_tobuffer(target, sr.base, 8)); ------------------ | | 272| 1.06k| { \ | | 273| 1.06k| isc_result_t _r = (x); \ | | 274| 1.06k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 1.06k] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 1.06k| } ------------------ 282| 1.06k| isc_region_consume(&sr, 8); ------------------ | | 50| 1.06k| do { \ | | 51| 1.06k| isc_region_t *_r = (r); \ | | 52| 1.06k| unsigned int _l = (l); \ | | 53| 1.06k| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 1.06k|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 1.06k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 1.06k, False: 0] | | | | | | ------------------ | | | | | | 55| 1.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 1.06k| _r->base += _l; \ | | 55| 1.06k| _r->length -= _l; \ | | 56| 1.06k| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 1.06k] | | ------------------ ------------------ 283| 1.06k| isc_buffer_forward(source, 8); 284| | 285| | /* 286| | * Signature Length + Signature. 287| | */ 288| 1.06k| if (sr.length < 2) { ------------------ | Branch (288:6): [True: 16, False: 1.04k] ------------------ 289| 16| return ISC_R_UNEXPECTEDEND; 290| 16| } 291| 1.04k| n = uint16_fromregion(&sr); 292| 1.04k| if (sr.length < n + 2) { ------------------ | Branch (292:6): [True: 41, False: 1.00k] ------------------ 293| 41| return ISC_R_UNEXPECTEDEND; 294| 41| } 295| 1.00k| RETERR(mem_tobuffer(target, sr.base, n + 2)); ------------------ | | 272| 1.00k| { \ | | 273| 1.00k| isc_result_t _r = (x); \ | | 274| 1.00k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 88, False: 915] | | ------------------ | | 275| 88| return ((_r)); \ | | 276| 88| } \ | | 277| 1.00k| } ------------------ 296| 915| isc_region_consume(&sr, n + 2); ------------------ | | 50| 915| do { \ | | 51| 915| isc_region_t *_r = (r); \ | | 52| 915| unsigned int _l = (l); \ | | 53| 915| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 915|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 915| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 915, False: 0] | | | | | | ------------------ | | | | | | 55| 915| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 915| _r->base += _l; \ | | 55| 915| _r->length -= _l; \ | | 56| 915| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 915] | | ------------------ ------------------ 297| 915| isc_buffer_forward(source, n + 2); 298| | 299| | /* 300| | * Original ID + Error. 301| | */ 302| 915| if (sr.length < 4) { ------------------ | Branch (302:6): [True: 44, False: 871] ------------------ 303| 44| return ISC_R_UNEXPECTEDEND; 304| 44| } 305| 871| RETERR(mem_tobuffer(target, sr.base, 4)); ------------------ | | 272| 871| { \ | | 273| 871| isc_result_t _r = (x); \ | | 274| 871| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 7, False: 864] | | ------------------ | | 275| 7| return ((_r)); \ | | 276| 7| } \ | | 277| 871| } ------------------ 306| 864| isc_region_consume(&sr, 4); ------------------ | | 50| 864| do { \ | | 51| 864| isc_region_t *_r = (r); \ | | 52| 864| unsigned int _l = (l); \ | | 53| 864| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 864|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 864| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 864, False: 0] | | | | | | ------------------ | | | | | | 55| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 864| _r->base += _l; \ | | 55| 864| _r->length -= _l; \ | | 56| 864| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 864] | | ------------------ ------------------ 307| 864| isc_buffer_forward(source, 4); 308| | 309| | /* 310| | * Other Length + Other. 311| | */ 312| 864| if (sr.length < 2) { ------------------ | Branch (312:6): [True: 5, False: 859] ------------------ 313| 5| return ISC_R_UNEXPECTEDEND; 314| 5| } 315| 859| n = uint16_fromregion(&sr); 316| 859| if (sr.length < n + 2) { ------------------ | Branch (316:6): [True: 77, False: 782] ------------------ 317| 77| return ISC_R_UNEXPECTEDEND; 318| 77| } 319| 782| isc_buffer_forward(source, n + 2); 320| 782| return mem_tobuffer(target, sr.base, n + 2); 321| 859|} rdata.c:tostruct_any_tsig: 444| 739|tostruct_any_tsig(ARGS_TOSTRUCT) { 445| 739| dns_rdata_any_tsig_t *tsig; 446| 739| dns_name_t alg; 447| 739| isc_region_t sr; 448| | 449| 739| REQUIRE(rdata->type == dns_rdatatype_tsig); ------------------ | | 194| 739|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 739| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 739, False: 0] | | | | ------------------ | | | | 43| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 450| 739| REQUIRE(rdata->rdclass == dns_rdataclass_any); ------------------ | | 194| 739|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 739| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 739, False: 0] | | | | ------------------ | | | | 43| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 451| 739| REQUIRE(rdata->length != 0); ------------------ | | 194| 739|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 739| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 739, False: 0] | | | | ------------------ | | | | 43| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 452| | 453| 739| tsig = (dns_rdata_any_tsig_t *)target; 454| 739| DNS_RDATACOMMON_INIT(tsig, rdata->type, rdata->rdclass); ------------------ | | 44| 739| do { \ | | 45| 739| (_data)->common.rdtype = (_rdtype); \ | | 46| 739| (_data)->common.rdclass = (_rdclass); \ | | 47| 739| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 739] | | ------------------ ------------------ 455| | 456| 739| dns_rdata_toregion(rdata, &sr); 457| | 458| | /* 459| | * Algorithm Name. 460| | */ 461| 739| dns_name_init(&alg); 462| 739| dns_name_fromregion(&alg, &sr); 463| 739| dns_name_init(&tsig->algorithm); 464| 739| name_duporclone(&alg, mctx, &tsig->algorithm); 465| | 466| 739| isc_region_consume(&sr, name_length(&tsig->algorithm)); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 467| | 468| | /* 469| | * Time Signed. 470| | */ 471| 739| INSIST(sr.length >= 6); ------------------ | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 739| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 739, False: 0] | | | | ------------------ | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 472| 739| tsig->timesigned = ((uint64_t)sr.base[0] << 40) | 473| 739| ((uint64_t)sr.base[1] << 32) | 474| 739| ((uint64_t)sr.base[2] << 24) | 475| 739| ((uint64_t)sr.base[3] << 16) | 476| 739| ((uint64_t)sr.base[4] << 8) | (uint64_t)sr.base[5]; 477| 739| isc_region_consume(&sr, 6); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 478| | 479| | /* 480| | * Fudge. 481| | */ 482| 739| tsig->fudge = uint16_fromregion(&sr); 483| 739| isc_region_consume(&sr, 2); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 484| | 485| | /* 486| | * Signature Size. 487| | */ 488| 739| tsig->siglen = uint16_fromregion(&sr); 489| 739| isc_region_consume(&sr, 2); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 490| | 491| | /* 492| | * Signature. 493| | */ 494| 739| INSIST(sr.length >= tsig->siglen); ------------------ | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 739| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 739, False: 0] | | | | ------------------ | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 495| 739| tsig->signature = mem_maybedup(mctx, sr.base, tsig->siglen); 496| 739| isc_region_consume(&sr, tsig->siglen); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 497| | 498| | /* 499| | * Original ID. 500| | */ 501| 739| tsig->originalid = uint16_fromregion(&sr); 502| 739| isc_region_consume(&sr, 2); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 503| | 504| | /* 505| | * Error. 506| | */ 507| 739| tsig->error = uint16_fromregion(&sr); 508| 739| isc_region_consume(&sr, 2); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 509| | 510| | /* 511| | * Other Size. 512| | */ 513| 739| tsig->otherlen = uint16_fromregion(&sr); 514| 739| isc_region_consume(&sr, 2); ------------------ | | 50| 739| do { \ | | 51| 739| isc_region_t *_r = (r); \ | | 52| 739| unsigned int _l = (l); \ | | 53| 739| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 739| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 739, False: 0] | | | | | | ------------------ | | | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 739| _r->base += _l; \ | | 55| 739| _r->length -= _l; \ | | 56| 739| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 739] | | ------------------ ------------------ 515| | 516| | /* 517| | * Other. 518| | */ 519| 739| INSIST(sr.length == tsig->otherlen); ------------------ | | 198| 739|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 739| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 739, False: 0] | | | | ------------------ | | | | 55| 739| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 520| 739| tsig->other = mem_maybedup(mctx, sr.base, tsig->otherlen); 521| | 522| 739| tsig->mctx = mctx; 523| 739| return ISC_R_SUCCESS; 524| 739|} rdata.c:fromtext_key: 235| 2|fromtext_key(ARGS_FROMTEXT) { 236| 2| REQUIRE(type == dns_rdatatype_key); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 237| | 238| 2| return generic_fromtext_key(CALL_FROMTEXT); ------------------ | | 80| 2|#define CALL_FROMTEXT rdclass, type, lexer, origin, options, target, callbacks ------------------ 239| 2|} rdata.c:generic_fromtext_key: 24| 2|generic_fromtext_key(ARGS_FROMTEXT) { 25| 2| isc_token_t token; 26| 2| dns_secalg_t alg; 27| 2| dns_secproto_t proto; 28| 2| dns_keyflags_t flags; 29| 2| unsigned int used; 30| | 31| 2| UNUSED(rdclass); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 32| 2| UNUSED(origin); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 33| 2| UNUSED(options); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 34| 2| UNUSED(callbacks); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 35| | 36| | /* flags */ 37| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 38| 2| false)); 39| 2| RETTOK(dns_keyflags_fromtext(&flags, &token.value.as_textregion)); ------------------ | | 56| 2| do { \ | | 57| 2| isc_result_t _r = (x); \ | | 58| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 2] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 2| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 2] | | ------------------ ------------------ 40| 2| if (type == dns_rdatatype_rkey && flags != 0U) { ------------------ | | 170| 4|#define dns_rdatatype_rkey ((dns_rdatatype_t)dns_rdatatype_rkey) ------------------ | Branch (40:6): [True: 0, False: 2] | Branch (40:36): [True: 0, False: 0] ------------------ 41| 0| RETTOK(DNS_R_FORMERR); ------------------ | | 56| 0| do { \ | | 57| 0| isc_result_t _r = (x); \ | | 58| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 0] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 0| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 0] | | ------------------ ------------------ 42| 0| } 43| 2| RETERR(uint16_tobuffer(flags, target)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 44| | 45| | /* protocol */ 46| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 47| 2| false)); 48| 2| RETTOK(dns_secproto_fromtext(&proto, &token.value.as_textregion)); ------------------ | | 56| 2| do { \ | | 57| 2| isc_result_t _r = (x); \ | | 58| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 2] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 2| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 2] | | ------------------ ------------------ 49| 2| RETERR(mem_tobuffer(target, &proto, 1)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 50| | 51| | /* algorithm */ 52| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 53| 2| false)); 54| 2| RETTOK(dns_secalg_fromtext(&alg, &token.value.as_textregion)); ------------------ | | 56| 2| do { \ | | 57| 2| isc_result_t _r = (x); \ | | 58| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 2] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 2| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 2] | | ------------------ ------------------ 55| 2| RETERR(mem_tobuffer(target, &alg, 1)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 56| | 57| | /* 58| | * Save the current used value. It will become the current 59| | * value when we parse the keydata field. 60| | */ 61| 2| used = isc_buffer_usedlength(target); ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 62| | 63| 2| RETERR(isc_base64_tobuffer(lexer, target, isc_one_or_more)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 64| | 65| 2| if (alg == DNS_KEYALG_PRIVATEDNS || alg == DNS_KEYALG_PRIVATEOID) { ------------------ | Branch (65:6): [True: 0, False: 2] | Branch (65:38): [True: 0, False: 2] ------------------ 66| 0| isc_buffer_t b; 67| | 68| | /* 69| | * Set up 'b' so that the key data can be parsed. 70| | */ 71| 0| b = *target; 72| 0| b.active = b.used; 73| 0| b.current = used; 74| | 75| 0| RETERR(check_private(&b, alg)); ------------------ | | 272| 0| { \ | | 273| 0| isc_result_t _r = (x); \ | | 274| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 0] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 0| } ------------------ 76| 0| } 77| | 78| 2| return ISC_R_SUCCESS; 79| 2|} rdata.c:tostruct_key: 373| 132|tostruct_key(ARGS_TOSTRUCT) { 374| 132| dns_rdata_key_t *key = target; 375| | 376| 132| REQUIRE(key != NULL); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 377| 132| REQUIRE(rdata != NULL); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 378| 132| REQUIRE(rdata->type == dns_rdatatype_key); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 379| | 380| 132| DNS_RDATACOMMON_INIT(key, rdata->type, rdata->rdclass); ------------------ | | 44| 132| do { \ | | 45| 132| (_data)->common.rdtype = (_rdtype); \ | | 46| 132| (_data)->common.rdclass = (_rdclass); \ | | 47| 132| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 132] | | ------------------ ------------------ 381| | 382| 132| return generic_tostruct_key(CALL_TOSTRUCT); ------------------ | | 109| 132|#define CALL_TOSTRUCT rdata, target, mctx ------------------ 383| 132|} rdata.c:generic_tostruct_key: 317| 132|generic_tostruct_key(ARGS_TOSTRUCT) { 318| 132| dns_rdata_key_t *key = target; 319| 132| isc_region_t sr; 320| | 321| 132| REQUIRE(key != NULL); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 322| 132| REQUIRE(rdata->length >= 4U); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 323| | 324| 132| REQUIRE(key != NULL); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 325| 132| REQUIRE(key->common.rdclass == rdata->rdclass); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 326| 132| REQUIRE(key->common.rdtype == rdata->type); ------------------ | | 194| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 132, False: 0] | | | | ------------------ | | | | 43| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 327| | 328| 132| dns_rdata_toregion(rdata, &sr); 329| | 330| | /* Flags */ 331| 132| key->flags = uint16_fromregion(&sr); 332| 132| isc_region_consume(&sr, 2); ------------------ | | 50| 132| do { \ | | 51| 132| isc_region_t *_r = (r); \ | | 52| 132| unsigned int _l = (l); \ | | 53| 132| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 132|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 132| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 132, False: 0] | | | | | | ------------------ | | | | | | 55| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 132| _r->base += _l; \ | | 55| 132| _r->length -= _l; \ | | 56| 132| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 132] | | ------------------ ------------------ 333| | 334| | /* Protocol */ 335| 132| key->protocol = uint8_fromregion(&sr); 336| 132| isc_region_consume(&sr, 1); ------------------ | | 50| 132| do { \ | | 51| 132| isc_region_t *_r = (r); \ | | 52| 132| unsigned int _l = (l); \ | | 53| 132| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 132|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 132| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 132, False: 0] | | | | | | ------------------ | | | | | | 55| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 132| _r->base += _l; \ | | 55| 132| _r->length -= _l; \ | | 56| 132| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 132] | | ------------------ ------------------ 337| | 338| | /* Algorithm */ 339| 132| key->algorithm = uint8_fromregion(&sr); 340| 132| isc_region_consume(&sr, 1); ------------------ | | 50| 132| do { \ | | 51| 132| isc_region_t *_r = (r); \ | | 52| 132| unsigned int _l = (l); \ | | 53| 132| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 132|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 132| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 132, False: 0] | | | | | | ------------------ | | | | | | 55| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 132| _r->base += _l; \ | | 55| 132| _r->length -= _l; \ | | 56| 132| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 132] | | ------------------ ------------------ 341| | 342| | /* Data */ 343| 132| key->datalen = sr.length; 344| 132| key->data = mem_maybedup(mctx, sr.base, key->datalen); 345| 132| key->mctx = mctx; 346| 132| return ISC_R_SUCCESS; 347| 132|} rdata.c:fromtext_ns: 20| 2|fromtext_ns(ARGS_FROMTEXT) { 21| 2| isc_token_t token; 22| 2| dns_fixedname_t fn; 23| 2| dns_name_t *name = dns_fixedname_initname(&fn); 24| 2| isc_buffer_t buffer; 25| 2| bool ok; 26| | 27| 2| REQUIRE(type == dns_rdatatype_ns); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 28| | 29| 2| UNUSED(type); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 30| 2| UNUSED(rdclass); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 31| 2| UNUSED(callbacks); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 32| | 33| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 34| 2| false)); 35| | 36| 2| buffer_fromregion(&buffer, &token.value.as_region); 37| 2| if (origin == NULL) { ------------------ | Branch (37:6): [True: 0, False: 2] ------------------ 38| 0| origin = dns_rootname; 39| 0| } 40| 2| RETTOK(dns_name_fromtext(name, &buffer, origin, options)); ------------------ | | 56| 2| do { \ | | 57| 2| isc_result_t _r = (x); \ | | 58| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 2] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 2| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 2] | | ------------------ ------------------ 41| 2| RETTOK(dns_name_towire(name, NULL, target)); ------------------ | | 56| 2| do { \ | | 57| 2| isc_result_t _r = (x); \ | | 58| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 2] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 2| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 2] | | ------------------ ------------------ 42| 2| ok = true; 43| 2| if ((options & DNS_RDATA_CHECKNAMES) != 0) { ------------------ | | 210| 2|#define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES | | ------------------ | | | | 135| 2|#define DNS_NAME_CHECKNAMES 0x0002 /*%< Used by rdata. */ | | ------------------ ------------------ | Branch (43:6): [True: 0, False: 2] ------------------ 44| 0| ok = dns_name_ishostname(name, false); 45| 0| } 46| 2| if (!ok && (options & DNS_RDATA_CHECKNAMESFAIL) != 0) { ------------------ | | 211| 0|#define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL | | ------------------ | | | | 136| 0|#define DNS_NAME_CHECKNAMESFAIL 0x0004 /*%< Used by rdata. */ | | ------------------ ------------------ | Branch (46:6): [True: 0, False: 2] | Branch (46:13): [True: 0, False: 0] ------------------ 47| 0| RETTOK(DNS_R_BADNAME); ------------------ | | 56| 0| do { \ | | 57| 0| isc_result_t _r = (x); \ | | 58| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 0] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 0| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 0] | | ------------------ ------------------ 48| 0| } 49| 2| if (!ok && callbacks != NULL) { ------------------ | Branch (49:6): [True: 0, False: 2] | Branch (49:13): [True: 0, False: 0] ------------------ 50| 0| warn_badname(name, lexer, callbacks); 51| 0| } 52| 2| return ISC_R_SUCCESS; 53| 2|} rdata.c:tostruct_ns: 151| 2|tostruct_ns(ARGS_TOSTRUCT) { 152| 2| isc_region_t region; 153| 2| dns_rdata_ns_t *ns = target; 154| 2| dns_name_t name; 155| | 156| 2| REQUIRE(rdata->type == dns_rdatatype_ns); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 157| 2| REQUIRE(ns != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 158| 2| REQUIRE(rdata->length != 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 159| | 160| 2| DNS_RDATACOMMON_INIT(ns, rdata->type, rdata->rdclass); ------------------ | | 44| 2| do { \ | | 45| 2| (_data)->common.rdtype = (_rdtype); \ | | 46| 2| (_data)->common.rdclass = (_rdclass); \ | | 47| 2| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 2] | | ------------------ ------------------ 161| | 162| 2| dns_name_init(&name); 163| 2| dns_rdata_toregion(rdata, ®ion); 164| 2| dns_name_fromregion(&name, ®ion); 165| 2| dns_name_init(&ns->name); 166| 2| name_duporclone(&name, mctx, &ns->name); 167| 2| ns->mctx = mctx; 168| 2| return ISC_R_SUCCESS; 169| 2|} rdata.c:fromwire_sig: 258| 824|fromwire_sig(ARGS_FROMWIRE) { 259| 824| isc_region_t sr; 260| 824| dns_name_t name; 261| 824| unsigned char algorithm; 262| | 263| 824| REQUIRE(type == dns_rdatatype_sig); ------------------ | | 194| 824|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 824| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 824, False: 0] | | | | ------------------ | | | | 43| 824| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 264| | 265| 824| UNUSED(type); ------------------ | | 65| 824|#define UNUSED(x) (void)(x) ------------------ 266| 824| UNUSED(rdclass); ------------------ | | 65| 824|#define UNUSED(x) (void)(x) ------------------ 267| | 268| 824| dctx = dns_decompress_setpermitted(dctx, false); 269| | 270| 824| isc_buffer_activeregion(source, &sr); 271| | /* 272| | * type covered: 2 273| | * algorithm: 1 274| | * labels: 1 275| | * original ttl: 4 276| | * signature expiration: 4 277| | * time signed: 4 278| | * key footprint: 2 279| | */ 280| 824| if (sr.length < 18) { ------------------ | Branch (280:6): [True: 15, False: 809] ------------------ 281| 15| return ISC_R_UNEXPECTEDEND; 282| 15| } 283| | 284| 809| algorithm = sr.base[2]; 285| | 286| 809| isc_buffer_forward(source, 18); 287| 809| RETERR(mem_tobuffer(target, sr.base, 18)); ------------------ | | 272| 809| { \ | | 273| 809| isc_result_t _r = (x); \ | | 274| 809| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 809] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 809| } ------------------ 288| | 289| | /* 290| | * Signer. 291| | */ 292| 809| dns_name_init(&name); 293| 809| RETERR(dns_name_fromwire(&name, source, dctx, target)); ------------------ | | 272| 809| { \ | | 273| 809| isc_result_t _r = (x); \ | | 274| 809| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 17, False: 792] | | ------------------ | | 275| 17| return ((_r)); \ | | 276| 17| } \ | | 277| 809| } ------------------ 294| | 295| | /* 296| | * Sig. 297| | */ 298| 792| isc_buffer_activeregion(source, &sr); 299| 792| if (sr.length == 0) { ------------------ | Branch (299:6): [True: 4, False: 788] ------------------ 300| 4| return ISC_R_UNEXPECTEDEND; 301| 4| } 302| | 303| 788| if (algorithm == DNS_KEYALG_PRIVATEDNS || ------------------ | Branch (303:6): [True: 160, False: 628] ------------------ 304| 628| algorithm == DNS_KEYALG_PRIVATEOID) ------------------ | Branch (304:6): [True: 138, False: 490] ------------------ 305| 298| { 306| 298| isc_buffer_t b = *source; 307| 298| RETERR(check_private(&b, algorithm)); ------------------ | | 272| 298| { \ | | 273| 298| isc_result_t _r = (x); \ | | 274| 298| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 61, False: 237] | | ------------------ | | 275| 61| return ((_r)); \ | | 276| 61| } \ | | 277| 298| } ------------------ 308| 237| } 309| | 310| 727| isc_buffer_forward(source, sr.length); 311| 727| return mem_tobuffer(target, sr.base, sr.length); 312| 788|} rdata.c:tostruct_sig: 455| 536|tostruct_sig(ARGS_TOSTRUCT) { 456| 536| isc_region_t sr; 457| 536| dns_rdata_sig_t *sig = target; 458| 536| dns_name_t signer; 459| | 460| 536| REQUIRE(rdata->type == dns_rdatatype_sig); ------------------ | | 194| 536|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 536| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 536, False: 0] | | | | ------------------ | | | | 43| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 461| 536| REQUIRE(sig != NULL); ------------------ | | 194| 536|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 536| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 536, False: 0] | | | | ------------------ | | | | 43| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 462| 536| REQUIRE(rdata->length != 0); ------------------ | | 194| 536|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 536| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 536, False: 0] | | | | ------------------ | | | | 43| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 463| | 464| 536| DNS_RDATACOMMON_INIT(sig, rdata->type, rdata->rdclass); ------------------ | | 44| 536| do { \ | | 45| 536| (_data)->common.rdtype = (_rdtype); \ | | 46| 536| (_data)->common.rdclass = (_rdclass); \ | | 47| 536| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 536] | | ------------------ ------------------ 465| | 466| 536| dns_rdata_toregion(rdata, &sr); 467| | 468| | /* 469| | * Type covered. 470| | */ 471| 536| sig->covered = uint16_fromregion(&sr); 472| 536| isc_region_consume(&sr, 2); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 473| | 474| | /* 475| | * Algorithm. 476| | */ 477| 536| sig->algorithm = uint8_fromregion(&sr); 478| 536| isc_region_consume(&sr, 1); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 479| | 480| | /* 481| | * Labels. 482| | */ 483| 536| sig->labels = uint8_fromregion(&sr); 484| 536| isc_region_consume(&sr, 1); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 485| | 486| | /* 487| | * Original TTL. 488| | */ 489| 536| sig->originalttl = uint32_fromregion(&sr); 490| 536| isc_region_consume(&sr, 4); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 491| | 492| | /* 493| | * Expire time. 494| | */ 495| 536| sig->timeexpire = uint32_fromregion(&sr); 496| 536| isc_region_consume(&sr, 4); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 497| | 498| | /* 499| | * Time signed. 500| | */ 501| 536| sig->timesigned = uint32_fromregion(&sr); 502| 536| isc_region_consume(&sr, 4); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 503| | 504| | /* 505| | * Key ID. 506| | */ 507| 536| sig->keyid = uint16_fromregion(&sr); 508| 536| isc_region_consume(&sr, 2); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 509| | 510| 536| dns_name_init(&signer); 511| 536| dns_name_fromregion(&signer, &sr); 512| 536| dns_name_init(&sig->signer); 513| 536| name_duporclone(&signer, mctx, &sig->signer); 514| 536| isc_region_consume(&sr, name_length(&sig->signer)); ------------------ | | 50| 536| do { \ | | 51| 536| isc_region_t *_r = (r); \ | | 52| 536| unsigned int _l = (l); \ | | 53| 536| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 536|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 536| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 536, False: 0] | | | | | | ------------------ | | | | | | 55| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 536| _r->base += _l; \ | | 55| 536| _r->length -= _l; \ | | 56| 536| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 536] | | ------------------ ------------------ 515| | 516| | /* 517| | * Signature. 518| | */ 519| 536| sig->siglen = sr.length; 520| 536| sig->signature = mem_maybedup(mctx, sr.base, sig->siglen); 521| 536| sig->mctx = mctx; 522| 536| return ISC_R_SUCCESS; 523| 536|} rdata.c:freestruct_sig: 526| 536|freestruct_sig(ARGS_FREESTRUCT) { 527| 536| dns_rdata_sig_t *sig = (dns_rdata_sig_t *)source; 528| | 529| 536| REQUIRE(sig != NULL); ------------------ | | 194| 536|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 536| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 536, False: 0] | | | | ------------------ | | | | 43| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 530| 536| REQUIRE(sig->common.rdtype == dns_rdatatype_sig); ------------------ | | 194| 536|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 536| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 536, False: 0] | | | | ------------------ | | | | 43| 536| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 531| | 532| 536| if (sig->mctx == NULL) { ------------------ | Branch (532:6): [True: 536, False: 0] ------------------ 533| 536| return; 534| 536| } 535| | 536| 0| dns_name_free(&sig->signer, sig->mctx); 537| 0| if (sig->signature != NULL) { ------------------ | Branch (537:6): [True: 0, False: 0] ------------------ 538| 0| isc_mem_free(sig->mctx, sig->signature); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 539| 0| } 540| | sig->mctx = NULL; 541| 0|} rdata.c:covers_sig: 586| 550|covers_sig(dns_rdata_t *rdata) { 587| 550| dns_rdatatype_t type; 588| 550| isc_region_t r; 589| | 590| 550| REQUIRE(rdata->type == dns_rdatatype_sig); ------------------ | | 194| 550|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 550| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 550, False: 0] | | | | ------------------ | | | | 43| 550| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 591| | 592| 550| dns_rdata_toregion(rdata, &r); 593| 550| type = uint16_fromregion(&r); 594| | 595| 550| return type; 596| 550|} rdata.c:fromtext_soa: 20| 2|fromtext_soa(ARGS_FROMTEXT) { 21| 2| isc_token_t token; 22| 2| isc_buffer_t buffer; 23| 2| int i; 24| 2| uint32_t n; 25| 2| bool ok; 26| | 27| 2| REQUIRE(type == dns_rdatatype_soa); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 28| | 29| 2| UNUSED(type); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 30| 2| UNUSED(rdclass); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 31| 2| UNUSED(callbacks); ------------------ | | 65| 2|#define UNUSED(x) (void)(x) ------------------ 32| | 33| 2| if (origin == NULL) { ------------------ | Branch (33:6): [True: 0, False: 2] ------------------ 34| 0| origin = dns_rootname; 35| 0| } 36| | 37| 6| for (i = 0; i < 2; i++) { ------------------ | Branch (37:14): [True: 4, False: 2] ------------------ 38| 4| dns_fixedname_t fn; 39| 4| dns_name_t *name = dns_fixedname_initname(&fn); 40| | 41| 4| RETERR(isc_lex_getmastertoken(lexer, &token, ------------------ | | 272| 4| { \ | | 273| 4| isc_result_t _r = (x); \ | | 274| 4| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 4] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 4| } ------------------ 42| 4| isc_tokentype_string, false)); 43| | 44| 4| buffer_fromregion(&buffer, &token.value.as_region); 45| 4| RETTOK(dns_name_fromtext(name, &buffer, origin, options)); ------------------ | | 56| 4| do { \ | | 57| 4| isc_result_t _r = (x); \ | | 58| 4| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 4] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 4| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 4] | | ------------------ ------------------ 46| 4| RETTOK(dns_name_towire(name, NULL, target)); ------------------ | | 56| 4| do { \ | | 57| 4| isc_result_t _r = (x); \ | | 58| 4| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 4] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 4| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 4] | | ------------------ ------------------ 47| 4| ok = true; 48| 4| if ((options & DNS_RDATA_CHECKNAMES) != 0) { ------------------ | | 210| 4|#define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES | | ------------------ | | | | 135| 4|#define DNS_NAME_CHECKNAMES 0x0002 /*%< Used by rdata. */ | | ------------------ ------------------ | Branch (48:7): [True: 0, False: 4] ------------------ 49| 0| switch (i) { ------------------ | Branch (49:12): [True: 0, False: 0] ------------------ 50| 0| case 0: ------------------ | Branch (50:4): [True: 0, False: 0] ------------------ 51| 0| ok = dns_name_ishostname(name, false); 52| 0| break; 53| 0| case 1: ------------------ | Branch (53:4): [True: 0, False: 0] ------------------ 54| 0| ok = dns_name_ismailbox(name); 55| 0| break; 56| 0| } 57| 0| } 58| 4| if (!ok && (options & DNS_RDATA_CHECKNAMESFAIL) != 0) { ------------------ | | 211| 0|#define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL | | ------------------ | | | | 136| 0|#define DNS_NAME_CHECKNAMESFAIL 0x0004 /*%< Used by rdata. */ | | ------------------ ------------------ | Branch (58:7): [True: 0, False: 4] | Branch (58:14): [True: 0, False: 0] ------------------ 59| 0| RETTOK(DNS_R_BADNAME); ------------------ | | 56| 0| do { \ | | 57| 0| isc_result_t _r = (x); \ | | 58| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 0] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 0| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 0] | | ------------------ ------------------ 60| 0| } 61| 4| if (!ok && callbacks != NULL) { ------------------ | Branch (61:7): [True: 0, False: 4] | Branch (61:14): [True: 0, False: 0] ------------------ 62| 0| warn_badname(name, lexer, callbacks); 63| 0| } 64| 4| } 65| | 66| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_number, ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 67| 2| false)); 68| 2| RETERR(uint32_tobuffer(token.value.as_ulong, target)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 69| | 70| 10| for (i = 0; i < 4; i++) { ------------------ | Branch (70:14): [True: 8, False: 2] ------------------ 71| 8| RETERR(isc_lex_getmastertoken(lexer, &token, ------------------ | | 272| 8| { \ | | 273| 8| isc_result_t _r = (x); \ | | 274| 8| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 8] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 8| } ------------------ 72| 8| isc_tokentype_string, false)); 73| 8| RETTOK(dns_counter_fromtext(&token.value.as_textregion, &n)); ------------------ | | 56| 8| do { \ | | 57| 8| isc_result_t _r = (x); \ | | 58| 8| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (58:7): [True: 0, False: 8] | | ------------------ | | 59| 0| isc_lex_ungettoken(lexer, &token); \ | | 60| 0| return (_r); \ | | 61| 0| } \ | | 62| 8| } while (0) | | ------------------ | | | Branch (62:11): [Folded, False: 8] | | ------------------ ------------------ 74| 8| RETERR(uint32_tobuffer(n, target)); ------------------ | | 272| 8| { \ | | 273| 8| isc_result_t _r = (x); \ | | 274| 8| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 8] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 8| } ------------------ 75| 8| } 76| | 77| 2| return ISC_R_SUCCESS; 78| 2|} rdata.c:tostruct_soa: 306| 2|tostruct_soa(ARGS_TOSTRUCT) { 307| 2| isc_region_t region; 308| 2| dns_rdata_soa_t *soa = target; 309| 2| dns_name_t name; 310| | 311| 2| REQUIRE(rdata->type == dns_rdatatype_soa); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 312| 2| REQUIRE(soa != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 313| 2| REQUIRE(rdata->length != 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 314| | 315| 2| DNS_RDATACOMMON_INIT(soa, rdata->type, rdata->rdclass); ------------------ | | 44| 2| do { \ | | 45| 2| (_data)->common.rdtype = (_rdtype); \ | | 46| 2| (_data)->common.rdclass = (_rdclass); \ | | 47| 2| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 2] | | ------------------ ------------------ 316| | 317| 2| dns_rdata_toregion(rdata, ®ion); 318| | 319| 2| dns_name_init(&name); 320| 2| dns_name_fromregion(&name, ®ion); 321| 2| isc_region_consume(®ion, name_length(&name)); ------------------ | | 50| 2| do { \ | | 51| 2| isc_region_t *_r = (r); \ | | 52| 2| unsigned int _l = (l); \ | | 53| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 2| _r->base += _l; \ | | 55| 2| _r->length -= _l; \ | | 56| 2| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 2] | | ------------------ ------------------ 322| 2| dns_name_init(&soa->origin); 323| 2| name_duporclone(&name, mctx, &soa->origin); 324| | 325| 2| dns_name_fromregion(&name, ®ion); 326| 2| isc_region_consume(®ion, name_length(&name)); ------------------ | | 50| 2| do { \ | | 51| 2| isc_region_t *_r = (r); \ | | 52| 2| unsigned int _l = (l); \ | | 53| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 2| _r->base += _l; \ | | 55| 2| _r->length -= _l; \ | | 56| 2| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 2] | | ------------------ ------------------ 327| 2| dns_name_init(&soa->contact); 328| 2| name_duporclone(&name, mctx, &soa->contact); 329| | 330| 2| soa->serial = uint32_fromregion(®ion); 331| 2| isc_region_consume(®ion, 4); ------------------ | | 50| 2| do { \ | | 51| 2| isc_region_t *_r = (r); \ | | 52| 2| unsigned int _l = (l); \ | | 53| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 2| _r->base += _l; \ | | 55| 2| _r->length -= _l; \ | | 56| 2| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 2] | | ------------------ ------------------ 332| | 333| 2| soa->refresh = uint32_fromregion(®ion); 334| 2| isc_region_consume(®ion, 4); ------------------ | | 50| 2| do { \ | | 51| 2| isc_region_t *_r = (r); \ | | 52| 2| unsigned int _l = (l); \ | | 53| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 2| _r->base += _l; \ | | 55| 2| _r->length -= _l; \ | | 56| 2| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 2] | | ------------------ ------------------ 335| | 336| 2| soa->retry = uint32_fromregion(®ion); 337| 2| isc_region_consume(®ion, 4); ------------------ | | 50| 2| do { \ | | 51| 2| isc_region_t *_r = (r); \ | | 52| 2| unsigned int _l = (l); \ | | 53| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 2| _r->base += _l; \ | | 55| 2| _r->length -= _l; \ | | 56| 2| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 2] | | ------------------ ------------------ 338| | 339| 2| soa->expire = uint32_fromregion(®ion); 340| 2| isc_region_consume(®ion, 4); ------------------ | | 50| 2| do { \ | | 51| 2| isc_region_t *_r = (r); \ | | 52| 2| unsigned int _l = (l); \ | | 53| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 2| _r->base += _l; \ | | 55| 2| _r->length -= _l; \ | | 56| 2| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 2] | | ------------------ ------------------ 341| | 342| 2| soa->minimum = uint32_fromregion(®ion); 343| | 344| 2| soa->mctx = mctx; 345| 2| return ISC_R_SUCCESS; 346| 2|} dns_rdatalist_init: 43| 2.92k|dns_rdatalist_init(dns_rdatalist_t *rdatalist) { 44| 2.92k| REQUIRE(rdatalist != NULL); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 45| | 46| | /* 47| | * Initialize rdatalist. 48| | */ 49| 2.92k| *rdatalist = (dns_rdatalist_t){ 50| 2.92k| .rdata = ISC_LIST_INITIALIZER, ------------------ | | 21| 2.92k| { \ | | 22| 2.92k| .head = NULL, \ | | 23| 2.92k| .tail = NULL, \ | | 24| 2.92k| } ------------------ 51| 2.92k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2.92k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2.92k| { \ | | | | 27| 2.92k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2.92k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2.92k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2.92k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2.92k| } | | ------------------ ------------------ 52| 2.92k| }; 53| 2.92k| memset(rdatalist->upper, 0xeb, sizeof(rdatalist->upper)); 54| | 55| | /* 56| | * Clear upper set bit. 57| | */ 58| 2.92k| rdatalist->upper[0] &= ~0x01; 59| 2.92k|} dns_rdatalist_tordataset: 62| 2.92k|dns_rdatalist_tordataset(dns_rdatalist_t *rdatalist, dns_rdataset_t *rdataset) { 63| | /* 64| | * Make 'rdataset' refer to the rdata in 'rdatalist'. 65| | */ 66| | 67| 2.92k| REQUIRE(rdatalist != NULL); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 68| 2.92k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.85k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | | Branch (42:11): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 69| 2.92k| REQUIRE(!dns_rdataset_isassociated(rdataset)); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 70| | 71| | /* Check if dns_rdatalist_init has was called. */ 72| 2.92k| REQUIRE(rdatalist->upper[0] == 0xea); ------------------ | | 194| 2.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.92k, False: 0] | | | | ------------------ | | | | 43| 2.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 73| | 74| 2.92k| *rdataset = (dns_rdataset_t){ 75| 2.92k| .methods = &methods, 76| 2.92k| .rdclass = rdatalist->rdclass, 77| 2.92k| .type = rdatalist->type, 78| 2.92k| .covers = rdatalist->covers, 79| 2.92k| .ttl = rdatalist->ttl, 80| 2.92k| .rdlist.list = rdatalist, 81| | 82| 2.92k| .link = rdataset->link, 83| 2.92k| .attributes = rdataset->attributes, 84| 2.92k| .magic = rdataset->magic, 85| 2.92k| }; 86| 2.92k|} dns_rdatalist_fromrdataset: 90| 1.12k| dns_rdatalist_t **rdatalist) { 91| 1.12k| REQUIRE(rdatalist != NULL && rdataset != NULL); ------------------ | | 194| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.12k, False: 0] | | | | | Branch (42:11): [True: 1.12k, False: 0] | | | | ------------------ | | | | 43| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 92| 1.12k| REQUIRE(rdataset->methods == &methods); ------------------ | | 194| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.12k, False: 0] | | | | ------------------ | | | | 43| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 93| | 94| 1.12k| *rdatalist = rdataset->rdlist.list; 95| 1.12k|} dns_rdatalist_disassociate: 98| 2.92k|dns_rdatalist_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 99| 2.92k| UNUSED(rdataset); ------------------ | | 65| 2.92k|#define UNUSED(x) (void)(x) ------------------ 100| 2.92k|} dns__rdatalist_first: 103| 1.28k|dns__rdatalist_first(dns_rdataset_t *rdataset) { 104| 1.28k| dns_rdatalist_t *rdatalist = NULL; 105| | 106| 1.28k| rdatalist = rdataset->rdlist.list; 107| 1.28k| rdataset->rdlist.iter = ISC_LIST_HEAD(rdatalist->rdata); ------------------ | | 62| 1.28k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 108| | 109| 1.28k| if (rdataset->rdlist.iter == NULL) { ------------------ | Branch (109:6): [True: 0, False: 1.28k] ------------------ 110| 0| return ISC_R_NOMORE; 111| 0| } 112| | 113| 1.28k| return ISC_R_SUCCESS; 114| 1.28k|} dns__rdatalist_next: 117| 6|dns__rdatalist_next(dns_rdataset_t *rdataset) { 118| 6| dns_rdata_t *rdata; 119| | 120| 6| rdata = rdataset->rdlist.iter; 121| 6| if (rdata == NULL) { ------------------ | Branch (121:6): [True: 0, False: 6] ------------------ 122| 0| return ISC_R_NOMORE; 123| 0| } 124| | 125| 6| rdataset->rdlist.iter = ISC_LIST_NEXT(rdata, link); ------------------ | | 140| 6|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 126| | 127| 6| if (rdataset->rdlist.iter == NULL) { ------------------ | Branch (127:6): [True: 6, False: 0] ------------------ 128| 6| return ISC_R_NOMORE; 129| 6| } 130| | 131| 0| return ISC_R_SUCCESS; 132| 6|} dns__rdatalist_current: 135| 1.28k|dns__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 136| 1.28k| dns_rdata_t *list_rdata; 137| | 138| 1.28k| list_rdata = rdataset->rdlist.iter; 139| 1.28k| INSIST(list_rdata != NULL); ------------------ | | 198| 1.28k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.28k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.28k, False: 0] | | | | ------------------ | | | | 55| 1.28k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 140| | 141| 1.28k| dns_rdata_clone(list_rdata, rdata); 142| 1.28k|} dns__rdatalist_count: 156| 6|dns__rdatalist_count(dns_rdataset_t *rdataset) { 157| 6| dns_rdatalist_t *rdatalist = NULL; 158| 6| unsigned int count; 159| | 160| 6| REQUIRE(rdataset != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 161| | 162| 6| rdatalist = rdataset->rdlist.list; 163| | 164| 6| count = 0; 165| 6| ISC_LIST_FOREACH(rdatalist->rdata, rdata, link) { ------------------ | | 234| 6| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 6| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 6|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 6, False: 0] | | ------------------ | | 236| 12| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 6, False: 6] | | ------------------ | | 237| 6| elt = elt##_next, \ | | 238| 6| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 6] | | ------------------ ------------------ 166| 6| count++; 167| 6| } 168| | 169| 6| return count; 170| 6|} dns__rdatalist_setownercase: 360| 1.12k|dns__rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) { 361| 1.12k| dns_rdatalist_t *rdatalist; 362| 1.12k| unsigned int i; 363| | 364| | /* 365| | * We do not need to worry about label lengths as they are all 366| | * less than or equal to 63. 367| | */ 368| 1.12k| rdatalist = rdataset->rdlist.list; 369| 1.12k| memset(rdatalist->upper, 0, sizeof(rdatalist->upper)); 370| 6.30k| for (i = 1; i < name->length; i++) { ------------------ | Branch (370:14): [True: 5.17k, False: 1.12k] ------------------ 371| 5.17k| if (name->ndata[i] >= 0x41 && name->ndata[i] <= 0x5a) { ------------------ | Branch (371:7): [True: 4.02k, False: 1.15k] | Branch (371:33): [True: 0, False: 4.02k] ------------------ 372| 0| rdatalist->upper[i / 8] |= 1 << (i % 8); 373| 0| } 374| 5.17k| } 375| | /* 376| | * Record that upper has been set. 377| | */ 378| 1.12k| rdatalist->upper[0] |= 0x01; 379| 1.12k|} dns_rdataset_init: 56| 4.12k|dns_rdataset_init(dns_rdataset_t *rdataset) { 57| | /* 58| | * Make 'rdataset' a valid, disassociated rdataset. 59| | */ 60| | 61| 4.12k| REQUIRE(rdataset != NULL); ------------------ | | 194| 4.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.12k, False: 0] | | | | ------------------ | | | | 43| 4.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 62| | 63| 4.12k| *rdataset = (dns_rdataset_t){ 64| 4.12k| .magic = DNS_RDATASET_MAGIC, ------------------ | | 92| 4.12k|#define DNS_RDATASET_MAGIC ISC_MAGIC('D', 'N', 'S', 'R') | | ------------------ | | | | 31| 4.12k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 65| 4.12k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.12k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.12k| { \ | | | | 27| 4.12k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.12k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.12k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.12k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.12k| } | | ------------------ ------------------ 66| 4.12k| }; 67| 4.12k|} dns_rdataset_invalidate: 70| 4|dns_rdataset_invalidate(dns_rdataset_t *rdataset) { 71| | /* 72| | * Invalidate 'rdataset'. 73| | */ 74| | 75| 4| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 76| 4| REQUIRE(rdataset->methods == NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 77| | 78| 4| *rdataset = (dns_rdataset_t){ 79| 4| .magic = 0, 80| 4| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4| { \ | | | | 27| 4| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4| } | | ------------------ ------------------ 81| 4| }; 82| 4|} dns__rdataset_disassociate: 85| 3.05k|dns__rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 86| | /* 87| | * Disassociate 'rdataset' from its rdata, allowing it to be reused. 88| | */ 89| | 90| 3.05k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 3.05k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.11k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.05k, False: 0] | | | | | Branch (42:11): [True: 3.05k, False: 0] | | | | ------------------ | | | | 43| 3.05k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 91| 3.05k| REQUIRE(rdataset->methods != NULL); ------------------ | | 194| 3.05k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.05k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.05k, False: 0] | | | | ------------------ | | | | 43| 3.05k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 92| | 93| 3.05k| if (rdataset->methods->disassociate != NULL) { ------------------ | Branch (93:6): [True: 3.05k, False: 0] ------------------ 94| 3.05k| (rdataset->methods->disassociate)(rdataset DNS__DB_FLARG_PASS); 95| 3.05k| } 96| 3.05k| *rdataset = (dns_rdataset_t){ 97| 3.05k| .magic = DNS_RDATASET_MAGIC, ------------------ | | 92| 3.05k|#define DNS_RDATASET_MAGIC ISC_MAGIC('D', 'N', 'S', 'R') | | ------------------ | | | | 31| 3.05k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 98| 3.05k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 3.05k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 3.05k| { \ | | | | 27| 3.05k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.05k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 3.05k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.05k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 3.05k| } | | ------------------ ------------------ 99| 3.05k| }; 100| 3.05k|} dns_rdataset_isassociated: 103| 7.92k|dns_rdataset_isassociated(const dns_rdataset_t *rdataset) { 104| | /* 105| | * Is 'rdataset' associated? 106| | */ 107| | 108| 7.92k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 7.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 15.8k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 7.92k, False: 0] | | | | | Branch (42:11): [True: 7.92k, False: 0] | | | | ------------------ | | | | 43| 7.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 109| | 110| 7.92k| if (rdataset->methods != NULL) { ------------------ | Branch (110:6): [True: 707, False: 7.21k] ------------------ 111| 707| return true; 112| 707| } 113| | 114| 7.21k| return false; 115| 7.92k|} dns_rdataset_count: 152| 6|dns_rdataset_count(dns_rdataset_t *rdataset) { 153| | /* 154| | * Return the number of records in 'rdataset'. 155| | */ 156| | 157| 6| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 158| 6| REQUIRE(rdataset->methods != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 159| 6| REQUIRE(rdataset->methods->count != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 160| | 161| 6| return (rdataset->methods->count)(rdataset); 162| 6|} dns_rdataset_first: 180| 1.41k|dns_rdataset_first(dns_rdataset_t *rdataset) { 181| 1.41k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.83k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.41k, False: 0] | | | | | Branch (42:11): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 182| 1.41k| REQUIRE(rdataset->methods != NULL); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 183| 1.41k| REQUIRE(rdataset->methods->first != NULL); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 184| | 185| 1.41k| isc_result_t result = rdataset->methods->first(rdataset); 186| 1.41k| ENSURE(result == ISC_R_SUCCESS || result == ISC_R_NOMORE); ------------------ | | 196| 1.41k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:11): [True: 1.41k, False: 0] | | | | | Branch (48:11): [True: 0, False: 0] | | | | ------------------ | | | | 49| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 187| 1.41k| return result; 188| 1.41k|} dns_rdataset_next: 191| 141|dns_rdataset_next(dns_rdataset_t *rdataset) { 192| 141| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 141|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 282| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 141, False: 0] | | | | | Branch (42:11): [True: 141, False: 0] | | | | ------------------ | | | | 43| 141| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 193| 141| REQUIRE(rdataset->methods != NULL); ------------------ | | 194| 141|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 141| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 141, False: 0] | | | | ------------------ | | | | 43| 141| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 194| 141| REQUIRE(rdataset->methods->next != NULL); ------------------ | | 194| 141|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 141| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 141, False: 0] | | | | ------------------ | | | | 43| 141| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 195| | 196| 141| isc_result_t result = rdataset->methods->next(rdataset); 197| 141| ENSURE(result == ISC_R_SUCCESS || result == ISC_R_NOMORE); ------------------ | | 196| 141|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 282| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:11): [True: 0, False: 141] | | | | | Branch (48:11): [True: 141, False: 0] | | | | ------------------ | | | | 49| 141| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 198| 141| return result; 199| 141|} dns_rdataset_current: 202| 1.41k|dns_rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 203| | /* 204| | * Make 'rdata' refer to the current rdata. 205| | */ 206| | 207| 1.41k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.83k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.41k, False: 0] | | | | | Branch (42:11): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 208| 1.41k| REQUIRE(rdataset->methods != NULL); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 209| 1.41k| REQUIRE(rdataset->methods->current != NULL); ------------------ | | 194| 1.41k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.41k, False: 0] | | | | ------------------ | | | | 43| 1.41k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 210| | 211| 1.41k| (rdataset->methods->current)(rdataset, rdata); 212| 1.41k|} dns_rdataset_setownercase: 541| 1.12k|dns_rdataset_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) { 542| 1.12k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 194| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.12k, False: 0] | | | | | Branch (42:11): [True: 1.12k, False: 0] | | | | ------------------ | | | | 43| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 543| 1.12k| REQUIRE(rdataset->methods != NULL); ------------------ | | 194| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.12k, False: 0] | | | | ------------------ | | | | 43| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 544| | 545| 1.12k| if (rdataset->methods->setownercase != NULL && ------------------ | Branch (545:6): [True: 1.12k, False: 0] ------------------ 546| 1.12k| !rdataset->attributes.keepcase) ------------------ | Branch (546:6): [True: 1.12k, False: 0] ------------------ 547| 1.12k| { 548| 1.12k| (rdataset->methods->setownercase)(rdataset, name); 549| 1.12k| } 550| 1.12k|} dns_rdatavec_fromrdataset: 343| 6| isc_region_t *region, uint32_t maxrrperset) { 344| 6| isc_result_t result; 345| | 346| 6| if (rdataset->type == dns_rdatatype_none && ------------------ | | 114| 12|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (346:6): [True: 0, False: 6] ------------------ 347| 0| rdataset->covers == dns_rdatatype_none) ------------------ | | 114| 0|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (347:6): [True: 0, False: 0] ------------------ 348| 0| { 349| 0| return DNS_R_DISALLOWED; 350| 0| } 351| | 352| 6| result = makevec(rdataset, mctx, region, maxrrperset); 353| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (353:6): [True: 6, False: 0] ------------------ 354| 6| dns_vecheader_t *new = (dns_vecheader_t *)region->base; 355| 6| dns_typepair_t typepair; 356| | 357| 6| if (rdataset->attributes.negative) { ------------------ | Branch (357:7): [True: 0, False: 6] ------------------ 358| 0| INSIST(rdataset->type == dns_rdatatype_none); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 359| 0| INSIST(rdataset->covers != dns_rdatatype_none); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 360| 0| typepair = DNS_TYPEPAIR_VALUE(rdataset->covers, ------------------ | | 47| 0| ({ \ | | 48| 0| DNS__TYPEPAIR_CHECK(base, covers); \ | | ------------------ | | | | 26| 0|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 49| 0| DNS__TYPEPAIR_VALUE(base, covers); \ | | ------------------ | | | | 44| 0| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 0| (((uint32_t)base) & 0xffff)) | | ------------------ | | 50| 0| }) ------------------ 361| 0| dns_rdatatype_none); 362| 6| } else { 363| 6| INSIST(rdataset->type != dns_rdatatype_none); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 364| 6| INSIST(dns_rdatatype_issig(rdataset->type) || ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 0, False: 6] | | | | | Branch (54:11): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 365| 6| rdataset->covers == dns_rdatatype_none); 366| 6| typepair = DNS_TYPEPAIR_VALUE(rdataset->type, ------------------ | | 47| 6| ({ \ | | 48| 6| DNS__TYPEPAIR_CHECK(base, covers); \ | | ------------------ | | | | 26| 6|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 49| 6| DNS__TYPEPAIR_VALUE(base, covers); \ | | ------------------ | | | | 44| 6| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 45| 6| (((uint32_t)base) & 0xffff)) | | ------------------ | | 50| 6| }) ------------------ 367| 6| rdataset->covers); 368| 6| } 369| | 370| | /* 371| | * Reset the vecheader content, but keep the refcount and mctx. 372| | */ 373| 6| *new = (dns_vecheader_t){ 374| 6| .next_header = ISC_SLINK_INITIALIZER, ------------------ | | 30| 6| { \ | | 31| 6| .next = NULL, \ | | 32| 6| } ------------------ 375| 6| .typepair = typepair, 376| 6| .trust = rdataset->trust, 377| 6| .ttl = rdataset->ttl, 378| 6| .references = atomic_load_acquire(&new->references), ------------------ | | 50| 6|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 379| 6| .mctx = new->mctx, 380| 6| }; 381| 6| } 382| | 383| 6| return result; 384| 6|} dns_rdatavec_size: 387| 6|dns_rdatavec_size(dns_vecheader_t *header) { 388| 6| REQUIRE(header != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 389| | 390| 6| unsigned char *vec = rdatavec_raw(header); 391| 6| INSIST(vec != NULL); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 392| | 393| 6| unsigned char *current = rdatavec_data(header); 394| 6| uint16_t count = rdatavec_count(header); 395| | 396| 12| while (count-- > 0) { ------------------ | Branch (396:9): [True: 6, False: 6] ------------------ 397| 6| uint16_t length = get_uint16(current); ------------------ | | 41| 6| ({ \ | | 42| 6| uint16_t __ret = peek_uint16(buffer); \ | | ------------------ | | | | 39| 6|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | | | ------------------ | | | | | | 224| 6|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | | | ------------------ | | ------------------ | | 43| 6| buffer += sizeof(uint16_t); \ | | 44| 6| __ret; \ | | 45| 6| }) ------------------ 398| 6| current += length; 399| 6| } 400| | 401| 6| return (unsigned int)(current - vec) + header_size(header); 402| 6|} dns_rdatavec_count: 405| 6|dns_rdatavec_count(dns_vecheader_t *header) { 406| 6| REQUIRE(header != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 407| | 408| 6| return rdatavec_count(header); 409| 6|} dns_vecheader_setownercase: 827| 6|dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name) { 828| 6| REQUIRE(!CASESET(header)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 829| | 830| 6| bool casefullylower = true; 831| | 832| | /* 833| | * We do not need to worry about label lengths as they are all 834| | * less than or equal to 63. 835| | */ 836| 6| memset(header->upper, 0, sizeof(header->upper)); 837| 60| for (size_t i = 0; i < name->length; i++) { ------------------ | Branch (837:21): [True: 54, False: 6] ------------------ 838| 54| if (isupper(name->ndata[i])) { ------------------ | Branch (838:7): [True: 0, False: 54] ------------------ 839| 0| header->upper[i / 8] |= 1 << (i % 8); 840| 0| casefullylower = false; 841| 0| } 842| 54| } 843| 6| if (casefullylower) { ------------------ | Branch (843:6): [True: 6, False: 0] ------------------ 844| 6| DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASEFULLYLOWER); ------------------ | | 143| 6| atomic_fetch_or_release(&(header)->attributes, attribute) | | ------------------ | | | | 58| 6| atomic_fetch_or_explicit((o), (v), memory_order_release) | | ------------------ ------------------ 845| 6| } 846| | DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASESET); ------------------ | | 143| 6| atomic_fetch_or_release(&(header)->attributes, attribute) | | ------------------ | | | | 58| 6| atomic_fetch_or_explicit((o), (v), memory_order_release) | | ------------------ ------------------ 847| 6|} vecheader_first: 865| 136| dns_rdataclass_t rdclass) { 866| 136| unsigned char *raw = rdatavec_data(header); 867| 136| uint16_t count = rdatavec_count(header); 868| 136| if (count == 0) { ------------------ | Branch (868:6): [True: 0, False: 136] ------------------ 869| 0| iter->iter_pos = NULL; 870| 0| iter->iter_count = 0; 871| 0| return ISC_R_NOMORE; 872| 0| } 873| | 874| | /* 875| | * iter.iter_count is the number of rdata beyond the cursor 876| | * position, so we decrement the total count by one before 877| | * storing it. 878| | * 879| | * 'raw' points to the first record. 880| | */ 881| 136| iter->iter_pos = raw; 882| 136| iter->iter_count = count - 1; 883| 136| iter->iter_rdclass = rdclass; 884| 136| iter->iter_type = DNS_TYPEPAIR_TYPE(header->typepair); ------------------ | | 30| 136| ({ \ | | 31| 136| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 32| 136| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 33| 136| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 26| 136|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 34| 136| __base; \ | | 35| 136| }) ------------------ 885| | 886| 136| return ISC_R_SUCCESS; 887| 136|} vecheader_next: 890| 135|vecheader_next(rdatavec_iter_t *iter) { 891| 135| uint16_t count = iter->iter_count; 892| 135| if (count == 0) { ------------------ | Branch (892:6): [True: 135, False: 0] ------------------ 893| 135| iter->iter_pos = NULL; 894| 135| return ISC_R_NOMORE; 895| 135| } 896| 0| iter->iter_count = count - 1; 897| | 898| | /* 899| | * Skip forward one record (length + 4) or one offset (4). 900| | */ 901| 0| unsigned char *raw = iter->iter_pos; 902| 0| uint16_t length = peek_uint16(raw); ------------------ | | 39| 0|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | ------------------ | | | | 224| 0|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | ------------------ ------------------ 903| 0| raw += length; 904| 0| iter->iter_pos = raw + sizeof(uint16_t); 905| | 906| 0| return ISC_R_SUCCESS; 907| 135|} vecheader_current: 910| 136|vecheader_current(rdatavec_iter_t *iter, dns_rdata_t *rdata) { 911| 136| unsigned char *raw = NULL; 912| 136| unsigned int length; 913| 136| isc_region_t r; 914| 136| unsigned int flags = 0; 915| | 916| 136| raw = iter->iter_pos; 917| 136| REQUIRE(raw != NULL); ------------------ | | 194| 136|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 136| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 136, False: 0] | | | | ------------------ | | | | 43| 136| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 918| | 919| | /* 920| | * Find the start of the record if not already in iter_pos 921| | * then skip the length and order fields. 922| | */ 923| 136| length = get_uint16(raw); ------------------ | | 41| 136| ({ \ | | 42| 136| uint16_t __ret = peek_uint16(buffer); \ | | ------------------ | | | | 39| 136|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | | | ------------------ | | | | | | 224| 136|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | | | ------------------ | | ------------------ | | 43| 136| buffer += sizeof(uint16_t); \ | | 44| 136| __ret; \ | | 45| 136| }) ------------------ 924| | 925| 136| if (iter->iter_type == dns_rdatatype_rrsig) { ------------------ | | 160| 136|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (925:6): [True: 0, False: 136] ------------------ 926| 0| if (*raw & DNS_RDATAVEC_OFFLINE) { ------------------ | | 59| 0|#define DNS_RDATAVEC_OFFLINE 0x01 /* RRSIG is for offline DNSKEY */ ------------------ | Branch (926:7): [True: 0, False: 0] ------------------ 927| 0| flags |= DNS_RDATA_OFFLINE; ------------------ | | 167| 0|#define DNS_RDATA_OFFLINE 0x0002 /*%< RRSIG has a offline key. */ ------------------ 928| 0| } 929| 0| length--; 930| 0| raw++; 931| 0| } 932| 136| r.length = length; 933| 136| r.base = raw; 934| 136| dns_rdata_fromregion(rdata, iter->iter_rdclass, iter->iter_type, &r); 935| 136| rdata->flags |= flags; 936| 136|} dns_vectop_new: 1031| 6|dns_vectop_new(isc_mem_t *mctx, dns_typepair_t typepair) { 1032| 6| dns_vectop_t *top = isc_mem_get(mctx, sizeof(*top)); ------------------ | | 128| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1033| 6| *top = (dns_vectop_t){ 1034| 6| .next_type = ISC_SLINK_INITIALIZER, ------------------ | | 30| 6| { \ | | 31| 6| .next = NULL, \ | | 32| 6| } ------------------ 1035| 6| .headers = ISC_SLIST_INITIALIZER, ------------------ | | 25| 6| { \ | | 26| 6| .head = NULL, \ | | 27| 6| } ------------------ 1036| 6| .typepair = typepair, 1037| 6| }; 1038| | 1039| 6| return top; 1040| 6|} rdatavec.c:makevec: 149| 6| uint32_t maxrrperset) { 150| | /* 151| | * Use &removed as a sentinel pointer for duplicate 152| | * rdata as rdata.data == NULL is valid. 153| | */ 154| 6| static unsigned char removed; 155| 6| dns_rdata_t *rdata = NULL; 156| 6| unsigned char *rawbuf = NULL; 157| 6| unsigned int headerlen = sizeof(dns_vecheader_t); 158| 6| uint32_t buflen = headerlen + 2; 159| 6| isc_result_t result; 160| 6| unsigned int nitems; 161| 6| unsigned int nalloc; 162| 6| unsigned int length; 163| 6| size_t i; 164| 6| size_t rdatasize; 165| | 166| | /* 167| | * If the source rdataset is also a vec, we don't need 168| | * to do anything special, just copy the whole vec to a 169| | * new buffer. 170| | */ 171| 6| if (rdataset->methods == &dns_rdatavec_rdatasetmethods) { ------------------ | Branch (171:6): [True: 0, False: 6] ------------------ 172| 0| dns_vecheader_t *header = dns_vecheader_getheader(rdataset); 173| 0| buflen = dns_rdatavec_size(header); 174| | 175| 0| rawbuf = newvec(rdataset, mctx, region, buflen); 176| | 177| 0| INSIST(headerlen <= buflen); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 178| 0| memmove(rawbuf, (unsigned char *)header + headerlen, 179| 0| buflen - headerlen); 180| 0| return ISC_R_SUCCESS; 181| 0| } 182| | 183| | /* 184| | * If there are no rdata then we just need to allocate a header 185| | * with a zero record count. 186| | */ 187| 6| nitems = dns_rdataset_count(rdataset); 188| 6| if (nitems == 0) { ------------------ | Branch (188:6): [True: 0, False: 6] ------------------ 189| 0| if (rdataset->type != 0) { ------------------ | Branch (189:7): [True: 0, False: 0] ------------------ 190| 0| return ISC_R_FAILURE; 191| 0| } 192| 0| rawbuf = newvec(rdataset, mctx, region, buflen); 193| 0| put_uint16(rawbuf, 0); ------------------ | | 47| 0| { \ | | 48| 0| ISC_U16TO8_BE(buffer, val); \ | | ------------------ | | | | 221| 0| (p)[0] = (uint8_t)((v) >> 8); \ | | | | 222| 0| (p)[1] = (uint8_t)((v)); | | ------------------ | | 49| 0| (buffer) += sizeof(uint16_t); \ | | 50| 0| } ------------------ 194| 0| return ISC_R_SUCCESS; 195| 0| } 196| | 197| 6| if (maxrrperset > 0 && nitems > maxrrperset) { ------------------ | Branch (197:6): [True: 0, False: 6] | Branch (197:25): [True: 0, False: 0] ------------------ 198| 0| return DNS_R_TOOMANYRECORDS; 199| 0| } 200| | 201| 6| if (nitems > 0xffff) { ------------------ | Branch (201:6): [True: 0, False: 6] ------------------ 202| 0| return ISC_R_NOSPACE; 203| 0| } 204| | 205| | /* 206| | * Remember the original number of items. 207| | */ 208| 6| nalloc = nitems; 209| | 210| 6| RUNTIME_CHECK(!ckd_mul(&rdatasize, nalloc, sizeof(rdata[0]))); ------------------ | | 241| 6| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 6, False: 0] | | ------------------ ------------------ 211| 6| rdata = isc_mem_get(mctx, rdatasize); ------------------ | | 128| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 212| | 213| | /* 214| | * Save all of the rdata members into an array. 215| | */ 216| 6| result = dns_rdataset_first(rdataset); 217| 6| if (result != ISC_R_SUCCESS && result != ISC_R_NOMORE) { ------------------ | Branch (217:6): [True: 0, False: 6] | Branch (217:33): [True: 0, False: 0] ------------------ 218| 0| goto free_rdatas; 219| 0| } 220| 12| for (i = 0; i < nalloc && result == ISC_R_SUCCESS; i++) { ------------------ | Branch (220:14): [True: 6, False: 6] | Branch (220:28): [True: 6, False: 0] ------------------ 221| 6| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 222| 6| dns_rdata_init(&rdata[i]); 223| 6| dns_rdataset_current(rdataset, &rdata[i]); 224| 6| INSIST(rdata[i].data != &removed); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 225| 6| result = dns_rdataset_next(rdataset); 226| 6| } 227| 6| if (i != nalloc || result != ISC_R_NOMORE) { ------------------ | Branch (227:6): [True: 0, False: 6] | Branch (227:21): [True: 0, False: 6] ------------------ 228| | /* 229| | * Somehow we iterated over fewer rdatas than 230| | * dns_rdataset_count() said there were or there 231| | * were more items than dns_rdataset_count said 232| | * there were. 233| | */ 234| 0| result = ISC_R_FAILURE; 235| 0| goto free_rdatas; 236| 0| } 237| | 238| | /* 239| | * Put into DNSSEC order. 240| | */ 241| 6| if (nalloc > 1U) { ------------------ | Branch (241:6): [True: 0, False: 6] ------------------ 242| 0| qsort(rdata, nalloc, sizeof(rdata[0]), compare_rdata); 243| 0| } 244| | 245| | /* 246| | * Remove duplicates and compute the total storage required. 247| | * 248| | * If an rdata is not a duplicate, accumulate the storage size 249| | * required for the rdata. We do not store the class, type, etc, 250| | * just the rdata, so our overhead is 2 bytes for the number of 251| | * records, and 2 bytes for the length of each rdata, plus the 252| | * rdata itself. 253| | */ 254| 6| for (i = 1; i < nalloc; i++) { ------------------ | Branch (254:14): [True: 0, False: 6] ------------------ 255| 0| if (compare_rdata(&rdata[i - 1], &rdata[i]) == 0) { ------------------ | Branch (255:7): [True: 0, False: 0] ------------------ 256| 0| rdata[i - 1].data = &removed; 257| 0| nitems--; 258| 0| } else { 259| 0| buflen += 2 + rdata[i - 1].length; 260| | /* 261| | * Provide space to store the per RR meta data. 262| | */ 263| 0| if (rdataset->type == dns_rdatatype_rrsig) { ------------------ | | 160| 0|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (263:8): [True: 0, False: 0] ------------------ 264| 0| buflen++; 265| 0| } 266| 0| if (buflen - headerlen - 2 > DNS_RDATA_MAXLENGTH) { ------------------ | | 181| 0|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (266:8): [True: 0, False: 0] ------------------ 267| 0| result = ISC_R_NOSPACE; 268| 0| goto free_rdatas; 269| 0| } 270| 0| } 271| 0| } 272| | 273| | /* 274| | * Don't forget the last item! 275| | */ 276| 6| buflen += 2 + rdata[i - 1].length; 277| | 278| | /* 279| | * Provide space to store the per RR meta data. 280| | */ 281| 6| if (rdataset->type == dns_rdatatype_rrsig) { ------------------ | | 160| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (281:6): [True: 0, False: 6] ------------------ 282| 0| buflen++; 283| 0| } 284| 6| if (buflen - headerlen - 2 > DNS_RDATA_MAXLENGTH) { ------------------ | | 181| 6|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (284:6): [True: 0, False: 6] ------------------ 285| 0| result = ISC_R_NOSPACE; 286| 0| goto free_rdatas; 287| 0| } 288| | 289| | /* 290| | * Ensure that singleton types are actually singletons. 291| | */ 292| 6| if (nitems > 1 && dns_rdatatype_issingleton(rdataset->type)) { ------------------ | Branch (292:6): [True: 0, False: 6] | Branch (292:20): [True: 0, False: 0] ------------------ 293| | /* 294| | * We have a singleton type, but there's more than one 295| | * RR in the rdataset. 296| | */ 297| 0| result = DNS_R_SINGLETON; 298| 0| goto free_rdatas; 299| 0| } 300| | 301| | /* 302| | * Allocate the memory, set up a buffer, start copying in 303| | * data. 304| | */ 305| 6| rawbuf = newvec(rdataset, mctx, region, buflen); 306| 6| put_uint16(rawbuf, nitems); ------------------ | | 47| 6| { \ | | 48| 6| ISC_U16TO8_BE(buffer, val); \ | | ------------------ | | | | 221| 6| (p)[0] = (uint8_t)((v) >> 8); \ | | | | 222| 6| (p)[1] = (uint8_t)((v)); | | ------------------ | | 49| 6| (buffer) += sizeof(uint16_t); \ | | 50| 6| } ------------------ 307| | 308| 12| for (i = 0; i < nalloc; i++) { ------------------ | Branch (308:14): [True: 6, False: 6] ------------------ 309| 6| if (rdata[i].data == &removed) { ------------------ | Branch (309:7): [True: 0, False: 6] ------------------ 310| 0| continue; 311| 0| } 312| 6| length = rdata[i].length; 313| 6| if (rdataset->type == dns_rdatatype_rrsig) { ------------------ | | 160| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (313:7): [True: 0, False: 6] ------------------ 314| 0| length++; 315| 0| } 316| 6| INSIST(length <= 0xffff); ------------------ | | 198| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6, False: 0] | | | | ------------------ | | | | 55| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 317| | 318| 6| put_uint16(rawbuf, length); ------------------ | | 47| 6| { \ | | 48| 6| ISC_U16TO8_BE(buffer, val); \ | | ------------------ | | | | 221| 6| (p)[0] = (uint8_t)((v) >> 8); \ | | | | 222| 6| (p)[1] = (uint8_t)((v)); | | ------------------ | | 49| 6| (buffer) += sizeof(uint16_t); \ | | 50| 6| } ------------------ 319| | 320| | /* 321| | * Store the per RR meta data. 322| | */ 323| 6| if (rdataset->type == dns_rdatatype_rrsig) { ------------------ | | 160| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (323:7): [True: 0, False: 6] ------------------ 324| 0| *rawbuf++ = (rdata[i].flags & DNS_RDATA_OFFLINE) ------------------ | | 167| 0|#define DNS_RDATA_OFFLINE 0x0002 /*%< RRSIG has a offline key. */ ------------------ | Branch (324:16): [True: 0, False: 0] ------------------ 325| 0| ? DNS_RDATAVEC_OFFLINE ------------------ | | 59| 0|#define DNS_RDATAVEC_OFFLINE 0x01 /* RRSIG is for offline DNSKEY */ ------------------ 326| 0| : 0; 327| 0| } 328| 6| if (rdata[i].length != 0) { ------------------ | Branch (328:7): [True: 6, False: 0] ------------------ 329| 6| memmove(rawbuf, rdata[i].data, rdata[i].length); 330| 6| } 331| 6| rawbuf += rdata[i].length; 332| 6| } 333| | 334| 6| result = ISC_R_SUCCESS; 335| | 336| 6|free_rdatas: 337| | isc_mem_put(mctx, rdata, rdatasize); ------------------ | | 150| 6| do { \ | | 151| 6| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 6| (p) = NULL; \ | | 153| 6| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 6] | | ------------------ ------------------ 338| 6| return result; 339| 6|} rdatavec.c:newvec: 130| 6| size_t size) { 131| 6| dns_vecheader_t *header = isc_mem_get(mctx, size); ------------------ | | 128| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 132| | 133| 6| *header = (dns_vecheader_t){ 134| 6| .next_header = ISC_SLINK_INITIALIZER, ------------------ | | 30| 6| { \ | | 31| 6| .next = NULL, \ | | 32| 6| } ------------------ 135| 6| .trust = rdataset->trust, 136| 6| .ttl = rdataset->ttl, 137| 6| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 6|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 138| 6| .mctx = isc_mem_ref(mctx), 139| 6| }; 140| | 141| 6| region->base = (unsigned char *)header; 142| 6| region->length = size; 143| | 144| 6| return (unsigned char *)header + sizeof(*header); 145| 6|} rdatavec.c:rdatavec_raw: 108| 296|rdatavec_raw(dns_vecheader_t *header) { 109| 296| unsigned char *as_char_star = (unsigned char *)header; 110| 296| unsigned char *raw = as_char_star + header_size(header); 111| | 112| 296| return raw; 113| 296|} rdatavec.c:rdatavec_data: 116| 142|rdatavec_data(dns_vecheader_t *header) { 117| 142| return rdatavec_raw(header) + 2; 118| 142|} rdatavec.c:rdatavec_count: 121| 148|rdatavec_count(dns_vecheader_t *header) { 122| 148| unsigned char *raw = rdatavec_raw(header); 123| 148| unsigned int count = get_uint16(raw); ------------------ | | 41| 148| ({ \ | | 42| 148| uint16_t __ret = peek_uint16(buffer); \ | | ------------------ | | | | 39| 148|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | | | ------------------ | | | | | | 224| 148|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | | | ------------------ | | ------------------ | | 43| 148| buffer += sizeof(uint16_t); \ | | 44| 148| __ret; \ | | 45| 148| }) ------------------ 124| | 125| 148| return count; 126| 148|} rdatavec.c:header_size: 102| 302|header_size(const dns_vecheader_t *header) { 103| 302| UNUSED(header); ------------------ | | 65| 302|#define UNUSED(x) (void)(x) ------------------ 104| 302| return sizeof(dns_vecheader_t); 105| 302|} rdatavec.c:rdataset_disassociate: 941| 136|rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 942| 136| dns_vecheader_unref(rdataset->vec.header); 943| 136|} rdatavec.c:rdataset_first: 946| 136|rdataset_first(dns_rdataset_t *rdataset) { 947| 136| return vecheader_first(&rdataset->vec.iter, rdataset->vec.header, 948| 136| rdataset->rdclass); 949| 136|} rdatavec.c:rdataset_next: 952| 135|rdataset_next(dns_rdataset_t *rdataset) { 953| 135| return vecheader_next(&rdataset->vec.iter); 954| 135|} rdatavec.c:rdataset_current: 957| 136|rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 958| 136| vecheader_current(&rdataset->vec.iter, rdata); 959| 136|} dns__tsig_algvalid: 100| 554|dns__tsig_algvalid(unsigned int alg) { 101| 554| return alg == DST_ALG_HMACMD5 || alg == DST_ALG_HMACSHA1 || ------------------ | Branch (101:9): [True: 1, False: 553] | Branch (101:35): [True: 2, False: 551] ------------------ 102| 551| alg == DST_ALG_HMACSHA224 || alg == DST_ALG_HMACSHA256 || ------------------ | Branch (102:9): [True: 1, False: 550] | Branch (102:38): [True: 232, False: 318] ------------------ 103| 318| alg == DST_ALG_HMACSHA384 || alg == DST_ALG_HMACSHA512; ------------------ | Branch (103:9): [True: 1, False: 317] | Branch (103:38): [True: 2, False: 315] ------------------ 104| 554|} dns_tsigkey_createfromkey: 174| 325| dns_tsigkey_t **keyp) { 175| 325| dns_tsigkey_t *tkey = NULL; 176| 325| isc_result_t result; 177| | 178| 325| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 194| 325|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 650| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 325, False: 0] | | | | | Branch (42:11): [True: 325, False: 0] | | | | ------------------ | | | | 43| 325| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 179| 325| REQUIRE(name != NULL); ------------------ | | 194| 325|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 325| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 325, False: 0] | | | | ------------------ | | | | 43| 325| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 180| 325| REQUIRE(mctx != NULL); ------------------ | | 194| 325|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 325| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 325, False: 0] | | | | ------------------ | | | | 43| 325| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 181| | 182| 325| tkey = isc_mem_get(mctx, sizeof(dns_tsigkey_t)); ------------------ | | 128| 325|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 183| 325| *tkey = (dns_tsigkey_t){ 184| 325| .generated = generated, 185| 325| .restored = restored, 186| 325| .inception = inception, 187| 325| .expire = expire, 188| 325| .alg = algorithm, 189| 325| .algname = DNS_NAME_INITEMPTY, ------------------ | | 183| 325| { .magic = DNS_NAME_MAGIC, \ | | ------------------ | | | | 121| 325|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | | | ------------------ | | | | | | 31| 325|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 184| 325| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 325|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 325| { \ | | | | | | 27| 325| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 325|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 325| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 325|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 325| } | | | | ------------------ | | ------------------ | | 185| 325| .list = ISC_LIST_INITIALIZER } | | ------------------ | | | | 21| 325| { \ | | | | 22| 325| .head = NULL, \ | | | | 23| 325| .tail = NULL, \ | | | | 24| 325| } | | ------------------ ------------------ 190| 325| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 325|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 325| { \ | | | | 27| 325| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 325|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 325| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 325|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 325| } | | ------------------ ------------------ 191| 325| }; 192| | 193| 325| tkey->name = dns_fixedname_initname(&tkey->fn); 194| 325| dns_name_copy(name, tkey->name); 195| 325| (void)dns_name_downcase(tkey->name, tkey->name); 196| | 197| 325| if (algorithm != DST_ALG_UNKNOWN) { ------------------ | Branch (197:6): [True: 11, False: 314] ------------------ 198| 11| if (dstkey != NULL && dst_key_alg(dstkey) != algorithm) { ------------------ | Branch (198:7): [True: 2, False: 9] | Branch (198:25): [True: 0, False: 2] ------------------ 199| 0| result = DNS_R_BADALG; 200| 0| goto cleanup_name; 201| 0| } 202| 314| } else if (dstkey != NULL) { ------------------ | Branch (202:13): [True: 0, False: 314] ------------------ 203| 0| result = DNS_R_BADALG; 204| 0| goto cleanup_name; 205| 0| } 206| | 207| 325| if (creator != NULL) { ------------------ | Branch (207:6): [True: 0, False: 325] ------------------ 208| 0| tkey->creator = isc_mem_get(mctx, sizeof(dns_name_t)); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 209| 0| dns_name_init(tkey->creator); 210| 0| dns_name_dup(creator, mctx, tkey->creator); 211| 0| } 212| | 213| 325| if (dstkey != NULL) { ------------------ | Branch (213:6): [True: 2, False: 323] ------------------ 214| 2| dst_key_attach(dstkey, &tkey->key); 215| 2| } 216| | 217| 325| isc_refcount_init(&tkey->references, 1); ------------------ | | 44| 325|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 218| 325| isc_mem_attach(mctx, &tkey->mctx); 219| | 220| | /* 221| | * Ignore this if it's a GSS key, since the key size is meaningless. 222| | */ 223| 325| if (dstkey != NULL && dst_key_size(dstkey) < 64 && ------------------ | Branch (223:6): [True: 2, False: 323] | Branch (223:24): [True: 0, False: 2] ------------------ 224| 0| algorithm != DST_ALG_GSSAPI) ------------------ | Branch (224:6): [True: 0, False: 0] ------------------ 225| 0| { 226| 0| char namestr[DNS_NAME_FORMATSIZE]; 227| 0| dns_name_format(name, namestr, sizeof(namestr)); 228| 0| isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, 229| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 230| 0| "the key '%s' is too short to be secure", 231| 0| namestr); 232| 0| } 233| | 234| 325| tkey->magic = TSIG_MAGIC; ------------------ | | 45| 325|#define TSIG_MAGIC ISC_MAGIC('T', 'S', 'I', 'G') | | ------------------ | | | | 31| 325|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 235| | 236| 325| if (tkey->restored) { ------------------ | Branch (236:6): [True: 0, False: 325] ------------------ 237| 0| tsig_log(tkey, ISC_LOG_DEBUG(3), "restored from file"); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 238| 325| } else if (tkey->generated) { ------------------ | Branch (238:13): [True: 0, False: 325] ------------------ 239| 0| tsig_log(tkey, ISC_LOG_DEBUG(3), "generated"); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 240| 325| } else { 241| 325| tsig_log(tkey, ISC_LOG_DEBUG(3), "statically configured"); ------------------ | | 36| 325|#define ISC_LOG_DEBUG(level) (level) ------------------ 242| 325| } 243| | 244| 325| SET_IF_NOT_NULL(keyp, tkey); ------------------ | | 100| 325| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 325, False: 0] | | ------------------ | | 101| 325| *(obj) = (val); \ | | 102| 325| } ------------------ 245| 325| return ISC_R_SUCCESS; 246| | 247| 0|cleanup_name: 248| 0| isc_mem_put(mctx, tkey, sizeof(dns_tsigkey_t)); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 249| | 250| 0| return result; 251| 325|} dns__tsig_algfromname: 297| 545|dns__tsig_algfromname(const dns_name_t *algorithm) { 298| 4.30k| for (size_t i = 0; i < ARRAY_SIZE(known_algs); ++i) { ------------------ | | 94| 4.30k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (298:21): [True: 3.77k, False: 530] ------------------ 299| 3.77k| const dns_name_t *name = known_algs[i].name; 300| 3.77k| if (algorithm == name || dns_name_equal(algorithm, name)) { ------------------ | Branch (300:7): [True: 0, False: 3.77k] | Branch (300:28): [True: 15, False: 3.75k] ------------------ 301| 15| return known_algs[i].dstalg; 302| 15| } 303| 3.77k| } 304| 530| return DST_ALG_UNKNOWN; 305| 545|} dns_tsigkey_create: 444| 325| dns_tsigkey_t **key) { 445| 325| dst_key_t *dstkey = NULL; 446| 325| isc_result_t result; 447| | 448| 325| REQUIRE(length >= 0); ------------------ | | 194| 325|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 325| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 325, False: 0] | | | | ------------------ | | | | 43| 325| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 449| 325| if (length > 0) { ------------------ | Branch (449:6): [True: 2, False: 323] ------------------ 450| 2| REQUIRE(secret != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 451| 2| } 452| | 453| 325| if (dns__tsig_algvalid(algorithm)) { ------------------ | Branch (453:6): [True: 10, False: 315] ------------------ 454| 10| if (secret != NULL) { ------------------ | Branch (454:7): [True: 2, False: 8] ------------------ 455| 2| isc_buffer_t b; 456| | 457| 2| isc_buffer_init(&b, secret, length); 458| 2| isc_buffer_add(&b, length); 459| 2| RETERR(dst_key_frombuffer( ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 460| 2| name, algorithm, 0, DNS_KEYPROTO_DNSSEC, 461| 2| dns_rdataclass_in, &b, mctx, &dstkey)); 462| 2| } 463| 315| } else if (length > 0) { ------------------ | Branch (463:13): [True: 0, False: 315] ------------------ 464| 0| return DNS_R_BADALG; 465| 0| } 466| | 467| 325| result = dns_tsigkey_createfromkey(name, algorithm, dstkey, false, 468| 325| false, NULL, 0, 0, mctx, key); 469| 325| if (dstkey != NULL) { ------------------ | Branch (469:6): [True: 2, False: 323] ------------------ 470| 2| dst_key_free(&dstkey); 471| 2| } 472| 325| return result; 473| 325|} dns_tsig_verify: 799| 614| dns_tsigkeyring_t *ring1, dns_tsigkeyring_t *ring2) { 800| 614| dns_rdata_any_tsig_t tsig, querytsig; 801| 614| isc_region_t r, source_r, header_r, sig_r; 802| 614| isc_buffer_t databuf; 803| 614| unsigned char data[32]; 804| 614| dns_name_t *keyname = NULL; 805| 614| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 614| { \ | | 148| 614| .data = NULL, \ | | 149| 614| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 614|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 614| { \ | | | | | | 27| 614| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 614|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 614| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 614|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 614| } | | | | ------------------ | | ------------------ | | 150| 614| } ------------------ 806| 614| isc_stdtime_t now; 807| 614| isc_result_t result; 808| 614| dns_tsigkey_t *tsigkey = NULL; 809| 614| dst_key_t *key = NULL; 810| 614| unsigned char header[DNS_MESSAGE_HEADERLEN]; 811| 614| dst_context_t *ctx = NULL; 812| 614| isc_mem_t *mctx = NULL; 813| 614| uint16_t addcount, id; 814| 614| unsigned int siglen; 815| 614| unsigned int alg; 816| 614| bool response; 817| | 818| 614| REQUIRE(source != NULL); ------------------ | | 194| 614|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 614| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 614, False: 0] | | | | ------------------ | | | | 43| 614| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 819| 614| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 194| 614|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.22k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 614, False: 0] | | | | | Branch (42:11): [True: 614, False: 0] | | | | ------------------ | | | | 43| 614| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 820| 614| tsigkey = dns_message_gettsigkey(msg); 821| 614| response = is_response(msg); ------------------ | | 48| 614|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) ------------------ 822| | 823| 614| REQUIRE(tsigkey == NULL || VALID_TSIGKEY(tsigkey)); ------------------ | | 194| 614|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.48k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 289, False: 0] | | | | | Branch (42:11): [True: 289, False: 0] | | | | | Branch (42:11): [True: 325, False: 289] | | | | ------------------ | | | | 43| 614| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 824| | 825| 614| msg->verify_attempted = 1; 826| 614| msg->verified_sig = 0; 827| 614| msg->tsigstatus = dns_tsigerror_badsig; 828| | 829| 614| if (msg->tcp_continuation) { ------------------ | Branch (829:6): [True: 0, False: 614] ------------------ 830| 0| if (tsigkey == NULL || msg->querytsig == NULL) { ------------------ | Branch (830:7): [True: 0, False: 0] | Branch (830:26): [True: 0, False: 0] ------------------ 831| 0| return DNS_R_UNEXPECTEDTSIG; 832| 0| } 833| 0| return tsig_verify_tcp(source, msg); 834| 0| } 835| | 836| | /* 837| | * There should be a TSIG record... 838| | */ 839| 614| if (msg->tsig == NULL) { ------------------ | Branch (839:6): [True: 39, False: 575] ------------------ 840| 39| return DNS_R_EXPECTEDTSIG; 841| 39| } 842| | 843| | /* 844| | * If this is a response and there's no key or query TSIG, there 845| | * shouldn't be one on the response. 846| | */ 847| 575| if (response && (tsigkey == NULL || msg->querytsig == NULL)) { ------------------ | Branch (847:6): [True: 170, False: 405] | Branch (847:19): [True: 1, False: 169] | Branch (847:38): [True: 2, False: 167] ------------------ 848| 3| return DNS_R_UNEXPECTEDTSIG; 849| 3| } 850| | 851| 572| mctx = msg->mctx; 852| | 853| | /* 854| | * If we're here, we know the message is well formed and contains a 855| | * TSIG record. 856| | */ 857| | 858| 572| keyname = msg->tsigname; 859| 572| RETERR(dns_rdataset_first(msg->tsig)); ------------------ | | 272| 572| { \ | | 273| 572| isc_result_t _r = (x); \ | | 274| 572| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 572] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 572| } ------------------ 860| 572| dns_rdataset_current(msg->tsig, &rdata); 861| 572| RETERR(dns_rdata_tostruct(&rdata, &tsig, NULL)); ------------------ | | 272| 572| { \ | | 273| 572| isc_result_t _r = (x); \ | | 274| 572| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 572] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 572| } ------------------ 862| 572| dns_rdata_reset(&rdata); 863| 572| if (response) { ------------------ | Branch (863:6): [True: 167, False: 405] ------------------ 864| 167| RETERR(dns_rdataset_first(msg->querytsig)); ------------------ | | 272| 167| { \ | | 273| 167| isc_result_t _r = (x); \ | | 274| 167| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 167] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 167| } ------------------ 865| 167| dns_rdataset_current(msg->querytsig, &rdata); 866| 167| RETERR(dns_rdata_tostruct(&rdata, &querytsig, NULL)); ------------------ | | 272| 167| { \ | | 273| 167| isc_result_t _r = (x); \ | | 274| 167| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 167] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 167| } ------------------ 867| 167| } 868| | 869| | /* 870| | * Do the key name and algorithm match that of the query? 871| | */ 872| 572| if (response && ------------------ | Branch (872:6): [True: 167, False: 405] ------------------ 873| 167| (!dns_name_equal(keyname, tsigkey->name) || ------------------ | Branch (873:7): [True: 0, False: 167] ------------------ 874| 167| !dns_name_equal(&tsig.algorithm, &querytsig.algorithm))) ------------------ | Branch (874:7): [True: 34, False: 133] ------------------ 875| 34| { 876| 34| msg->tsigstatus = dns_tsigerror_badkey; 877| 34| tsig_log(msg->tsigkey, 2, 878| 34| "key name and algorithm do not match"); 879| 34| return DNS_R_TSIGVERIFYFAILURE; 880| 34| } 881| | 882| | /* 883| | * Get the current time. 884| | */ 885| 538| if (msg->fuzzing) { ------------------ | Branch (885:6): [True: 538, False: 0] ------------------ 886| 538| now = msg->fuzztime; 887| 538| } else { 888| 0| now = isc_stdtime_now(); 889| 0| } 890| | 891| | /* 892| | * Find dns_tsigkey_t based on keyname. 893| | */ 894| 538| if (tsigkey == NULL) { ------------------ | Branch (894:6): [True: 324, False: 214] ------------------ 895| 324| result = ISC_R_NOTFOUND; 896| 324| if (ring1 != NULL) { ------------------ | Branch (896:7): [True: 311, False: 13] ------------------ 897| 311| result = dns_tsigkey_find(&tsigkey, keyname, 898| 311| &tsig.algorithm, ring1); 899| 311| } 900| 324| if (result == ISC_R_NOTFOUND && ring2 != NULL) { ------------------ | Branch (900:7): [True: 323, False: 1] | Branch (900:35): [True: 310, False: 13] ------------------ 901| 310| result = dns_tsigkey_find(&tsigkey, keyname, 902| 310| &tsig.algorithm, ring2); 903| 310| } 904| 324| if (result != ISC_R_SUCCESS) { ------------------ | Branch (904:7): [True: 323, False: 1] ------------------ 905| 323| msg->tsigstatus = dns_tsigerror_badkey; 906| 323| alg = dns__tsig_algfromname(&tsig.algorithm); 907| 323| RETERR(dns_tsigkey_create(keyname, alg, NULL, 0, mctx, ------------------ | | 272| 323| { \ | | 273| 323| isc_result_t _r = (x); \ | | 274| 323| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 323] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 323| } ------------------ 908| 323| &msg->tsigkey)); 909| 323| if (alg == DST_ALG_UNKNOWN) { ------------------ | Branch (909:8): [True: 314, False: 9] ------------------ 910| 314| dns_name_clone(&tsig.algorithm, 911| 314| &msg->tsigkey->algname); 912| 314| } 913| | 914| 323| tsig_log(msg->tsigkey, 2, "unknown key"); 915| 323| return DNS_R_TSIGVERIFYFAILURE; 916| 323| } 917| 1| msg->tsigkey = tsigkey; 918| 1| } 919| | 920| 215| key = tsigkey->key; 921| | 922| | /* 923| | * Check digest length. 924| | */ 925| 215| alg = dst_key_alg(key); 926| 215| RETERR(dst_key_sigsize(key, &siglen)); ------------------ | | 272| 215| { \ | | 273| 215| isc_result_t _r = (x); \ | | 274| 215| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 215] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 215| } ------------------ 927| 215| if (dns__tsig_algvalid(alg)) { ------------------ | Branch (927:6): [True: 215, False: 0] ------------------ 928| 215| if (tsig.siglen > siglen) { ------------------ | Branch (928:7): [True: 22, False: 193] ------------------ 929| 22| tsig_log(msg->tsigkey, 2, "signature length too big"); 930| 22| return DNS_R_FORMERR; 931| 22| } 932| 193| if (tsig.siglen > 0 && ------------------ | Branch (932:7): [True: 59, False: 134] ------------------ 933| 59| (tsig.siglen < 10 || tsig.siglen < ((siglen + 1) / 2))) ------------------ | Branch (933:8): [True: 10, False: 49] | Branch (933:28): [True: 3, False: 46] ------------------ 934| 13| { 935| 13| tsig_log(msg->tsigkey, 2, 936| 13| "signature length below minimum"); 937| 13| return DNS_R_FORMERR; 938| 13| } 939| 193| } 940| | 941| 180| if (tsig.siglen > 0) { ------------------ | Branch (941:6): [True: 46, False: 134] ------------------ 942| 46| uint16_t addcount_n; 943| | 944| 46| sig_r.base = tsig.signature; 945| 46| sig_r.length = tsig.siglen; 946| | 947| 46| RETERR(dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, ------------------ | | 272| 46| { \ | | 273| 46| isc_result_t _r = (x); \ | | 274| 46| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 46] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 46| } ------------------ 948| 46| false, &ctx)); 949| | 950| 46| if (response) { ------------------ | Branch (950:7): [True: 3, False: 43] ------------------ 951| 3| isc_buffer_init(&databuf, data, sizeof(data)); 952| 3| isc_buffer_putuint16(&databuf, querytsig.siglen); 953| 3| isc_buffer_usedregion(&databuf, &r); 954| 3| result = dst_context_adddata(ctx, &r); 955| 3| if (result != ISC_R_SUCCESS) { ------------------ | Branch (955:8): [True: 0, False: 3] ------------------ 956| 0| goto cleanup_context; 957| 0| } 958| 3| if (querytsig.siglen > 0) { ------------------ | Branch (958:8): [True: 3, False: 0] ------------------ 959| 3| r.length = querytsig.siglen; 960| 3| r.base = querytsig.signature; 961| 3| result = dst_context_adddata(ctx, &r); 962| 3| if (result != ISC_R_SUCCESS) { ------------------ | Branch (962:9): [True: 0, False: 3] ------------------ 963| 0| goto cleanup_context; 964| 0| } 965| 3| } 966| 3| } 967| | 968| | /* 969| | * Extract the header. 970| | */ 971| 46| isc_buffer_usedregion(source, &r); 972| 46| memmove(header, r.base, DNS_MESSAGE_HEADERLEN); ------------------ | | 145| 46|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 973| 46| isc_region_consume(&r, DNS_MESSAGE_HEADERLEN); ------------------ | | 50| 46| do { \ | | 51| 46| isc_region_t *_r = (r); \ | | 52| 46| unsigned int _l = (l); \ | | 53| 46| INSIST(_r->length >= _l); \ | | ------------------ | | | | 198| 46|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 46| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 55| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 46| _r->base += _l; \ | | 55| 46| _r->length -= _l; \ | | 56| 46| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 46] | | ------------------ ------------------ 974| | 975| | /* 976| | * Decrement the additional field counter. 977| | */ 978| 46| memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2); ------------------ | | 145| 46|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 979| 46| addcount_n = ntohs(addcount); 980| 46| addcount = htons((uint16_t)(addcount_n - 1)); 981| 46| memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2); ------------------ | | 145| 46|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 982| | 983| | /* 984| | * Put in the original id. 985| | */ 986| 46| id = htons(tsig.originalid); 987| 46| memmove(&header[0], &id, 2); 988| | 989| | /* 990| | * Digest the modified header. 991| | */ 992| 46| header_r.base = (unsigned char *)header; 993| 46| header_r.length = DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 46|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 994| 46| result = dst_context_adddata(ctx, &header_r); 995| 46| if (result != ISC_R_SUCCESS) { ------------------ | Branch (995:7): [True: 0, False: 46] ------------------ 996| 0| goto cleanup_context; 997| 0| } 998| | 999| | /* 1000| | * Digest all non-TSIG records. 1001| | */ 1002| 46| isc_buffer_usedregion(source, &source_r); 1003| 46| r.base = source_r.base + DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 46|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1004| 46| r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 46|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1005| 46| result = dst_context_adddata(ctx, &r); 1006| 46| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1006:7): [True: 0, False: 46] ------------------ 1007| 0| goto cleanup_context; 1008| 0| } 1009| | 1010| | /* 1011| | * Digest the key name. 1012| | */ 1013| 46| dns_name_toregion(tsigkey->name, &r); 1014| 46| result = dst_context_adddata(ctx, &r); 1015| 46| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1015:7): [True: 0, False: 46] ------------------ 1016| 0| goto cleanup_context; 1017| 0| } 1018| | 1019| 46| isc_buffer_init(&databuf, data, sizeof(data)); 1020| 46| isc_buffer_putuint16(&databuf, tsig.common.rdclass); 1021| 46| isc_buffer_putuint32(&databuf, msg->tsig->ttl); 1022| 46| isc_buffer_usedregion(&databuf, &r); 1023| 46| result = dst_context_adddata(ctx, &r); 1024| 46| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1024:7): [True: 0, False: 46] ------------------ 1025| 0| goto cleanup_context; 1026| 0| } 1027| | 1028| | /* 1029| | * Digest the key algorithm. 1030| | */ 1031| 46| dns_name_toregion(dns_tsigkey_algorithm(tsigkey), &r); 1032| 46| result = dst_context_adddata(ctx, &r); 1033| 46| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1033:7): [True: 0, False: 46] ------------------ 1034| 0| goto cleanup_context; 1035| 0| } 1036| | 1037| 46| isc_buffer_clear(&databuf); 1038| 46| isc_buffer_putuint48(&databuf, tsig.timesigned); 1039| 46| isc_buffer_putuint16(&databuf, tsig.fudge); 1040| 46| isc_buffer_putuint16(&databuf, tsig.error); 1041| 46| isc_buffer_putuint16(&databuf, tsig.otherlen); 1042| 46| isc_buffer_usedregion(&databuf, &r); 1043| 46| result = dst_context_adddata(ctx, &r); 1044| 46| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1044:7): [True: 0, False: 46] ------------------ 1045| 0| goto cleanup_context; 1046| 0| } 1047| | 1048| 46| if (tsig.otherlen > 0) { ------------------ | Branch (1048:7): [True: 29, False: 17] ------------------ 1049| 29| r.base = tsig.other; 1050| 29| r.length = tsig.otherlen; 1051| 29| result = dst_context_adddata(ctx, &r); 1052| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1052:8): [True: 0, False: 29] ------------------ 1053| 0| goto cleanup_context; 1054| 0| } 1055| 29| } 1056| | 1057| 46| result = dst_context_verify(ctx, &sig_r); 1058| 46| if (result == DST_R_VERIFYFAILURE) { ------------------ | Branch (1058:7): [True: 40, False: 6] ------------------ 1059| 40| result = DNS_R_TSIGVERIFYFAILURE; 1060| 40| tsig_log(msg->tsigkey, 2, 1061| 40| "signature failed to verify(1)"); 1062| 40| goto cleanup_context; 1063| 40| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1063:14): [True: 0, False: 6] ------------------ 1064| 0| goto cleanup_context; 1065| 0| } 1066| 6| msg->verified_sig = 1; 1067| 134| } else if (!response || (tsig.error != dns_tsigerror_badsig && ------------------ | Branch (1067:13): [True: 7, False: 127] | Branch (1067:27): [True: 76, False: 51] ------------------ 1068| 76| tsig.error != dns_tsigerror_badkey)) ------------------ | Branch (1068:6): [True: 19, False: 57] ------------------ 1069| 26| { 1070| 26| tsig_log(msg->tsigkey, 2, "signature was empty"); 1071| 26| return DNS_R_TSIGVERIFYFAILURE; 1072| 26| } 1073| | 1074| | /* 1075| | * Here at this point, the MAC has been verified. Even if any of 1076| | * the following code returns a TSIG error, the reply will be 1077| | * signed and WILL always include the request MAC in the digest 1078| | * computation. 1079| | */ 1080| | 1081| | /* 1082| | * Is the time ok? 1083| | */ 1084| 114| if (now + msg->timeadjust > tsig.timesigned + tsig.fudge) { ------------------ | Branch (1084:6): [True: 1, False: 113] ------------------ 1085| 1| msg->tsigstatus = dns_tsigerror_badtime; 1086| 1| tsig_log(msg->tsigkey, 2, "signature has expired"); 1087| 1| result = DNS_R_CLOCKSKEW; 1088| 1| goto cleanup_context; 1089| 113| } else if (now + msg->timeadjust < tsig.timesigned - tsig.fudge) { ------------------ | Branch (1089:13): [True: 99, False: 14] ------------------ 1090| 99| msg->tsigstatus = dns_tsigerror_badtime; 1091| 99| tsig_log(msg->tsigkey, 2, "signature is in the future"); 1092| 99| result = DNS_R_CLOCKSKEW; 1093| 99| goto cleanup_context; 1094| 99| } 1095| | 1096| 14| if (dns__tsig_algvalid(alg)) { ------------------ | Branch (1096:6): [True: 14, False: 0] ------------------ 1097| 14| uint16_t digestbits = dst_key_getbits(key); 1098| | 1099| 14| if (tsig.siglen > 0 && digestbits != 0 && ------------------ | Branch (1099:7): [True: 6, False: 8] | Branch (1099:26): [True: 0, False: 6] ------------------ 1100| 0| tsig.siglen < ((digestbits + 7) / 8)) ------------------ | Branch (1100:7): [True: 0, False: 0] ------------------ 1101| 0| { 1102| 0| msg->tsigstatus = dns_tsigerror_badtrunc; 1103| 0| tsig_log(msg->tsigkey, 2, 1104| 0| "truncated signature length too small"); 1105| 0| result = DNS_R_TSIGVERIFYFAILURE; 1106| 0| goto cleanup_context; 1107| 0| } 1108| 14| if (tsig.siglen > 0 && digestbits == 0 && tsig.siglen < siglen) ------------------ | Branch (1108:7): [True: 6, False: 8] | Branch (1108:26): [True: 6, False: 0] | Branch (1108:45): [True: 4, False: 2] ------------------ 1109| 4| { 1110| 4| msg->tsigstatus = dns_tsigerror_badtrunc; 1111| 4| tsig_log(msg->tsigkey, 2, "signature length too small"); 1112| 4| result = DNS_R_TSIGVERIFYFAILURE; 1113| 4| goto cleanup_context; 1114| 4| } 1115| 14| } 1116| | 1117| 10| if (response && tsig.error != dns_rcode_noerror) { ------------------ | | 269| 9|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ | Branch (1117:6): [True: 9, False: 1] | Branch (1117:18): [True: 8, False: 1] ------------------ 1118| 8| msg->tsigstatus = tsig.error; 1119| 8| if (tsig.error == dns_tsigerror_badtime) { ------------------ | Branch (1119:7): [True: 0, False: 8] ------------------ 1120| 0| result = DNS_R_CLOCKSKEW; 1121| 8| } else { 1122| 8| result = DNS_R_TSIGERRORSET; 1123| 8| } 1124| 8| goto cleanup_context; 1125| 8| } 1126| | 1127| 2| msg->tsigstatus = dns_rcode_noerror; ------------------ | | 269| 2|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 1128| 2| result = ISC_R_SUCCESS; 1129| | 1130| 154|cleanup_context: 1131| 154| if (ctx != NULL) { ------------------ | Branch (1131:6): [True: 46, False: 108] ------------------ 1132| 46| dst_context_destroy(&ctx); 1133| 46| } 1134| | 1135| 154| return result; 1136| 2|} dns_tsigkey_find: 1455| 621| const dns_name_t *algorithm, dns_tsigkeyring_t *ring) { 1456| 621| dns_tsigkey_t *key = NULL; 1457| 621| isc_result_t result; 1458| 621| isc_rwlocktype_t locktype = isc_rwlocktype_read; 1459| 621| isc_stdtime_t now = isc_stdtime_now(); 1460| | 1461| 621| REQUIRE(name != NULL); ------------------ | | 194| 621|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 621| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 621, False: 0] | | | | ------------------ | | | | 43| 621| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1462| 621| REQUIRE(VALID_TSIGKEYRING(ring)); ------------------ | | 194| 621|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 621, False: 0] | | | | | Branch (42:11): [True: 621, False: 0] | | | | ------------------ | | | | 43| 621| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1463| 621| REQUIRE(tsigkey != NULL && *tsigkey == NULL); ------------------ | | 194| 621|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 621, False: 0] | | | | | Branch (42:11): [True: 621, False: 0] | | | | ------------------ | | | | 43| 621| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1464| | 1465| 621|again: 1466| 621| RWLOCK(&ring->lock, locktype); ------------------ | | 30| 621| { \ | | 31| 621| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 621| (t), __FILE__, __LINE__)); \ | | 33| 621| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 621| { \ | | | | 253| 621| switch (type) { \ | | | | 254| 621| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 621, False: 0] | | | | ------------------ | | | | 255| 621| isc_rwlock_rdlock(rwl); \ | | | | 256| 621| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 621] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 621] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 621| } \ | | | | 263| 621| } | | ------------------ | | 34| 621| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 621| (lp), (t), __FILE__, __LINE__)); \ | | 36| 621| } ------------------ 1467| 621| result = isc_hashmap_find(ring->keys, dns_name_hash(name), tkey_match, 1468| 621| name, (void **)&key); 1469| 621| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (1469:6): [True: 399, False: 222] ------------------ 1470| 399| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 399| { \ | | 39| 399| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 399| (lp), (t), __FILE__, __LINE__)); \ | | 41| 399| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 399| { \ | | | | 283| 399| switch (type) { \ | | | | 284| 399| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 399, False: 0] | | | | ------------------ | | | | 285| 399| isc_rwlock_rdunlock(rwl); \ | | | | 286| 399| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 399] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 399] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 399| } \ | | | | 293| 399| } | | ------------------ | | 42| 399| } ------------------ 1471| 399| return result; 1472| 399| } 1473| | 1474| 222| if (algorithm != NULL && key->alg != dns__tsig_algfromname(algorithm)) { ------------------ | Branch (1474:6): [True: 222, False: 0] | Branch (1474:27): [True: 221, False: 1] ------------------ 1475| 221| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 221| { \ | | 39| 221| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 221| (lp), (t), __FILE__, __LINE__)); \ | | 41| 221| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 221| { \ | | | | 283| 221| switch (type) { \ | | | | 284| 221| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 221, False: 0] | | | | ------------------ | | | | 285| 221| isc_rwlock_rdunlock(rwl); \ | | | | 286| 221| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 221] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 221] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 221| } \ | | | | 293| 221| } | | ------------------ | | 42| 221| } ------------------ 1476| 221| return ISC_R_NOTFOUND; 1477| 221| } 1478| 1| if (key->inception != key->expire && isc_serial_lt(key->expire, now)) { ------------------ | Branch (1478:6): [True: 0, False: 1] | Branch (1478:39): [True: 0, False: 0] ------------------ 1479| | /* 1480| | * The key has expired. 1481| | */ 1482| 0| if (locktype == isc_rwlocktype_read) { ------------------ | Branch (1482:7): [True: 0, False: 0] ------------------ 1483| 0| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 0| { \ | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 0| { \ | | | | 283| 0| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 0] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 0] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 0] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 1484| 0| locktype = isc_rwlocktype_write; 1485| 0| key = NULL; 1486| 0| goto again; 1487| 0| } 1488| 0| dns__tsigkey_delete(ring, key); 1489| 0| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 0| { \ | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 0| { \ | | | | 283| 0| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 0] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 0] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 0] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 1490| 0| return ISC_R_NOTFOUND; 1491| 0| } 1492| 1| dns_tsigkey_ref(key); 1493| 1| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 1| { \ | | 39| 1| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 1| (lp), (t), __FILE__, __LINE__)); \ | | 41| 1| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 1| { \ | | | | 283| 1| switch (type) { \ | | | | 284| 1| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 1, False: 0] | | | | ------------------ | | | | 285| 1| isc_rwlock_rdunlock(rwl); \ | | | | 286| 1| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 1] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 1] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 1| } \ | | | | 293| 1| } | | ------------------ | | 42| 1| } ------------------ 1494| 1| adjust_lru(ring, key); 1495| 1| *tsigkey = key; 1496| 1| return ISC_R_SUCCESS; 1497| 1|} dns_tsigkey_algorithm: 1500| 46|dns_tsigkey_algorithm(dns_tsigkey_t *tkey) { 1501| 46| REQUIRE(VALID_TSIGKEY(tkey)); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 92| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 46, False: 0] | | | | | Branch (42:11): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1502| | 1503| 46| switch (tkey->alg) { 1504| 0| case DST_ALG_HMACMD5: ------------------ | Branch (1504:2): [True: 0, False: 46] ------------------ 1505| 0| return dns_tsig_hmacmd5_name; 1506| 0| case DST_ALG_HMACSHA1: ------------------ | Branch (1506:2): [True: 0, False: 46] ------------------ 1507| 0| return dns_tsig_hmacsha1_name; 1508| 0| case DST_ALG_HMACSHA224: ------------------ | Branch (1508:2): [True: 0, False: 46] ------------------ 1509| 0| return dns_tsig_hmacsha224_name; 1510| 46| case DST_ALG_HMACSHA256: ------------------ | Branch (1510:2): [True: 46, False: 0] ------------------ 1511| 46| return dns_tsig_hmacsha256_name; 1512| 0| case DST_ALG_HMACSHA384: ------------------ | Branch (1512:2): [True: 0, False: 46] ------------------ 1513| 0| return dns_tsig_hmacsha384_name; 1514| 0| case DST_ALG_HMACSHA512: ------------------ | Branch (1514:2): [True: 0, False: 46] ------------------ 1515| 0| return dns_tsig_hmacsha512_name; 1516| 0| case DST_ALG_GSSAPI: ------------------ | Branch (1516:2): [True: 0, False: 46] ------------------ 1517| 0| return dns_tsig_gssapi_name; 1518| | 1519| 0| case DST_ALG_UNKNOWN: ------------------ | Branch (1519:2): [True: 0, False: 46] ------------------ 1520| | /* 1521| | * If the tsigkey object was created with an 1522| | * unknown algorithm, then we cloned 1523| | * the algorithm name here. 1524| | */ 1525| 0| return &tkey->algname; 1526| | 1527| 0| default: ------------------ | Branch (1527:2): [True: 0, False: 46] ------------------ 1528| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1529| 46| } 1530| 46|} dns_tsigkeyring_create: 1533| 6|dns_tsigkeyring_create(isc_mem_t *mctx, dns_tsigkeyring_t **ringp) { 1534| 6| dns_tsigkeyring_t *ring = NULL; 1535| | 1536| 6| REQUIRE(mctx != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1537| 6| REQUIRE(ringp != NULL && *ringp == NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1538| | 1539| 6| ring = isc_mem_get(mctx, sizeof(dns_tsigkeyring_t)); ------------------ | | 128| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1540| 6| *ring = (dns_tsigkeyring_t){ 1541| 6| .lru = ISC_LIST_INITIALIZER, ------------------ | | 21| 6| { \ | | 22| 6| .head = NULL, \ | | 23| 6| .tail = NULL, \ | | 24| 6| } ------------------ 1542| 6| }; 1543| | 1544| 6| isc_hashmap_create(mctx, 12, &ring->keys); 1545| 6| isc_rwlock_init(&ring->lock); 1546| 6| isc_mem_attach(mctx, &ring->mctx); 1547| 6| isc_refcount_init(&ring->references, 1); ------------------ | | 44| 6|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 1548| 6| ring->magic = TSIGKEYRING_MAGIC; ------------------ | | 42| 6|#define TSIGKEYRING_MAGIC ISC_MAGIC('T', 'K', 'R', 'g') | | ------------------ | | | | 31| 6|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1549| | 1550| 6| *ringp = ring; 1551| 6|} dns_tsigkeyring_add: 1554| 2|dns_tsigkeyring_add(dns_tsigkeyring_t *ring, dns_tsigkey_t *tkey) { 1555| 2| isc_result_t result; 1556| | 1557| 2| REQUIRE(VALID_TSIGKEY(tkey)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1558| 2| REQUIRE(VALID_TSIGKEYRING(ring)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1559| | 1560| 2| RWLOCK(&ring->lock, isc_rwlocktype_write); ------------------ | | 30| 2| { \ | | 31| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 2| (t), __FILE__, __LINE__)); \ | | 33| 2| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 2| { \ | | | | 253| 2| switch (type) { \ | | | | 254| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 0, False: 2] | | | | ------------------ | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | 256| 0| break; \ | | | | 257| 2| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 2, False: 0] | | | | ------------------ | | | | 258| 2| isc_rwlock_wrlock(rwl); \ | | | | 259| 2| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 2] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 2| } \ | | | | 263| 2| } | | ------------------ | | 34| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 2| (lp), (t), __FILE__, __LINE__)); \ | | 36| 2| } ------------------ 1561| 2| result = isc_hashmap_add(ring->keys, dns_name_hash(tkey->name), 1562| 2| tkey_match, tkey->name, tkey, NULL); 1563| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1563:6): [True: 2, False: 0] ------------------ 1564| 2| dns_tsigkey_ref(tkey); 1565| | 1566| | /* 1567| | * If this is a TKEY-generated key, add it to the LRU list, 1568| | * and if we've exceeded the quota for generated keys, 1569| | * remove the least recently used one from the both the 1570| | * list and the RBT. 1571| | */ 1572| 2| if (tkey->generated) { ------------------ | Branch (1572:7): [True: 0, False: 2] ------------------ 1573| 0| ISC_LIST_APPEND(ring->lru, tkey, link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 1574| 0| if (++ring->generated > DNS_TSIG_MAXGENERATEDKEYS) { ------------------ | | 61| 0|#define DNS_TSIG_MAXGENERATEDKEYS 4096 ------------------ | Branch (1574:8): [True: 0, False: 0] ------------------ 1575| 0| dns_tsigkey_t *key = ISC_LIST_HEAD(ring->lru); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1576| 0| dns__tsigkey_delete(ring, key); 1577| 0| } 1578| 0| } 1579| 2| } 1580| 2| RWUNLOCK(&ring->lock, isc_rwlocktype_write); ------------------ | | 38| 2| { \ | | 39| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 2| (lp), (t), __FILE__, __LINE__)); \ | | 41| 2| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 2| { \ | | | | 283| 2| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 2] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 2| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 2, False: 0] | | | | ------------------ | | | | 288| 2| isc_rwlock_wrunlock(rwl); \ | | | | 289| 2| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 2] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 1581| | 1582| 2| return result; 1583| 2|} tsig.c:tsig_log: 107| 887|tsig_log(dns_tsigkey_t *key, int level, const char *fmt, ...) { 108| 887| va_list ap; 109| 887| char message[4096]; 110| 887| char namestr[DNS_NAME_FORMATSIZE]; 111| 887| char creatorstr[DNS_NAME_FORMATSIZE]; 112| | 113| 887| if (!isc_log_wouldlog(level)) { ------------------ | Branch (113:6): [True: 887, False: 0] ------------------ 114| 887| return; 115| 887| } 116| 0| if (key != NULL) { ------------------ | Branch (116:6): [True: 0, False: 0] ------------------ 117| 0| dns_name_format(key->name, namestr, sizeof(namestr)); 118| 0| } else { 119| 0| strlcpy(namestr, "", sizeof(namestr)); 120| 0| } 121| | 122| 0| if (key != NULL && key->generated && key->creator != NULL) { ------------------ | Branch (122:6): [True: 0, False: 0] | Branch (122:21): [True: 0, False: 0] | Branch (122:39): [True: 0, False: 0] ------------------ 123| 0| dns_name_format(key->creator, creatorstr, sizeof(creatorstr)); 124| 0| } else { 125| 0| strlcpy(creatorstr, "", sizeof(creatorstr)); 126| 0| } 127| | 128| 0| va_start(ap, fmt); 129| 0| vsnprintf(message, sizeof(message), fmt, ap); 130| 0| va_end(ap); 131| 0| if (key != NULL && key->generated) { ------------------ | Branch (131:6): [True: 0, False: 0] | Branch (131:21): [True: 0, False: 0] ------------------ 132| 0| isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, level, 133| 0| "tsig key '%s' (%s): %s", namestr, creatorstr, 134| 0| message); 135| 0| } else { 136| 0| isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, level, 137| 0| "tsig key '%s': %s", namestr, message); 138| 0| } 139| 0|} tsig.c:destroy_tsigkey: 476| 323|destroy_tsigkey(dns_tsigkey_t *key) { 477| 323| REQUIRE(VALID_TSIGKEY(key)); ------------------ | | 194| 323|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 646| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 323, False: 0] | | | | | Branch (42:11): [True: 323, False: 0] | | | | ------------------ | | | | 43| 323| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 478| | 479| 323| key->magic = 0; 480| 323| if (key->key != NULL) { ------------------ | Branch (480:6): [True: 0, False: 323] ------------------ 481| 0| dst_key_free(&key->key); 482| 0| } 483| 323| if (key->creator != NULL) { ------------------ | Branch (483:6): [True: 0, False: 323] ------------------ 484| 0| dns_name_free(key->creator, key->mctx); 485| 0| isc_mem_put(key->mctx, key->creator, sizeof(dns_name_t)); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 486| 0| } 487| | isc_mem_putanddetach(&key->mctx, key, sizeof(dns_tsigkey_t)); ------------------ | | 161| 323| do { \ | | 162| 323| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 323| (p) = NULL; \ | | 164| 323| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 323] | | ------------------ ------------------ 488| 323|} tsig.c:tkey_match: 142| 222|tkey_match(void *node, const void *key) { 143| 222| dns_tsigkey_t *tkey = node; 144| | 145| 222| return dns_name_equal(tkey->name, key); 146| 222|} tsig.c:adjust_lru: 154| 1|adjust_lru(dns_tsigkeyring_t *ring, dns_tsigkey_t *tkey) { 155| 1| if (tkey->generated) { ------------------ | Branch (155:6): [True: 0, False: 1] ------------------ 156| 0| RWLOCK(&ring->lock, isc_rwlocktype_write); ------------------ | | 30| 0| { \ | | 31| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 0| (t), __FILE__, __LINE__)); \ | | 33| 0| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 0| { \ | | | | 253| 0| switch (type) { \ | | | | 254| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 0, False: 0] | | | | ------------------ | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | 256| 0| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 0] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 0] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 0| } \ | | | | 263| 0| } | | ------------------ | | 34| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 0| (lp), (t), __FILE__, __LINE__)); \ | | 36| 0| } ------------------ 157| | /* 158| | * We may have been removed from the LRU list between 159| | * removing the read lock and acquiring the write lock. 160| | */ 161| 0| if (ISC_LINK_LINKED(tkey, link) && ring->lru.tail != tkey) { ------------------ | | 60| 0|#define ISC_LINK_LINKED(elt, link) ISC_LINK_LINKED_TYPE(elt, link, void) | | ------------------ | | | | 59| 0| ((type *)((elt)->link.prev) != ISC_LINK_TOMBSTONE(type)) | | | | ------------------ | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | | Branch (59:2): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (161:38): [True: 0, False: 0] ------------------ 162| 0| ISC_LIST_UNLINK(ring->lru, tkey, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 163| 0| ISC_LIST_APPEND(ring->lru, tkey, link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 164| 0| } 165| 0| RWUNLOCK(&ring->lock, isc_rwlocktype_write); ------------------ | | 38| 0| { \ | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 0| { \ | | | | 283| 0| switch (type) { \ | | | | 284| 0| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 0, False: 0] | | | | ------------------ | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | 286| 0| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 0] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 0] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 166| 0| } 167| 1|} dns_counter_fromtext: 124| 8|dns_counter_fromtext(isc_textregion_t *source, uint32_t *ttl) { 125| 8| return bind_ttl(source, ttl); 126| 8|} dns_ttl_fromtext: 129| 6|dns_ttl_fromtext(isc_textregion_t *source, uint32_t *ttl) { 130| 6| isc_result_t result; 131| | 132| 6| result = bind_ttl(source, ttl); 133| 6| if (result != ISC_R_SUCCESS && result != ISC_R_RANGE) { ------------------ | Branch (133:6): [True: 0, False: 6] | Branch (133:33): [True: 0, False: 0] ------------------ 134| 0| result = DNS_R_BADTTL; 135| 0| } 136| 6| return result; 137| 6|} ttl.c:bind_ttl: 140| 14|bind_ttl(isc_textregion_t *source, uint32_t *ttl) { 141| 14| uint64_t tmp = 0ULL; 142| 14| uint32_t n; 143| 14| char *s; 144| 14| char buf[64]; 145| 14| char nbuf[64]; /* Number buffer */ 146| | 147| | /* 148| | * Copy the buffer as it may not be NULL terminated. 149| | * No legal counter / ttl is longer that 63 characters. 150| | */ 151| 14| if (source->length > sizeof(buf) - 1) { ------------------ | Branch (151:6): [True: 0, False: 14] ------------------ 152| 0| return DNS_R_SYNTAX; 153| 0| } 154| | /* Copy source->length bytes and NUL terminate. */ 155| 14| snprintf(buf, sizeof(buf), "%.*s", (int)source->length, source->base); 156| 14| s = buf; 157| | 158| 14| do { 159| 14| isc_result_t result; 160| | 161| 14| char *np = nbuf; 162| 28| while (*s != '\0' && isdigit((unsigned char)*s)) { ------------------ | Branch (162:10): [True: 14, False: 14] | Branch (162:24): [True: 14, False: 0] ------------------ 163| 14| *np++ = *s++; 164| 14| } 165| 14| *np++ = '\0'; 166| 14| INSIST(np - nbuf <= (int)sizeof(nbuf)); ------------------ | | 198| 14|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 14, False: 0] | | | | ------------------ | | | | 55| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 167| 14| result = isc_parse_uint32(&n, nbuf, 10); 168| 14| if (result != ISC_R_SUCCESS) { ------------------ | Branch (168:7): [True: 0, False: 14] ------------------ 169| 0| return DNS_R_SYNTAX; 170| 0| } 171| 14| switch (*s) { 172| 0| case 'w': ------------------ | Branch (172:3): [True: 0, False: 14] ------------------ 173| 0| case 'W': ------------------ | Branch (173:3): [True: 0, False: 14] ------------------ 174| 0| tmp += (uint64_t)n * 7 * 24 * 3600; 175| 0| s++; 176| 0| break; 177| 0| case 'd': ------------------ | Branch (177:3): [True: 0, False: 14] ------------------ 178| 0| case 'D': ------------------ | Branch (178:3): [True: 0, False: 14] ------------------ 179| 0| tmp += (uint64_t)n * 24 * 3600; 180| 0| s++; 181| 0| break; 182| 0| case 'h': ------------------ | Branch (182:3): [True: 0, False: 14] ------------------ 183| 0| case 'H': ------------------ | Branch (183:3): [True: 0, False: 14] ------------------ 184| 0| tmp += (uint64_t)n * 3600; 185| 0| s++; 186| 0| break; 187| 0| case 'm': ------------------ | Branch (187:3): [True: 0, False: 14] ------------------ 188| 0| case 'M': ------------------ | Branch (188:3): [True: 0, False: 14] ------------------ 189| 0| tmp += (uint64_t)n * 60; 190| 0| s++; 191| 0| break; 192| 0| case 's': ------------------ | Branch (192:3): [True: 0, False: 14] ------------------ 193| 0| case 'S': ------------------ | Branch (193:3): [True: 0, False: 14] ------------------ 194| 0| tmp += (uint64_t)n; 195| 0| s++; 196| 0| break; 197| 14| case '\0': ------------------ | Branch (197:3): [True: 14, False: 0] ------------------ 198| | /* Plain number? */ 199| 14| if (tmp != 0ULL) { ------------------ | Branch (199:8): [True: 0, False: 14] ------------------ 200| 0| return DNS_R_SYNTAX; 201| 0| } 202| 14| tmp = n; 203| 14| break; 204| 0| default: ------------------ | Branch (204:3): [True: 0, False: 14] ------------------ 205| 0| return DNS_R_SYNTAX; 206| 14| } 207| 14| } while (*s != '\0'); ------------------ | Branch (207:11): [True: 0, False: 14] ------------------ 208| | 209| 14| if (tmp > 0xffffffffULL) { ------------------ | Branch (209:6): [True: 0, False: 14] ------------------ 210| 0| return ISC_R_RANGE; 211| 0| } 212| | 213| 14| *ttl = (uint32_t)(tmp & 0xffffffffUL); 214| 14| return ISC_R_SUCCESS; 215| 14|} dns_unreachcache_new: 89| 2| const uint16_t backoff_eligible_s) { 90| 2| REQUIRE(expire_min_s > 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 91| 2| REQUIRE(expire_min_s <= expire_max_s); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 92| | 93| 2| dns_unreachcache_t *uc = isc_mem_get(mctx, sizeof(*uc)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 94| 2| *uc = (dns_unreachcache_t){ 95| 2| .magic = UNREACHCACHE_MAGIC, ------------------ | | 57| 2|#define UNREACHCACHE_MAGIC ISC_MAGIC('U', 'R', 'C', 'a') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 96| 2| .expire_min_s = expire_min_s, 97| 2| .expire_max_s = expire_max_s, 98| 2| .backoff_eligible_s = backoff_eligible_s, 99| 2| }; 100| | 101| 2| uc->ht = cds_lfht_new(UNREACHCACHE_INIT_SIZE, UNREACHCACHE_MIN_SIZE, 0, ------------------ | | 60| 2|#define UNREACHCACHE_INIT_SIZE (1 << 4) /* Must be power of 2 */ ------------------ uc->ht = cds_lfht_new(UNREACHCACHE_INIT_SIZE, UNREACHCACHE_MIN_SIZE, 0, ------------------ | | 61| 2|#define UNREACHCACHE_MIN_SIZE (1 << 5) /* Must be power of 2 */ ------------------ 102| 2| CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); 103| 2| INSIST(uc->ht != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 104| | 105| 2| isc_mutex_init(&uc->lru_lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 106| 2| CDS_INIT_LIST_HEAD(&uc->lru); 107| | 108| 2| isc_mem_attach(mctx, &uc->mctx); 109| | 110| 2| return uc; 111| 2|} dns_view_create: 113| 2| dns_view_t **viewp) { 114| 2| dns_view_t *view = NULL; 115| 2| isc_result_t result; 116| 2| char buffer[1024]; 117| | 118| 2| REQUIRE(name != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 119| 2| REQUIRE(viewp != NULL && *viewp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 120| | 121| 2| result = isc_file_sanitize(NULL, name, "nta", buffer, sizeof(buffer)); 122| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 123| | 124| 2| view = isc_mem_get(mctx, sizeof(*view)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 125| 2| *view = (dns_view_t){ 126| 2| .rdclass = rdclass, 127| 2| .name = isc_mem_strdup(mctx, name), ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 128| 2| .nta_file = isc_mem_strdup(mctx, buffer), ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 129| 2| .recursion = true, 130| 2| .enablevalidation = true, 131| 2| .minimalresponses = dns_minimal_no, 132| 2| .transfer_format = dns_one_answer, 133| 2| .msgcompression = true, 134| 2| .provideixfr = true, 135| 2| .maxcachettl = 7 * 24 * 3600, 136| 2| .maxncachettl = 3 * 3600, 137| 2| .dstport = 53, 138| 2| .staleanswerttl = 1, 139| 2| .staleanswersok = dns_stale_answer_conf, 140| 2| .sendcookie = true, 141| 2| .synthfromdnssec = true, 142| 2| .trust_anchor_telemetry = true, 143| 2| .root_key_sentinel = true, 144| 2| .udpsize = DEFAULT_EDNS_BUFSIZE, ------------------ | | 78| 2|#define DEFAULT_EDNS_BUFSIZE 1232 ------------------ 145| 2| .max_restarts = DEFAULT_MAX_RESTARTS, ------------------ | | 73| 2|#define DEFAULT_MAX_RESTARTS 11 ------------------ 146| 2| }; 147| | 148| 2| isc_refcount_init(&view->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 149| 2| isc_refcount_init(&view->weakrefs, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 150| | 151| 2| dns_fixedname_init(&view->redirectfixed); 152| | 153| 2| ISC_LIST_INIT(view->dlz_searched); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 154| 2| ISC_LIST_INIT(view->dlz_unsearched); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 155| 2| ISC_LIST_INIT(view->dns64); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 156| | 157| 2| ISC_LINK_INIT(view, link); ------------------ | | 57| 2|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 2| do { \ | | | | 54| 2| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 2| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 2| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 158| | 159| 2| isc_mem_attach(mctx, &view->mctx); 160| | 161| 2| if (dispatchmgr != NULL) { ------------------ | Branch (161:6): [True: 0, False: 2] ------------------ 162| 0| dns_dispatchmgr_attach(dispatchmgr, &view->dispatchmgr); 163| 0| } 164| | 165| 2| isc_mutex_init(&view->lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 166| | 167| 2| dns_zt_create(mctx, view, &view->zonetable); 168| | 169| 2| dns_fwdtable_create(mctx, view, &view->fwdtable); 170| | 171| 2| dns_tsigkeyring_create(view->mctx, &view->dynamickeys); 172| | 173| 2| view->failcache = dns_badcache_new(view->mctx); 174| | 175| 2| view->unreachcache = dns_unreachcache_new( 176| 2| view->mctx, UNREACH_HOLD_TIME_INITIAL_SEC, ------------------ | | 81| 2|#define UNREACH_HOLD_TIME_INITIAL_SEC ((uint16_t)10) ------------------ 177| 2| UNREACH_HOLD_TIME_MAX_SEC, UNREACH_BACKOFF_ELIGIBLE_SEC); ------------------ | | 82| 2|#define UNREACH_HOLD_TIME_MAX_SEC (UNREACH_HOLD_TIME_INITIAL_SEC << 6) | | ------------------ | | | | 81| 2|#define UNREACH_HOLD_TIME_INITIAL_SEC ((uint16_t)10) | | ------------------ ------------------ UNREACH_HOLD_TIME_MAX_SEC, UNREACH_BACKOFF_ELIGIBLE_SEC); ------------------ | | 83| 2|#define UNREACH_BACKOFF_ELIGIBLE_SEC ((uint16_t)120) ------------------ 178| | 179| 2| isc_mutex_init(&view->newzone.lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 180| | 181| 2| dns_order_create(view->mctx, &view->order); 182| | 183| 2| dns_peerlist_new(view->mctx, &view->peers); 184| | 185| 2| dns_aclenv_create(view->mctx, &view->aclenv); 186| | 187| 2| dns_nametree_create(view->mctx, DNS_NAMETREE_COUNT, "sfd", &view->sfd); 188| | 189| 2| view->magic = DNS_VIEW_MAGIC; ------------------ | | 255| 2|#define DNS_VIEW_MAGIC ISC_MAGIC('V', 'i', 'e', 'w') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 190| 2| *viewp = view; 191| 2|} dns_view_weakattach: 527| 2|dns_view_weakattach(dns_view_t *source, dns_view_t **targetp) { 528| 2| REQUIRE(DNS_VIEW_VALID(source)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 529| 2| REQUIRE(targetp != NULL && *targetp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 530| | 531| 2| isc_refcount_increment(&source->weakrefs); ------------------ | | 81| 2| ({ \ | | 82| 2| uint_fast32_t __v; \ | | 83| 2| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 2| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 2| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:11): [True: 2, False: 0] | | | | | | | Branch (54:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 2| __v; \ | | 86| 2| }) ------------------ 532| | 533| 2| *targetp = source; 534| 2|} dns_view_setkeyring: 637| 1.13k|dns_view_setkeyring(dns_view_t *view, dns_tsigkeyring_t *ring) { 638| 1.13k| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 194| 1.13k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.13k, False: 0] | | | | | Branch (42:11): [True: 1.13k, False: 0] | | | | ------------------ | | | | 43| 1.13k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 639| 1.13k| REQUIRE(ring != NULL); ------------------ | | 194| 1.13k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.13k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.13k, False: 0] | | | | ------------------ | | | | 43| 1.13k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 640| 1.13k| if (view->statickeys != NULL) { ------------------ | Branch (640:6): [True: 1.13k, False: 1] ------------------ 641| 1.13k| dns_tsigkeyring_detach(&view->statickeys); 642| 1.13k| } 643| 1.13k| dns_tsigkeyring_attach(ring, &view->statickeys); 644| 1.13k|} dns_view_freeze: 693| 2|dns_view_freeze(dns_view_t *view) { 694| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 695| 2| REQUIRE(!view->frozen); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| | 697| 2| if (view->resolver != NULL) { ------------------ | Branch (697:6): [True: 0, False: 2] ------------------ 698| 0| INSIST(view->cachedb != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 699| 0| dns_resolver_freeze(view->resolver); 700| 0| } 701| | view->frozen = true; 702| 2|} dns_view_addzone: 713| 2|dns_view_addzone(dns_view_t *view, dns_zone_t *zone) { 714| 2| isc_result_t result; 715| 2| dns_zt_t *zonetable = NULL; 716| | 717| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 718| 2| REQUIRE(!view->frozen); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 719| | 720| 2| rcu_read_lock(); 721| 2| zonetable = rcu_dereference(view->zonetable); 722| 2| if (zonetable != NULL) { ------------------ | Branch (722:6): [True: 2, False: 0] ------------------ 723| 2| result = dns_zt_mount(zonetable, zone); 724| 2| } else { 725| 0| result = ISC_R_SHUTTINGDOWN; 726| 0| } 727| 2| rcu_read_unlock(); 728| | 729| 2| return result; 730| 2|} dns_view_find: 778| 372| dns_rdataset_t *sigrdataset) { 779| 372| isc_result_t result; 780| 372| dns_db_t *db = NULL, *zdb = NULL; 781| 372| dns_dbnode_t *node = NULL, *znode = NULL; 782| 372| bool is_cache, is_staticstub_zone; 783| 372| dns_rdataset_t zrdataset, zsigrdataset; 784| 372| dns_zone_t *zone = NULL; 785| 372| dns_zt_t *zonetable = NULL; 786| | 787| | /* 788| | * Find an rdataset whose owner name is 'name', and whose type is 789| | * 'type'. 790| | */ 791| | 792| 372| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 194| 372|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 744| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 372, False: 0] | | | | | Branch (42:11): [True: 372, False: 0] | | | | ------------------ | | | | 43| 372| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 793| 372| REQUIRE(view->frozen); ------------------ | | 194| 372|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 372| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 372, False: 0] | | | | ------------------ | | | | 43| 372| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 794| 372| REQUIRE(type != dns_rdatatype_rrsig); ------------------ | | 194| 372|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 372| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 372, False: 0] | | | | ------------------ | | | | 43| 372| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 795| 372| REQUIRE(rdataset != NULL); /* XXXBEW - remove this */ ------------------ | | 194| 372|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 372| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 372, False: 0] | | | | ------------------ | | | | 43| 372| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 796| 372| REQUIRE(nodep == NULL || *nodep == NULL); ------------------ | | 194| 372|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 372| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 372, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 372| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 797| | 798| | /* 799| | * Initialize. 800| | */ 801| 372| dns_rdataset_init(&zrdataset); 802| 372| dns_rdataset_init(&zsigrdataset); 803| | 804| | /* 805| | * Find a database to answer the query. 806| | */ 807| 372| is_staticstub_zone = false; 808| 372| rcu_read_lock(); 809| 372| zonetable = rcu_dereference(view->zonetable); 810| 372| if (zonetable != NULL) { ------------------ | Branch (810:6): [True: 372, False: 0] ------------------ 811| 372| result = dns_zt_find(zonetable, name, DNS_ZTFIND_MIRROR, &zone); 812| 372| } else { 813| 0| result = ISC_R_SHUTTINGDOWN; 814| 0| } 815| 372| rcu_read_unlock(); 816| 372| if (zone != NULL && dns_zone_gettype(zone) == dns_zone_staticstub && ------------------ | Branch (816:6): [True: 209, False: 163] | Branch (816:22): [True: 0, False: 209] ------------------ 817| 0| !use_static_stub) ------------------ | Branch (817:6): [True: 0, False: 0] ------------------ 818| 0| { 819| 0| result = ISC_R_NOTFOUND; 820| 0| } 821| 372| if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) { ------------------ | Branch (821:6): [True: 132, False: 240] | Branch (821:33): [True: 77, False: 163] ------------------ 822| 209| result = dns_zone_getdb(zone, &db); 823| 209| if (result != ISC_R_SUCCESS && view->cachedb != NULL) { ------------------ | Branch (823:7): [True: 0, False: 209] | Branch (823:34): [True: 0, False: 0] ------------------ 824| 0| dns_db_attach(view->cachedb, &db); 825| 209| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (825:14): [True: 0, False: 209] ------------------ 826| 0| goto cleanup; 827| 0| } 828| 209| if (dns_zone_gettype(zone) == dns_zone_staticstub && ------------------ | Branch (828:7): [True: 0, False: 209] ------------------ 829| 0| dns_name_equal(name, dns_zone_getorigin(zone))) ------------------ | Branch (829:7): [True: 0, False: 0] ------------------ 830| 0| { 831| 0| is_staticstub_zone = true; 832| 0| } 833| 209| } else if (result == ISC_R_NOTFOUND && view->cachedb != NULL) { ------------------ | Branch (833:13): [True: 163, False: 0] | Branch (833:41): [True: 0, False: 163] ------------------ 834| 0| dns_db_attach(view->cachedb, &db); 835| 163| } else { 836| 163| goto cleanup; 837| 163| } 838| | 839| 209| is_cache = dns_db_iscache(db); 840| | 841| 209|db_find: 842| | /* 843| | * Now look for an answer in the database. 844| | */ 845| 209| result = dns_db_find(db, name, NULL, type, options, now, &node, ------------------ | | 816| 209| dns__db_find(db, name, version, type, options, now, nodep, foundname, \ | | 817| 209| NULL, NULL, rdataset, sigrdataset DNS__DB_FILELINE) ------------------ 846| 209| foundname, rdataset, sigrdataset); 847| | 848| 209| if (result == DNS_R_DELEGATION || result == ISC_R_NOTFOUND) { ------------------ | Branch (848:6): [True: 0, False: 209] | Branch (848:36): [True: 0, False: 209] ------------------ 849| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 287| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 0] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 850| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 287| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 0] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 851| 0| if (node != NULL) { ------------------ | Branch (851:7): [True: 0, False: 0] ------------------ 852| 0| dns_db_detachnode(&node); ------------------ | | 1024| 0|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 853| 0| } 854| 0| if (!is_cache) { ------------------ | Branch (854:7): [True: 0, False: 0] ------------------ 855| 0| dns_db_detach(&db); 856| 0| if (view->cachedb != NULL && !is_staticstub_zone) { ------------------ | Branch (856:8): [True: 0, False: 0] | Branch (856:33): [True: 0, False: 0] ------------------ 857| | /* 858| | * Either the answer is in the cache, or we 859| | * don't know it. 860| | * Note that if the result comes from a 861| | * static-stub zone we stop the search here 862| | * (see the function description in view.h). 863| | */ 864| 0| is_cache = true; 865| 0| dns_db_attach(view->cachedb, &db); 866| 0| goto db_find; 867| 0| } 868| 0| } else { 869| | /* 870| | * We don't have the data in the cache. If we've got 871| | * glue from the zone, use it. 872| | */ 873| 0| if (dns_rdataset_isassociated(&zrdataset)) { ------------------ | Branch (873:8): [True: 0, False: 0] ------------------ 874| 0| dns_rdataset_clone(&zrdataset, rdataset); ------------------ | | 339| 0| dns__rdataset_clone(source, target DNS__DB_FILELINE) ------------------ 875| 0| if (sigrdataset != NULL && ------------------ | Branch (875:9): [True: 0, False: 0] ------------------ 876| 0| dns_rdataset_isassociated(&zsigrdataset)) ------------------ | Branch (876:9): [True: 0, False: 0] ------------------ 877| 0| { 878| 0| dns_rdataset_clone(&zsigrdataset, ------------------ | | 339| 0| dns__rdataset_clone(source, target DNS__DB_FILELINE) ------------------ 879| 0| sigrdataset); 880| 0| } 881| 0| result = DNS_R_GLUE; 882| 0| if (db != NULL) { ------------------ | Branch (882:9): [True: 0, False: 0] ------------------ 883| 0| dns_db_detach(&db); 884| 0| } 885| 0| dns_db_attach(zdb, &db); 886| 0| dns_db_attachnode(znode, &node); ------------------ | | 1005| 0| dns__db_attachnode(source, targetp DNS__DB_FILELINE) ------------------ 887| 0| goto cleanup; 888| 0| } 889| 0| } 890| | /* 891| | * We don't know the answer. 892| | */ 893| 0| result = ISC_R_NOTFOUND; 894| 209| } else if (result == DNS_R_GLUE) { ------------------ | Branch (894:13): [True: 0, False: 209] ------------------ 895| | /* 896| | * Glue is the answer wanted. 897| | */ 898| 0| result = ISC_R_SUCCESS; 899| 0| } 900| | 901| 209| if (result == ISC_R_NOTFOUND && !is_staticstub_zone && use_hints && ------------------ | Branch (901:6): [True: 0, False: 209] | Branch (901:34): [True: 0, False: 0] | Branch (901:57): [True: 0, False: 0] ------------------ 902| 0| view->rootdb != NULL) ------------------ | Branch (902:6): [True: 0, False: 0] ------------------ 903| 0| { 904| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 287| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 0] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 905| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 287| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 0] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 906| 0| if (db != NULL) { ------------------ | Branch (906:7): [True: 0, False: 0] ------------------ 907| 0| if (node != NULL) { ------------------ | Branch (907:8): [True: 0, False: 0] ------------------ 908| 0| dns_db_detachnode(&node); ------------------ | | 1024| 0|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 909| 0| } 910| 0| dns_db_detach(&db); 911| 0| } 912| 0| result = dns_db_find(view->rootdb, name, NULL, type, options, ------------------ | | 816| 0| dns__db_find(db, name, version, type, options, now, nodep, foundname, \ | | 817| 0| NULL, NULL, rdataset, sigrdataset DNS__DB_FILELINE) ------------------ 913| 0| now, &node, foundname, rdataset, 914| 0| sigrdataset); 915| 0| if (result == ISC_R_SUCCESS || result == DNS_R_GLUE) { ------------------ | Branch (915:7): [True: 0, False: 0] | Branch (915:34): [True: 0, False: 0] ------------------ 916| | /* 917| | * Lazily rearm priming if the rootdb's 918| | * stored TTL has elapsed. The stale 919| | * record is still returned; it is better 920| | * than nothing until the fresh priming 921| | * fetch completes. 922| | */ 923| 0| maybe_prime(view); 924| 0| dns_db_attach(view->rootdb, &db); 925| 0| result = DNS_R_HINT; 926| 0| } else if (result == DNS_R_NXRRSET) { ------------------ | Branch (926:14): [True: 0, False: 0] ------------------ 927| 0| dns_db_attach(view->rootdb, &db); 928| 0| result = DNS_R_HINTNXRRSET; 929| 0| } else if (result == DNS_R_NXDOMAIN) { ------------------ | Branch (929:14): [True: 0, False: 0] ------------------ 930| 0| result = ISC_R_NOTFOUND; 931| 0| } 932| | 933| | /* 934| | * Cleanup if the rootdb lookup failed. 935| | */ 936| 0| if (db == NULL && node != NULL) { ------------------ | Branch (936:7): [True: 0, False: 0] | Branch (936:21): [True: 0, False: 0] ------------------ 937| 0| dns_db_detachnode(&node); ------------------ | | 1024| 0|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 938| 0| } 939| 0| } 940| | 941| 372|cleanup: 942| 372| dns_rdataset_cleanup(&zrdataset); ------------------ | | 287| 372| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 372, Folded] | | | Branch (287:26): [True: 0, False: 372] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 943| 372| dns_rdataset_cleanup(&zsigrdataset); ------------------ | | 287| 372| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 372, Folded] | | | Branch (287:26): [True: 0, False: 372] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 944| | 945| 372| if (zdb != NULL) { ------------------ | Branch (945:6): [True: 0, False: 372] ------------------ 946| 0| if (znode != NULL) { ------------------ | Branch (946:7): [True: 0, False: 0] ------------------ 947| 0| dns_db_detachnode(&znode); ------------------ | | 1024| 0|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 948| 0| } 949| 0| dns_db_detach(&zdb); 950| 0| } 951| | 952| 372| if (db != NULL) { ------------------ | Branch (952:6): [True: 209, False: 163] ------------------ 953| 209| if (node != NULL) { ------------------ | Branch (953:7): [True: 132, False: 77] ------------------ 954| 132| if (nodep != NULL) { ------------------ | Branch (954:8): [True: 0, False: 132] ------------------ 955| 0| *nodep = node; 956| 132| } else { 957| 132| dns_db_detachnode(&node); ------------------ | | 1024| 132|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 958| 132| } 959| 132| } 960| 209| if (dbp != NULL) { ------------------ | Branch (960:7): [True: 0, False: 209] ------------------ 961| 0| *dbp = db; 962| 209| } else { 963| 209| dns_db_detach(&db); 964| 209| } 965| 209| } else { 966| 163| INSIST(node == NULL); ------------------ | | 198| 163|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 163| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 163, False: 0] | | | | ------------------ | | | | 55| 163| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 967| 163| } 968| | 969| 372| if (zone != NULL) { ------------------ | Branch (969:6): [True: 209, False: 163] ------------------ 970| 209| dns_zone_detach(&zone); 971| 209| } 972| | 973| 372| return result; 974| 209|} dns_view_simplefind: 980| 372| dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { 981| 372| isc_result_t result; 982| 372| dns_fixedname_t foundname; 983| | 984| 372| dns_fixedname_init(&foundname); 985| 372| result = dns_view_find(view, name, type, now, options, use_hints, false, 986| 372| NULL, NULL, dns_fixedname_name(&foundname), 987| 372| rdataset, sigrdataset); 988| 372| if (result == DNS_R_NXDOMAIN) { ------------------ | Branch (988:6): [True: 77, False: 295] ------------------ 989| | /* 990| | * The rdataset and sigrdataset of the relevant NSEC record 991| | * may be returned, but the caller cannot use them because 992| | * foundname is not returned by this simplified API. We 993| | * disassociate them here to prevent any misuse by the caller. 994| | */ 995| 77| dns_rdataset_cleanup(rdataset); ------------------ | | 287| 77| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 77, False: 0] | | | Branch (287:26): [True: 0, False: 77] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 996| 77| dns_rdataset_cleanup(sigrdataset); ------------------ | | 287| 77| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 77] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 997| 295| } else if (result != ISC_R_SUCCESS && result != DNS_R_GLUE && ------------------ | Branch (997:13): [True: 163, False: 132] | Branch (997:40): [True: 163, False: 0] ------------------ 998| 163| result != DNS_R_HINT && result != DNS_R_NCACHENXDOMAIN && ------------------ | Branch (998:6): [True: 163, False: 0] | Branch (998:30): [True: 163, False: 0] ------------------ 999| 163| result != DNS_R_NCACHENXRRSET && result != DNS_R_NXRRSET && ------------------ | Branch (999:6): [True: 163, False: 0] | Branch (999:39): [True: 163, False: 0] ------------------ 1000| 163| result != DNS_R_HINTNXRRSET && result != ISC_R_NOTFOUND) ------------------ | Branch (1000:6): [True: 163, False: 0] | Branch (1000:37): [True: 0, False: 163] ------------------ 1001| 0| { 1002| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 287| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 0] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 1003| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 287| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 0, False: 0] | | | Branch (287:26): [True: 0, False: 0] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 1004| 0| result = ISC_R_NOTFOUND; 1005| 0| } 1006| | 1007| 372| return result; 1008| 372|} dns_view_checksig: 1345| 429|dns_view_checksig(dns_view_t *view, isc_buffer_t *source, dns_message_t *msg) { 1346| 429| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 194| 429|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 858| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 429, False: 0] | | | | | Branch (42:11): [True: 429, False: 0] | | | | ------------------ | | | | 43| 429| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1347| 429| REQUIRE(source != NULL); ------------------ | | 194| 429|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 429| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 429, False: 0] | | | | ------------------ | | | | 43| 429| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1348| | 1349| 429| return dns_tsig_verify(source, msg, view->statickeys, 1350| 429| view->dynamickeys); 1351| 429|} dns_view_sfd_add: 1994| 2|dns_view_sfd_add(dns_view_t *view, const dns_name_t *name) { 1995| 2| isc_result_t result; 1996| | 1997| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1998| | 1999| 2| result = dns_nametree_add(view->sfd, name, 0); 2000| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 2001| 2|} dns_zone_create: 448| 2|dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx, isc_tid_t tid) { 449| 2| isc_time_t now; 450| 2| dns_zone_t *zone = NULL; 451| | 452| 2| REQUIRE(zonep != NULL && *zonep == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 453| 2| REQUIRE(mctx != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 454| | 455| 2| now = isc_time_now(); 456| 2| zone = isc_mem_get(mctx, sizeof(*zone)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 457| 2| *zone = (dns_zone_t){ 458| 2| .masterformat = dns_masterformat_none, 459| 2| .journalsize = -1, 460| 2| .rdclass = dns_rdataclass_none, ------------------ | | 32| 2|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ 461| 2| .type = dns_zone_none, 462| 2| .refresh = DNS_ZONE_DEFAULTREFRESH, ------------------ | | 130| 2|#define DNS_ZONE_DEFAULTREFRESH 3600 /*%< 1 hour */ ------------------ 463| 2| .retry = DNS_ZONE_DEFAULTRETRY, ------------------ | | 140| 2| 60 /*%< 1 minute, subject to \ ------------------ 464| 2| .maxrefresh = DNS_ZONE_MAXREFRESH, ------------------ | | 127| 2|#define DNS_ZONE_MAXREFRESH 2419200 /*%< 4 weeks */ ------------------ 465| 2| .minrefresh = DNS_ZONE_MINREFRESH, ------------------ | | 124| 2|#define DNS_ZONE_MINREFRESH 300 /*%< 5 minutes */ ------------------ 466| 2| .maxretry = DNS_ZONE_MAXRETRY, ------------------ | | 136| 2|#define DNS_ZONE_MAXRETRY 1209600 /*%< 2 weeks */ ------------------ 467| 2| .minretry = DNS_ZONE_MINRETRY, ------------------ | | 133| 2|#define DNS_ZONE_MINRETRY 300 /*%< 5 minutes */ ------------------ 468| 2| .checkdstype = dns_checkdstype_yes, 469| 2| .zero_no_soa_ttl = true, 470| 2| .check_names = dns_severity_ignore, 471| 2| .idlein = DNS_DEFAULT_IDLEIN, ------------------ | | 53| 2|#define DNS_DEFAULT_IDLEIN 3600 /*%< 1 hour */ ------------------ 472| 2| .idleout = DNS_DEFAULT_IDLEOUT, ------------------ | | 54| 2|#define DNS_DEFAULT_IDLEOUT 3600 /*%< 1 hour */ ------------------ 473| 2| .maxxfrin = MAX_XFER_TIME, ------------------ | | 55| 2|#define MAX_XFER_TIME (2 * 3600) /*%< Documented default is 2 hours */ ------------------ 474| 2| .maxxfrout = MAX_XFER_TIME, ------------------ | | 55| 2|#define MAX_XFER_TIME (2 * 3600) /*%< Documented default is 2 hours */ ------------------ 475| 2| .sigvalidityinterval = 30 * 24 * 3600, 476| 2| .sigresigninginterval = 7 * 24 * 3600, 477| 2| .statlevel = dns_zonestat_none, 478| 2| .signatures = 10, 479| 2| .nodes = 100, 480| 2| .privatetype = (dns_rdatatype_t)0xffffU, 481| 2| .rpz_num = DNS_RPZ_INVALID_NUM, ------------------ | | 91| 2|#define DNS_RPZ_INVALID_NUM DNS_RPZ_MAX_ZONES | | ------------------ | | | | 82| 2|#define DNS_RPZ_MAX_ZONES 64 | | ------------------ ------------------ 482| 2| .requestixfr = true, 483| 2| .ixfr_ratio = 100, 484| 2| .requestexpire = true, 485| 2| .updatemethod = dns_updatemethod_increment, 486| 2| .tid = tid, 487| 2| .notifytime = now, 488| 2| .newincludes = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 489| 2| .checkds_requests = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 490| 2| .signing = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 491| 2| .nsec3chain = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 492| 2| .setnsec3param_queue = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 493| 2| .forwards = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 494| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 495| 2| .statelink = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 496| 2| }; 497| 2| dns_remote_t r = { 498| 2| .magic = DNS_REMOTE_MAGIC, ------------------ | | 25| 2|#define DNS_REMOTE_MAGIC ISC_MAGIC('R', 'm', 't', 'e') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 499| 2| }; 500| | 501| 2| isc_mem_attach(mctx, &zone->mctx); 502| 2| isc_mutex_init(&zone->lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 503| 2| ZONEDB_INITLOCK(&zone->dblock); ------------------ | | 110| 2|#define ZONEDB_INITLOCK(l) isc_rwlock_init(l) ------------------ 504| | 505| 2| isc_refcount_init(&zone->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 506| 2| isc_refcount_init(&zone->irefs, 0); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 507| 2| dns_name_init(&zone->origin); 508| 2| isc_sockaddr_any(&zone->parentalsrc4); 509| 2| isc_sockaddr_any6(&zone->parentalsrc6); 510| 2| isc_sockaddr_any(&zone->xfrsource4); 511| 2| isc_sockaddr_any6(&zone->xfrsource6); 512| | 513| 2| zone->primaries = r; 514| 2| zone->parentals = r; 515| 2| zone->alsonotify = r; 516| 2| zone->cds_endpoints = r; 517| 2| zone->defaultkasp = NULL; 518| 2| ISC_LIST_INIT(zone->keyring); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 519| | 520| 2| dns_notifyctx_init(&zone->notifysoa, dns_rdatatype_soa); ------------------ | | 120| 2|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ 521| 2| dns_notifyctx_init(&zone->notifycds, dns_rdatatype_cds); ------------------ | | 172| 2|#define dns_rdatatype_cds ((dns_rdatatype_t)dns_rdatatype_cds) ------------------ 522| | 523| 2| isc_stats_create(mctx, &zone->gluecachestats, 524| 2| dns_gluecachestatscounter_max); 525| | 526| 2| zone->magic = ZONE_MAGIC; ------------------ | | 32| 2|#define ZONE_MAGIC ISC_MAGIC('Z', 'O', 'N', 'E') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 527| | 528| | /* Must be after magic is set. */ 529| 2| dns_zone_setdbtype(zone, dbargc_default, dbargv_default); 530| | 531| 2| *zonep = zone; 532| 2|} dns__zone_inline_secure: 716| 20|dns__zone_inline_secure(dns_zone_t *zone) { 717| 20| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 20|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 40| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 20, False: 0] | | | | | Branch (42:11): [True: 20, False: 0] | | | | ------------------ | | | | 43| 20| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 718| 20| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 194| 20|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 20, False: 0] | | | | ------------------ | | | | 43| 20| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 719| 20| if (zone->raw != NULL) { ------------------ | Branch (719:6): [True: 0, False: 20] ------------------ 720| 0| return true; 721| 0| } 722| 20| return false; 723| 20|} dns__zone_inline_raw: 730| 12|dns__zone_inline_raw(dns_zone_t *zone) { 731| 12| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 12, False: 0] | | | | | Branch (42:11): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 12| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| 12| if (zone->secure != NULL) { ------------------ | Branch (733:6): [True: 0, False: 12] ------------------ 734| 0| return true; 735| 0| } 736| 12| return false; 737| 12|} dns__zone_freedbargs: 816| 2|dns__zone_freedbargs(dns_zone_t *zone) { 817| 2| unsigned int i; 818| | 819| | /* Free the old database argument list. */ 820| 2| if (zone->db_argv != NULL) { ------------------ | Branch (820:6): [True: 0, False: 2] ------------------ 821| 0| for (i = 0; i < zone->db_argc; i++) { ------------------ | Branch (821:15): [True: 0, False: 0] ------------------ 822| 0| isc_mem_free(zone->mctx, zone->db_argv[i]); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 823| 0| } 824| 0| isc_mem_cput(zone->mctx, zone->db_argv, zone->db_argc, ------------------ | | 155| 0| do { \ | | 156| 0| isc__mem_put((c), (p), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 157| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ | | 158| 0| (p) = NULL; \ | | 159| 0| } while (0) | | ------------------ | | | Branch (159:11): [Folded, False: 0] | | ------------------ ------------------ 825| 0| sizeof(*zone->db_argv)); 826| 0| } 827| 2| zone->db_argc = 0; 828| | zone->db_argv = NULL; 829| 2|} dns__zone_setview_helper: 832| 2|dns__zone_setview_helper(dns_zone_t *zone, dns_view_t *view) { 833| 2| char namebuf[1024]; 834| | 835| 2| if (zone->prev_view == NULL && zone->view != NULL) { ------------------ | Branch (835:6): [True: 2, False: 0] | Branch (835:33): [True: 0, False: 2] ------------------ 836| 0| dns_view_weakattach(zone->view, &zone->prev_view); 837| 0| } 838| | 839| 2| INSIST(zone != zone->raw); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 840| 2| if (zone->view != NULL) { ------------------ | Branch (840:6): [True: 0, False: 2] ------------------ 841| 0| dns_view_sfd_del(zone->view, &zone->origin); 842| 0| dns_view_weakdetach(&zone->view); 843| 0| } 844| 2| dns_view_weakattach(view, &zone->view); 845| 2| dns_view_sfd_add(view, &zone->origin); 846| | 847| 2| if (zone->strviewname != NULL) { ------------------ | Branch (847:6): [True: 0, False: 2] ------------------ 848| 0| isc_mem_free(zone->mctx, zone->strviewname); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 849| 0| } 850| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (850:6): [True: 2, False: 0] ------------------ 851| 2| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 166| 2| do { \ | | 167| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 2| (p) = NULL; \ | | 169| 2| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 2] | | ------------------ ------------------ 852| 2| } 853| | 854| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 855| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 856| 2| zone_viewname_tostr(zone, namebuf, sizeof namebuf); 857| 2| zone->strviewname = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 858| | 859| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (859:6): [True: 0, False: 2] ------------------ 860| 0| dns_zone_setview(zone->raw, view); 861| 0| } 862| 2|} dns_zone_isdynamic: 907| 6|dns_zone_isdynamic(dns_zone_t *zone, bool ignore_freeze) { 908| 6| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 909| | 910| 6| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (910:6): [True: 0, False: 6] | Branch (910:42): [True: 0, False: 6] ------------------ 911| 6| zone->type == dns_zone_stub || zone->type == dns_zone_key || ------------------ | Branch (911:6): [True: 0, False: 6] | Branch (911:37): [True: 0, False: 6] ------------------ 912| 6| (zone->type == dns_zone_redirect && ------------------ | Branch (912:7): [True: 0, False: 6] ------------------ 913| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (913:7): [True: 0, False: 0] ------------------ 914| 0| { 915| 0| return true; 916| 0| } 917| | 918| | /* Inline zones are always dynamic. */ 919| 6| if (zone->type == dns_zone_primary && zone->raw != NULL) { ------------------ | Branch (919:6): [True: 6, False: 0] | Branch (919:40): [True: 0, False: 6] ------------------ 920| 0| return true; 921| 0| } 922| | 923| | /* If !ignore_freeze, we need check whether updates are disabled. */ 924| 6| if (zone->type == dns_zone_primary && ------------------ | Branch (924:6): [True: 6, False: 0] ------------------ 925| 6| (!zone->update_disabled || ignore_freeze) && ------------------ | Branch (925:7): [True: 6, False: 0] | Branch (925:33): [True: 0, False: 0] ------------------ 926| 6| ((zone->ssutable != NULL) || ------------------ | Branch (926:7): [True: 0, False: 6] ------------------ 927| 6| (zone->update_acl != NULL && !dns_acl_isnone(zone->update_acl)))) ------------------ | Branch (927:8): [True: 0, False: 6] | Branch (927:36): [True: 0, False: 0] ------------------ 928| 0| { 929| 0| return true; 930| 0| } 931| | 932| 6| return false; 933| 6|} dns_zone_rpz_enable_db: 967| 2|dns_zone_rpz_enable_db(dns_zone_t *zone, dns_db_t *db) { 968| 2| if (zone->rpz_num == DNS_RPZ_INVALID_NUM) { ------------------ | | 91| 2|#define DNS_RPZ_INVALID_NUM DNS_RPZ_MAX_ZONES | | ------------------ | | | | 82| 2|#define DNS_RPZ_MAX_ZONES 64 | | ------------------ ------------------ | Branch (968:6): [True: 2, False: 0] ------------------ 969| 2| return; 970| 2| } 971| 0| REQUIRE(zone->rpzs != NULL); ------------------ | | 194| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 972| 0| dns_rpz_dbupdate_register(db, zone->rpzs->zones[zone->rpz_num]); 973| 0|} dns_zone_catz_enable_db: 988| 2|dns_zone_catz_enable_db(dns_zone_t *zone, dns_db_t *db) { 989| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 990| 2| REQUIRE(db != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 991| | 992| 2| if (zone->catzs != NULL) { ------------------ | Branch (992:6): [True: 0, False: 2] ------------------ 993| 0| dns_catz_dbupdate_register(db, zone->catzs); 994| 0| } 995| 2|} dns_zone_load: 1457| 2|dns_zone_load(dns_zone_t *zone, bool newonly) { 1458| 2| return zone_load(zone, newonly ? DNS_ZONELOADFLAG_NOSTAT : 0, false); ------------------ | Branch (1458:25): [True: 0, False: 2] ------------------ 1459| 2|} dns_zone_logv: 13618| 16| const char *prefix, const char *fmt, va_list ap) { 13619| 16| char message[4096]; 13620| 16| const char *zstr; 13621| | 13622| 16| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 13623| | 13624| 16| if (!isc_log_wouldlog(level)) { ------------------ | Branch (13624:6): [True: 14, False: 2] ------------------ 13625| 14| return; 13626| 14| } 13627| | 13628| 2| vsnprintf(message, sizeof(message), fmt, ap); 13629| | 13630| 2| switch (zone->type) { 13631| 0| case dns_zone_key: ------------------ | Branch (13631:2): [True: 0, False: 2] ------------------ 13632| 0| zstr = "managed-keys-zone"; 13633| 0| break; 13634| 0| case dns_zone_redirect: ------------------ | Branch (13634:2): [True: 0, False: 2] ------------------ 13635| 0| zstr = "redirect-zone"; 13636| 0| break; 13637| 2| default: ------------------ | Branch (13637:2): [True: 2, False: 0] ------------------ 13638| 2| zstr = "zone "; 13639| 2| } 13640| | 13641| 2| isc_log_write(category, DNS_LOGMODULE_ZONE, level, "%s%s%s%s: %s", 13642| 2| prefix != NULL ? prefix : "", prefix != NULL ? ": " : "", ------------------ | Branch (13642:9): [True: 0, False: 2] | Branch (13642:39): [True: 0, False: 2] ------------------ 13643| 2| zstr, zone->strnamerd, message); 13644| 2|} dns_zone_logc: 13648| 10| const char *fmt, ...) { 13649| 10| va_list ap; 13650| | 13651| 10| va_start(ap, fmt); 13652| 10| dns_zone_logv(zone, category, level, NULL, fmt, ap); 13653| | va_end(ap); 13654| 10|} dns_zonetype_name: 13712| 2|dns_zonetype_name(dns_zonetype_t type) { 13713| 2| switch (type) { 13714| 0| case dns_zone_none: ------------------ | Branch (13714:2): [True: 0, False: 2] ------------------ 13715| 0| return "none"; 13716| 2| case dns_zone_primary: ------------------ | Branch (13716:2): [True: 2, False: 0] ------------------ 13717| 2| return "primary"; 13718| 0| case dns_zone_secondary: ------------------ | Branch (13718:2): [True: 0, False: 2] ------------------ 13719| 0| return "secondary"; 13720| 0| case dns_zone_mirror: ------------------ | Branch (13720:2): [True: 0, False: 2] ------------------ 13721| 0| return "mirror"; 13722| 0| case dns_zone_stub: ------------------ | Branch (13722:2): [True: 0, False: 2] ------------------ 13723| 0| return "stub"; 13724| 0| case dns_zone_staticstub: ------------------ | Branch (13724:2): [True: 0, False: 2] ------------------ 13725| 0| return "static-stub"; 13726| 0| case dns_zone_key: ------------------ | Branch (13726:2): [True: 0, False: 2] ------------------ 13727| 0| return "key"; 13728| 0| case dns_zone_dlz: ------------------ | Branch (13728:2): [True: 0, False: 2] ------------------ 13729| 0| return "dlz"; 13730| 0| case dns_zone_redirect: ------------------ | Branch (13730:2): [True: 0, False: 2] ------------------ 13731| 0| return "redirect"; 13732| 0| default: ------------------ | Branch (13732:2): [True: 0, False: 2] ------------------ 13733| 0| return "unknown"; 13734| 2| } 13735| 2|} dns__zone_keymgmt_initialize: 16017| 2|dns__zone_keymgmt_initialize(void) { 16018| 2.05k| for (size_t idx = 0; idx < ARRAY_SIZE(keymgmt_buckets_g); ++idx) { ------------------ | | 94| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (16018:23): [True: 2.04k, False: 2] ------------------ 16019| 2.04k| isc_mutex_init(&keymgmt_buckets_g[idx].lock); ------------------ | | 68| 2.04k|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2.04k| { \ | | | | 80| 2.04k| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2.04k| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2.04k| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2.04k] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2.04k| } | | ------------------ ------------------ 16020| 2.04k| } 16021| 2|} dns_zone_cdscheck: 19291| 2|dns_zone_cdscheck(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *version) { 19292| 2| isc_result_t result; 19293| 2| dns_dbnode_t *node = NULL; 19294| 2| dns_rdataset_t dnskey, cds, cdnskey; 19295| 2| unsigned char algorithms[DST_MAX_ALGS]; 19296| 2| unsigned int i; 19297| 2| bool empty = false; 19298| | 19299| 2| enum { notexpected = 0, expected = 1, found = 2 }; 19300| | 19301| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 19302| | 19303| 2| RETERR(dns_db_getoriginnode(db, &node)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 19304| | 19305| 2| dns_rdataset_init(&cds); 19306| 2| dns_rdataset_init(&dnskey); 19307| 2| dns_rdataset_init(&cdnskey); 19308| | 19309| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_cds, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 19310| 2| dns_rdatatype_none, 0, &cds, NULL); 19311| 2| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (19311:6): [True: 0, False: 2] ------------------ 19312| 0| CHECK(result); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 19313| 0| } 19314| | 19315| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_cdnskey, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 19316| 2| dns_rdatatype_none, 0, &cdnskey, NULL); 19317| 2| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (19317:6): [True: 0, False: 2] ------------------ 19318| 0| CHECK(result); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 19319| 0| } 19320| | 19321| 2| if (!dns_rdataset_isassociated(&cds) && ------------------ | Branch (19321:6): [True: 2, False: 0] ------------------ 19322| 2| !dns_rdataset_isassociated(&cdnskey)) ------------------ | Branch (19322:6): [True: 2, False: 0] ------------------ 19323| 2| { 19324| 2| result = ISC_R_SUCCESS; 19325| 2| goto cleanup; 19326| 2| } 19327| | 19328| 0| result = dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, ------------------ | | 1125| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 0| sigrdataset DNS__DB_FILELINE) ------------------ 19329| 0| dns_rdatatype_none, 0, &dnskey, NULL); 19330| 0| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (19330:6): [True: 0, False: 0] ------------------ 19331| 0| empty = true; 19332| 0| } else { 19333| 0| CHECK(result); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 19334| 0| } 19335| | 19336| | /* 19337| | * For each DNSSEC algorithm in the CDS RRset there must be 19338| | * a matching DNSKEY record with the exception of a CDS deletion 19339| | * record which must be by itself. 19340| | */ 19341| 0| if (dns_rdataset_isassociated(&cds)) { ------------------ | Branch (19341:6): [True: 0, False: 0] ------------------ 19342| 0| bool logged_digest_type[DNS_DSDIGEST_MAX + 1] = { 0 }; 19343| 0| bool delete = false; 19344| 0| memset(algorithms, notexpected, sizeof(algorithms)); 19345| 0| DNS_RDATASET_FOREACH(&cds) { ------------------ | | 252| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19346| 0| dns_rdata_t crdata = DNS_RDATA_INIT; ------------------ | | 147| 0| { \ | | 148| 0| .data = NULL, \ | | 149| 0| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 0|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 0| { \ | | | | | | 27| 0| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 0| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 0| } | | | | ------------------ | | ------------------ | | 150| 0| } ------------------ 19347| 0| dns_rdata_cds_t structcds; 19348| | 19349| 0| dns_rdataset_current(&cds, &crdata); 19350| | /* 19351| | * CDS deletion record has this form "0 0 0 00" which 19352| | * is 5 zero octets. 19353| | */ 19354| 0| if (crdata.length == 5U && ------------------ | Branch (19354:8): [True: 0, False: 0] ------------------ 19355| 0| memcmp(crdata.data, ------------------ | Branch (19355:8): [True: 0, False: 0] ------------------ 19356| 0| (unsigned char[5]){ 0, 0, 0, 0, 0 }, 5) == 0) 19357| 0| { 19358| 0| delete = true; 19359| 0| continue; 19360| 0| } 19361| | 19362| 0| if (empty) { ------------------ | Branch (19362:8): [True: 0, False: 0] ------------------ 19363| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 19364| 0| } 19365| | 19366| 0| CHECK(dns_rdata_tostruct(&crdata, &structcds, NULL)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 19367| | 19368| | /* 19369| | * Log deprecated CDS digest types. 19370| | */ 19371| 0| switch (structcds.digest_type) { ------------------ | Branch (19371:12): [True: 0, False: 0] ------------------ 19372| 0| case DNS_DSDIGEST_SHA1: ------------------ | | 19| 0|#define DNS_DSDIGEST_SHA1 (1) ------------------ | Branch (19372:4): [True: 0, False: 0] ------------------ 19373| 0| case DNS_DSDIGEST_GOST: ------------------ | | 21| 0|#define DNS_DSDIGEST_GOST (3) ------------------ | Branch (19373:4): [True: 0, False: 0] ------------------ 19374| 0| if (!logged_digest_type[structcds.digest_type]) ------------------ | Branch (19374:9): [True: 0, False: 0] ------------------ 19375| 0| { 19376| 0| char algbuf[DNS_DSDIGEST_FORMATSIZE]; 19377| 0| dns_dsdigest_format( 19378| 0| structcds.digest_type, algbuf, 19379| 0| sizeof(algbuf)); 19380| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 19381| 0| "deprecated CDS digest type " 19382| 0| "%u (%s)", 19383| 0| structcds.digest_type, 19384| 0| algbuf); 19385| 0| logged_digest_type[structcds.digest_type] = 19386| 0| true; 19387| 0| } 19388| 0| break; 19389| 0| } 19390| | 19391| 0| if (structcds.algorithm != DNS_KEYALG_PRIVATEDNS && ------------------ | Branch (19391:8): [True: 0, False: 0] ------------------ 19392| 0| structcds.algorithm != DNS_KEYALG_PRIVATEOID) ------------------ | Branch (19392:8): [True: 0, False: 0] ------------------ 19393| 0| { 19394| 0| if (algorithms[structcds.algorithm] == 0) { ------------------ | Branch (19394:9): [True: 0, False: 0] ------------------ 19395| 0| algorithms[structcds.algorithm] = 19396| 0| expected; 19397| 0| } 19398| 0| DNS_RDATASET_FOREACH(&dnskey) { ------------------ | | 252| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19399| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 0| { \ | | 148| 0| .data = NULL, \ | | 149| 0| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 0|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 0| { \ | | | | | | 27| 0| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 0| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 0| } | | | | ------------------ | | ------------------ | | 150| 0| } ------------------ 19400| 0| dns_rdata_dnskey_t structdnskey; 19401| | 19402| 0| dns_rdataset_current(&dnskey, &rdata); 19403| 0| dns_rdata_tostruct(&rdata, 19404| 0| &structdnskey, NULL); 19405| | 19406| 0| if (structdnskey.algorithm == ------------------ | Branch (19406:10): [True: 0, False: 0] ------------------ 19407| 0| structcds.algorithm) 19408| 0| { 19409| 0| algorithms[structcds.algorithm] = 19410| 0| found; 19411| 0| } 19412| 0| } 19413| 0| } else { 19414| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 0| { \ | | 148| 0| .data = NULL, \ | | 149| 0| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 0|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 0| { \ | | | | | | 27| 0| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 0| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 0| } | | | | ------------------ | | ------------------ | | 150| 0| } ------------------ 19415| 0| dns_rdata_dnskey_t structdnskey; 19416| 0| dst_algorithm_t dnskeyalg; 19417| | 19418| | /* Convert CDS to DS */ 19419| 0| crdata.type = dns_rdatatype_ds; ------------------ | | 157| 0|#define dns_rdatatype_ds ((dns_rdatatype_t)dns_rdatatype_ds) ------------------ 19420| 0| result = dns_dnssec_matchdskey(&zone->origin, 19421| 0| &crdata, &dnskey, 19422| 0| &rdata); 19423| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (19423:9): [True: 0, False: 0] ------------------ 19424| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 19425| 0| } 19426| 0| CHECK(dns_rdata_tostruct(&rdata, &structdnskey, ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 19427| 0| NULL)); 19428| 0| dnskeyalg = dst_algorithm_fromdata( 19429| 0| structdnskey.algorithm, 19430| 0| structdnskey.data, 19431| 0| structdnskey.datalen); 19432| 0| algorithms[dnskeyalg] = found; 19433| 0| } 19434| 0| } 19435| 0| for (i = 0; i < sizeof(algorithms); i++) { ------------------ | Branch (19435:15): [True: 0, False: 0] ------------------ 19436| 0| if (delete) { ------------------ | Branch (19436:8): [True: 0, False: 0] ------------------ 19437| 0| if (algorithms[i] != notexpected) { ------------------ | Branch (19437:9): [True: 0, False: 0] ------------------ 19438| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 19439| 0| } 19440| 0| } else if (algorithms[i] == expected) { ------------------ | Branch (19440:15): [True: 0, False: 0] ------------------ 19441| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 19442| 0| } 19443| 0| } 19444| 0| } 19445| | 19446| | /* 19447| | * For each DNSSEC algorithm in the CDNSKEY RRset there must be 19448| | * a matching DNSKEY record with the exception of a CDNSKEY deletion 19449| | * record which must be by itself. 19450| | */ 19451| 0| if (dns_rdataset_isassociated(&cdnskey)) { ------------------ | Branch (19451:6): [True: 0, False: 0] ------------------ 19452| 0| bool delete = false; 19453| 0| memset(algorithms, notexpected, sizeof(algorithms)); 19454| 0| DNS_RDATASET_FOREACH(&cdnskey) { ------------------ | | 252| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19455| 0| dns_rdata_t crdata = DNS_RDATA_INIT; ------------------ | | 147| 0| { \ | | 148| 0| .data = NULL, \ | | 149| 0| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 0|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 0| { \ | | | | | | 27| 0| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 0| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 0| } | | | | ------------------ | | ------------------ | | 150| 0| } ------------------ 19456| 0| dns_rdata_cdnskey_t structcdnskey; 19457| 0| dst_algorithm_t cdnskeyalg; 19458| | 19459| 0| dns_rdataset_current(&cdnskey, &crdata); 19460| | /* 19461| | * CDNSKEY deletion record has this form 19462| | * "0 3 0 AA==" which is 2 zero octets, a 3, 19463| | * and 2 zero octets. 19464| | */ 19465| 0| if (crdata.length == 5U && ------------------ | Branch (19465:8): [True: 0, False: 0] ------------------ 19466| 0| memcmp(crdata.data, ------------------ | Branch (19466:8): [True: 0, False: 0] ------------------ 19467| 0| (unsigned char[5]){ 0, 0, 3, 0, 0 }, 5) == 0) 19468| 0| { 19469| 0| delete = true; 19470| 0| continue; 19471| 0| } 19472| | 19473| 0| if (empty) { ------------------ | Branch (19473:8): [True: 0, False: 0] ------------------ 19474| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 19475| 0| } 19476| | 19477| 0| CHECK(dns_rdata_tostruct(&crdata, &structcdnskey, ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 19478| 0| NULL)); 19479| 0| cdnskeyalg = dst_algorithm_fromdata( 19480| 0| structcdnskey.algorithm, structcdnskey.data, 19481| 0| structcdnskey.datalen); 19482| 0| if (algorithms[cdnskeyalg] == 0) { ------------------ | Branch (19482:8): [True: 0, False: 0] ------------------ 19483| 0| algorithms[cdnskeyalg] = expected; 19484| 0| } 19485| 0| DNS_RDATASET_FOREACH(&dnskey) { ------------------ | | 252| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19486| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 0| { \ | | 148| 0| .data = NULL, \ | | 149| 0| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 0|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 0| { \ | | | | | | 27| 0| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 0| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 0| } | | | | ------------------ | | ------------------ | | 150| 0| } ------------------ 19487| 0| dns_rdata_dnskey_t structdnskey; 19488| 0| dst_algorithm_t dnskeyalg; 19489| | 19490| 0| dns_rdataset_current(&dnskey, &rdata); 19491| 0| CHECK(dns_rdata_tostruct(&rdata, &structdnskey, ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 19492| 0| NULL)); 19493| 0| dnskeyalg = dst_algorithm_fromdata( 19494| 0| structdnskey.algorithm, 19495| 0| structdnskey.data, 19496| 0| structdnskey.datalen); 19497| | 19498| 0| if (dnskeyalg == cdnskeyalg) { ------------------ | Branch (19498:9): [True: 0, False: 0] ------------------ 19499| 0| algorithms[cdnskeyalg] = found; 19500| 0| } 19501| 0| } 19502| 0| } 19503| 0| for (i = 0; i < sizeof(algorithms); i++) { ------------------ | Branch (19503:15): [True: 0, False: 0] ------------------ 19504| 0| if (delete) { ------------------ | Branch (19504:8): [True: 0, False: 0] ------------------ 19505| 0| if (algorithms[i] != notexpected) { ------------------ | Branch (19505:9): [True: 0, False: 0] ------------------ 19506| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 19507| 0| } 19508| 0| } else if (algorithms[i] == expected) { ------------------ | Branch (19508:15): [True: 0, False: 0] ------------------ 19509| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 19510| 0| } 19511| 0| } 19512| 0| } 19513| 0| result = ISC_R_SUCCESS; 19514| | 19515| 2|cleanup: 19516| 2| dns_rdataset_cleanup(&cds); ------------------ | | 287| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 2, Folded] | | | Branch (287:26): [True: 0, False: 2] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 19517| 2| dns_rdataset_cleanup(&dnskey); ------------------ | | 287| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 2, Folded] | | | Branch (287:26): [True: 0, False: 2] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 19518| 2| dns_rdataset_cleanup(&cdnskey); ------------------ | | 287| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 2, Folded] | | | Branch (287:26): [True: 0, False: 2] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 19519| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 19520| 2| return result; 19521| 0|} dns_zone_verifydb: 20590| 2|dns_zone_verifydb(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *ver) { 20591| 2| dns_dbversion_t *version = NULL; 20592| 2| dns_keytable_t *secroots = NULL; 20593| 2| isc_result_t result; 20594| 2| dns_name_t *origin; 20595| | 20596| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 20597| 2| REQUIRE(db != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 20598| | 20599| 2| ENTER; ------------------ | | 345| 2|#define ENTER zone_debuglog(zone, __func__, 1, "enter") ------------------ 20600| | 20601| 2| if (dns_zone_gettype(zone) != dns_zone_mirror) { ------------------ | Branch (20601:6): [True: 2, False: 0] ------------------ 20602| 2| return ISC_R_SUCCESS; 20603| 2| } 20604| | 20605| 0| if (ver == NULL) { ------------------ | Branch (20605:6): [True: 0, False: 0] ------------------ 20606| 0| dns_db_currentversion(db, &version); 20607| 0| } else { 20608| 0| version = ver; 20609| 0| } 20610| | 20611| 0| if (zone->view != NULL) { ------------------ | Branch (20611:6): [True: 0, False: 0] ------------------ 20612| 0| result = dns_view_getsecroots(zone->view, &secroots); 20613| 0| CHECK(result); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 20614| 0| } 20615| | 20616| 0| origin = dns_db_origin(db); 20617| 0| result = dns_zoneverify_dnssec(zone, db, version, origin, secroots, 20618| 0| zone->mctx, true, false, dnssec_report); 20619| | 20620| 0|cleanup: 20621| 0| if (secroots != NULL) { ------------------ | Branch (20621:6): [True: 0, False: 0] ------------------ 20622| 0| dns_keytable_detach(&secroots); 20623| 0| } 20624| | 20625| 0| if (ver == NULL) { ------------------ | Branch (20625:6): [True: 0, False: 0] ------------------ 20626| 0| dns_db_closeversion(db, &version, false); ------------------ | | 731| 0| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 20627| 0| } 20628| | 20629| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20629:6): [True: 0, False: 0] ------------------ 20630| 0| dnssec_log(zone, ISC_LOG_ERROR, "zone verification failed: %s", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 20631| 0| isc_result_totext(result)); 20632| 0| result = DNS_R_VERIFYFAILURE; 20633| 0| } 20634| | 20635| 0| return result; 20636| 0|} dns_zone_makedb: 20677| 2|dns_zone_makedb(dns_zone_t *zone, dns_db_t **dbp) { 20678| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 20679| 2| REQUIRE(dbp != NULL && *dbp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 20680| | 20681| 2| dns_db_t *db = NULL; 20682| | 20683| 2| isc_result_t result = dns_db_create( 20684| 2| zone->mctx, zone->db_argv[0], &zone->origin, 20685| 2| (zone->type == dns_zone_stub) ? dns_dbtype_stub ------------------ | Branch (20685:3): [True: 0, False: 2] ------------------ 20686| 2| : dns_dbtype_zone, 20687| 2| zone->rdclass, zone->db_argc - 1, zone->db_argv + 1, &db); 20688| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20688:6): [True: 0, False: 2] ------------------ 20689| 0| return result; 20690| 0| } 20691| | 20692| 2| switch (zone->type) { 20693| 2| case dns_zone_primary: ------------------ | Branch (20693:2): [True: 2, False: 0] ------------------ 20694| 2| case dns_zone_secondary: ------------------ | Branch (20694:2): [True: 0, False: 2] ------------------ 20695| 2| case dns_zone_mirror: ------------------ | Branch (20695:2): [True: 0, False: 2] ------------------ 20696| 2| result = dns_db_setgluecachestats(db, zone->gluecachestats); 20697| 2| if (result == ISC_R_NOTIMPLEMENTED) { ------------------ | Branch (20697:7): [True: 0, False: 2] ------------------ 20698| 0| result = ISC_R_SUCCESS; 20699| 0| } 20700| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20700:7): [True: 0, False: 2] ------------------ 20701| 0| dns_db_detach(&db); 20702| 0| return result; 20703| 0| } 20704| 2| break; 20705| 2| default: ------------------ | Branch (20705:2): [True: 0, False: 2] ------------------ 20706| 0| break; 20707| 2| } 20708| | 20709| 2| dns_db_setmaxrrperset(db, zone->maxrrperset); 20710| 2| dns_db_setmaxtypepername(db, zone->maxtypepername); 20711| | 20712| 2| *dbp = db; 20713| | 20714| 2| return ISC_R_SUCCESS; 20715| 2|} zone.c:zone_load: 1150| 2|zone_load(dns_zone_t *zone, unsigned int flags, bool locked) { 1151| 2| isc_result_t result; 1152| 2| isc_time_t now; 1153| 2| isc_time_t loadtime; 1154| 2| dns_db_t *db = NULL; 1155| 2| bool rbt, hasraw, is_dynamic; 1156| | 1157| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1158| | 1159| 2| if (!locked) { ------------------ | Branch (1159:6): [True: 2, False: 0] ------------------ 1160| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 1161| 2| } 1162| | 1163| 2| INSIST(zone != zone->raw); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1164| 2| hasraw = dns__zone_inline_secure(zone); 1165| 2| if (hasraw) { ------------------ | Branch (1165:6): [True: 0, False: 2] ------------------ 1166| | /* 1167| | * We are trying to load an inline-signed zone. First call 1168| | * self recursively to try loading the raw version of the zone. 1169| | * Assuming the raw zone file is readable, there are two 1170| | * possibilities: 1171| | * 1172| | * a) the raw zone was not yet loaded and thus it will be 1173| | * loaded now, synchronously; if this succeeds, a 1174| | * subsequent attempt to load the signed zone file will 1175| | * take place and thus zone_postload() will be called 1176| | * twice: first for the raw zone and then for the secure 1177| | * zone; the latter call will take care of syncing the raw 1178| | * version with the secure version, 1179| | * 1180| | * b) the raw zone was already loaded and we are trying to 1181| | * reload it, which will happen asynchronously; this means 1182| | * zone_postload() will only be called for the raw zone 1183| | * because "result" returned by the zone_load() call below 1184| | * will not be ISC_R_SUCCESS but rather DNS_R_CONTINUE; 1185| | * zone_postload() called for the raw zone will take care 1186| | * of syncing the raw version with the secure version. 1187| | */ 1188| 0| result = zone_load(zone->raw, flags, false); 1189| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1189:7): [True: 0, False: 0] ------------------ 1190| 0| if (!locked) { ------------------ | Branch (1190:8): [True: 0, False: 0] ------------------ 1191| 0| UNLOCK_ZONE(zone); ------------------ | | 86| 0| do { \ | | 87| 0| INSIST((z)->locked); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 0| (z)->locked = false; \ | | 89| 0| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 0| { \ | | | | 35| 0| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 0| { \ | | | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 0| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 0| __FILE__, __LINE__)); \ | | | | 38| 0| } | | ------------------ | | 90| 0| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 0] | | ------------------ ------------------ 1192| 0| } 1193| 0| return result; 1194| 0| } 1195| 0| LOCK_ZONE(zone->raw); ------------------ | | 80| 0| do { \ | | 81| 0| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 0| { \ | | | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 0| __FILE__, __LINE__)); \ | | | | 29| 0| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 0| { \ | | | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 0| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 0| __FILE__, __LINE__)); \ | | | | 32| 0| } | | ------------------ | | 82| 0| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 0| (z)->locked = true; \ | | 84| 0| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 0] | | ------------------ ------------------ 1196| 0| } 1197| | 1198| 2| now = isc_time_now(); 1199| | 1200| 2| INSIST(zone->type != dns_zone_none); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1201| | 1202| | /* load was already in progress */ 1203| 2| if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADING)) { ------------------ | | 118| 2|#define DNS_ZONE_FLAG(z, f) ((atomic_load_relaxed(&(z)->flags) & (f)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (118:32): [True: 0, False: 2] | | ------------------ ------------------ 1204| 0| if ((flags & DNS_ZONELOADFLAG_THAW) != 0) { ------------------ | Branch (1204:7): [True: 0, False: 0] ------------------ 1205| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_THAW); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1206| 0| } 1207| 0| CLEANUP(ISC_R_LOADING); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 1208| 0| } 1209| | 1210| 2| INSIST(zone->db_argc >= 1); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1211| | 1212| 2| rbt = strcmp(zone->db_argv[0], ZONEDB_DEFAULT) == 0; ------------------ | | 168| 2|#define ZONEDB_DEFAULT "qpzone" ------------------ 1213| | 1214| 2| if (zone->db != NULL && zone->masterfile == NULL && rbt) { ------------------ | Branch (1214:6): [True: 0, False: 2] | Branch (1214:26): [True: 0, False: 0] | Branch (1214:54): [True: 0, False: 0] ------------------ 1215| | /* 1216| | * The zone has no master file configured. 1217| | */ 1218| 0| result = ISC_R_SUCCESS; 1219| 0| goto cleanup; 1220| 0| } 1221| | 1222| 2| is_dynamic = dns_zone_isdynamic(zone, false); 1223| 2| if (zone->db != NULL && is_dynamic) { ------------------ | Branch (1223:6): [True: 0, False: 2] | Branch (1223:26): [True: 0, False: 0] ------------------ 1224| | /* 1225| | * This is a secondary, stub, or dynamically updated zone 1226| | * being reloaded. Do nothing - the database we already 1227| | * have is guaranteed to be up-to-date. 1228| | */ 1229| 0| if (zone->type == dns_zone_primary && !hasraw) { ------------------ | Branch (1229:7): [True: 0, False: 0] | Branch (1229:41): [True: 0, False: 0] ------------------ 1230| 0| result = DNS_R_DYNAMIC; 1231| 0| } else { 1232| 0| result = ISC_R_SUCCESS; 1233| 0| } 1234| 0| goto cleanup; 1235| 0| } 1236| | 1237| | /* 1238| | * Store the current time before the zone is loaded, so that if the 1239| | * file changes between the time of the load and the time that 1240| | * zone->loadtime is set, then the file will still be reloaded 1241| | * the next time dns_zone_load is called. 1242| | */ 1243| 2| loadtime = isc_time_now(); 1244| | 1245| | /* 1246| | * Don't do the load if the file that stores the zone is older 1247| | * than the last time the zone was loaded. If the zone has not 1248| | * been loaded yet, zone->loadtime will be the epoch. 1249| | */ 1250| 2| if (zone->masterfile != NULL) { ------------------ | Branch (1250:6): [True: 2, False: 0] ------------------ 1251| 2| isc_time_t filetime; 1252| | 1253| | /* 1254| | * The file is already loaded. If we are just doing a 1255| | * "rndc reconfig", we are done. 1256| | */ 1257| 2| if (!isc_time_isepoch(&zone->loadtime) && ------------------ | Branch (1257:7): [True: 0, False: 2] ------------------ 1258| 0| (flags & DNS_ZONELOADFLAG_NOSTAT) != 0) ------------------ | Branch (1258:7): [True: 0, False: 0] ------------------ 1259| 0| { 1260| 0| result = ISC_R_SUCCESS; 1261| 0| goto cleanup; 1262| 0| } 1263| | 1264| 2| if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) && ------------------ | | 118| 4|#define DNS_ZONE_FLAG(z, f) ((atomic_load_relaxed(&(z)->flags) & (f)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (118:32): [True: 0, False: 2] | | ------------------ ------------------ 1265| 0| !zone_touched(zone)) ------------------ | Branch (1265:7): [True: 0, False: 0] ------------------ 1266| 0| { 1267| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1268| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1269| 0| "skipping load: master file " 1270| 0| "older than last load"); 1271| 0| CLEANUP(DNS_R_UPTODATE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 1272| 0| } 1273| | 1274| | /* 1275| | * If the file modification time is in the past 1276| | * set loadtime to that value. 1277| | */ 1278| 2| result = isc_file_getmodtime(zone->masterfile, &filetime); 1279| 2| if (result == ISC_R_SUCCESS && ------------------ | Branch (1279:7): [True: 2, False: 0] ------------------ 1280| 2| isc_time_compare(&loadtime, &filetime) > 0) ------------------ | Branch (1280:7): [True: 1, False: 1] ------------------ 1281| 1| { 1282| 1| loadtime = filetime; 1283| 1| } 1284| 2| } 1285| | 1286| | /* 1287| | * Built in zones (with the exception of empty zones) don't need 1288| | * to be reloaded. 1289| | */ 1290| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (1290:6): [True: 2, False: 0] ------------------ 1291| 2| strcmp(zone->db_argv[0], "_builtin") == 0 && ------------------ | Branch (1291:6): [True: 0, False: 2] ------------------ 1292| 0| (zone->db_argc < 2 || strcmp(zone->db_argv[1], "empty") != 0) && ------------------ | Branch (1292:7): [True: 0, False: 0] | Branch (1292:28): [True: 0, False: 0] ------------------ 1293| 0| DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) ------------------ | | 118| 0|#define DNS_ZONE_FLAG(z, f) ((atomic_load_relaxed(&(z)->flags) & (f)) != 0) | | ------------------ | | | | 28| 0|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (118:32): [True: 0, False: 0] | | ------------------ ------------------ 1294| 0| { 1295| 0| result = ISC_R_SUCCESS; 1296| 0| goto cleanup; 1297| 0| } 1298| | 1299| | /* 1300| | * Zones associated with a DLZ don't need to be loaded either, 1301| | * but we need to associate the database with the zone object. 1302| | */ 1303| 2| if (strcmp(zone->db_argv[0], "dlz") == 0) { ------------------ | Branch (1303:6): [True: 0, False: 2] ------------------ 1304| 0| dns_dlzdb_t *dlzdb = NULL; 1305| 0| dns_dlzfindzone_t findzone; 1306| | 1307| 0| ISC_LIST_FOREACH(zone->view->dlz_unsearched, d, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 1308| 0| INSIST(DNS_DLZ_VALID(d)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 0, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1309| 0| if (strcmp(zone->db_argv[1], d->dlzname) == 0) { ------------------ | Branch (1309:8): [True: 0, False: 0] ------------------ 1310| 0| dlzdb = d; 1311| 0| break; 1312| 0| } 1313| 0| } 1314| | 1315| 0| if (dlzdb == NULL) { ------------------ | Branch (1315:7): [True: 0, False: 0] ------------------ 1316| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1317| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1318| 0| "DLZ %s does not exist or is set " 1319| 0| "to 'search yes;'", 1320| 0| zone->db_argv[1]); 1321| 0| CLEANUP(ISC_R_NOTFOUND); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 1322| 0| } 1323| | 1324| 0| ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 112| 0|#define ZONEDB_LOCK(l, t) RWLOCK((l), (t)) | | ------------------ | | | | 30| 0| { \ | | | | 31| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | 32| 0| (t), __FILE__, __LINE__)); \ | | | | 33| 0| isc_rwlock_lock((lp), (t)); \ | | | | ------------------ | | | | | | 252| 0| { \ | | | | | | 253| 0| switch (type) { \ | | | | | | 254| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (254:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | | | 256| 0| break; \ | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (257:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | 259| 0| break; \ | | | | | | 260| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (260:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 262| 0| } \ | | | | | | 263| 0| } | | | | ------------------ | | | | 34| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | 35| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 36| 0| } | | ------------------ ------------------ 1325| | /* ask SDLZ driver if the zone is supported */ 1326| 0| findzone = dlzdb->implementation->methods->findzone; 1327| 0| result = (*findzone)(dlzdb->implementation->driverarg, 1328| 0| dlzdb->dbdata, dlzdb->mctx, 1329| 0| zone->view->rdclass, &zone->origin, NULL, 1330| 0| NULL, &db); 1331| 0| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (1331:7): [True: 0, False: 0] ------------------ 1332| 0| if (zone->db != NULL) { ------------------ | Branch (1332:8): [True: 0, False: 0] ------------------ 1333| 0| zone_detachdb(zone); 1334| 0| } 1335| 0| zone_attachdb(zone, db); 1336| 0| dns_db_detach(&db); 1337| 0| result = ISC_R_SUCCESS; 1338| 0| } 1339| 0| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 113| 0|#define ZONEDB_UNLOCK(l, t) RWUNLOCK((l), (t)) | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ ------------------ 1340| | 1341| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1341:7): [True: 0, False: 0] ------------------ 1342| 0| if (dlzdb->configure_callback == NULL) { ------------------ | Branch (1342:8): [True: 0, False: 0] ------------------ 1343| 0| goto cleanup; 1344| 0| } 1345| | 1346| 0| result = (*dlzdb->configure_callback)(zone->view, dlzdb, 1347| 0| zone); 1348| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1348:8): [True: 0, False: 0] ------------------ 1349| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1350| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1351| 0| "DLZ configuration callback: %s", 1352| 0| isc_result_totext(result)); 1353| 0| } 1354| 0| } 1355| 0| goto cleanup; 1356| 0| } 1357| | 1358| 2| if ((zone->type == dns_zone_secondary || ------------------ | Branch (1358:7): [True: 0, False: 2] ------------------ 1359| 2| zone->type == dns_zone_mirror || zone->type == dns_zone_stub || ------------------ | Branch (1359:7): [True: 0, False: 2] | Branch (1359:40): [True: 0, False: 2] ------------------ 1360| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (1360:8): [True: 0, False: 2] ------------------ 1361| 0| dns_remote_addresses(&zone->primaries) != NULL)) && ------------------ | Branch (1361:8): [True: 0, False: 0] ------------------ 1362| 0| rbt) ------------------ | Branch (1362:6): [True: 0, False: 0] ------------------ 1363| 0| { 1364| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIRSTREFRESH); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1365| | 1366| 0| if (zone->stream == NULL && ------------------ | Branch (1366:7): [True: 0, False: 0] ------------------ 1367| 0| (zone->masterfile == NULL || ------------------ | Branch (1367:8): [True: 0, False: 0] ------------------ 1368| 0| !isc_file_exists(zone->masterfile))) ------------------ | Branch (1368:8): [True: 0, False: 0] ------------------ 1369| 0| { 1370| 0| if (zone->masterfile != NULL) { ------------------ | Branch (1370:8): [True: 0, False: 0] ------------------ 1371| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1372| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1373| 0| "no master file"); 1374| 0| } 1375| 0| zone->refreshtime = now; 1376| 0| if (zone->loop != NULL) { ------------------ | Branch (1376:8): [True: 0, False: 0] ------------------ 1377| 0| dns__zone_settimer(zone, &now); 1378| 0| } 1379| 0| result = ISC_R_SUCCESS; 1380| 0| goto cleanup; 1381| 0| } 1382| 0| } 1383| | 1384| 2| if (zone->type == dns_zone_primary && zone->masterfile != NULL && ------------------ | Branch (1384:6): [True: 2, False: 0] | Branch (1384:40): [True: 2, False: 0] ------------------ 1385| 2| !isc_file_exists(zone->masterfile) && zone->initfile != NULL) ------------------ | Branch (1385:6): [True: 0, False: 2] | Branch (1385:44): [True: 0, False: 0] ------------------ 1386| 0| { 1387| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 1388| 0| "zone file %s not found; copying initial " 1389| 0| "file %s", 1390| 0| zone->masterfile, zone->initfile); 1391| 0| result = copy_initfile(zone); 1392| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1392:7): [True: 0, False: 0] ------------------ 1393| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1394| 0| ISC_LOG_ERROR, "copy from %s failed: %s", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1395| 0| zone->initfile, 1396| 0| isc_result_totext(result)); 1397| 0| } 1398| 0| } 1399| | 1400| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 1401| 2| "starting load"); 1402| | 1403| 2| result = dns_zone_makedb(zone, &db); 1404| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1404:6): [True: 0, False: 2] ------------------ 1405| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1406| 0| "loading zone: creating database: %s", 1407| 0| isc_result_totext(result)); 1408| 0| goto cleanup; 1409| 0| } 1410| | 1411| 2| if (!dns_db_ispersistent(db)) { ------------------ | Branch (1411:6): [True: 2, False: 0] ------------------ 1412| 2| if (zone->masterfile != NULL || zone->stream != NULL) { ------------------ | Branch (1412:7): [True: 2, False: 0] | Branch (1412:35): [True: 0, False: 0] ------------------ 1413| 2| result = zone_startload(db, zone, loadtime); 1414| 2| } else { 1415| 0| result = DNS_R_NOMASTERFILE; 1416| 0| if (zone->type == dns_zone_primary || ------------------ | Branch (1416:8): [True: 0, False: 0] ------------------ 1417| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (1417:9): [True: 0, False: 0] ------------------ 1418| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (1418:9): [True: 0, False: 0] ------------------ 1419| 0| { 1420| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1421| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1422| 0| "loading zone: " 1423| 0| "no master file configured"); 1424| 0| goto cleanup; 1425| 0| } 1426| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1427| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 1428| 0| "loading zone: " 1429| 0| "no master file configured: continuing"); 1430| 0| } 1431| 2| } 1432| | 1433| 2| if (result == DNS_R_CONTINUE) { ------------------ | Branch (1433:6): [True: 0, False: 2] ------------------ 1434| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADING); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1435| 0| if ((flags & DNS_ZONELOADFLAG_THAW) != 0) { ------------------ | Branch (1435:7): [True: 0, False: 0] ------------------ 1436| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_THAW); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1437| 0| } 1438| 0| goto cleanup; 1439| 0| } 1440| | 1441| 2| result = zone_postload(zone, db, loadtime, result); 1442| | 1443| 2|cleanup: 1444| 2| if (hasraw) { ------------------ | Branch (1444:6): [True: 0, False: 2] ------------------ 1445| 0| UNLOCK_ZONE(zone->raw); ------------------ | | 86| 0| do { \ | | 87| 0| INSIST((z)->locked); \ | | ------------------ | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 0| (z)->locked = false; \ | | 89| 0| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 0| { \ | | | | 35| 0| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 0| { \ | | | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 0| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 0| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 0| __FILE__, __LINE__)); \ | | | | 38| 0| } | | ------------------ | | 90| 0| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 0] | | ------------------ ------------------ 1446| 0| } 1447| 2| if (!locked) { ------------------ | Branch (1447:6): [True: 2, False: 0] ------------------ 1448| 2| UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 1449| 2| } 1450| 2| if (db != NULL) { ------------------ | Branch (1450:6): [True: 2, False: 0] ------------------ 1451| 2| dns_db_detach(&db); 1452| 2| } 1453| 2| return result; 1454| 2|} zone.c:zone_attachdb: 15283| 2|zone_attachdb(dns_zone_t *zone, dns_db_t *db) { 15284| 2| REQUIRE(zone->db == NULL && db != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 15285| | 15286| 2| dns_db_attach(db, &zone->db); 15287| 2|} zone.c:zone_startload: 1690| 2|zone_startload(dns_db_t *db, dns_zone_t *zone, isc_time_t loadtime) { 1691| 2| isc_result_t result; 1692| 2| isc_result_t tresult; 1693| 2| unsigned int options; 1694| 2| dns_load_t *load = isc_mem_get(zone->mctx, sizeof(*load)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1695| | 1696| 2| ENTER; ------------------ | | 345| 2|#define ENTER zone_debuglog(zone, __func__, 1, "enter") ------------------ 1697| | 1698| 2| *load = (dns_load_t){ 1699| 2| .loadtime = loadtime, 1700| 2| }; 1701| | 1702| 2| dns_zone_rpz_enable_db(zone, db); 1703| 2| dns_zone_catz_enable_db(zone, db); 1704| | 1705| 2| options = get_primary_options(zone); 1706| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_MANYERRORS)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1707| 0| options |= DNS_MASTER_MANYERRORS; ------------------ | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ ------------------ 1708| 0| } 1709| | 1710| 2| zone_iattach(zone, &load->zone); 1711| 2| dns_db_attach(db, &load->db); 1712| | 1713| 2| dns_rdatacallbacks_init(&load->callbacks); 1714| 2| load->callbacks.rawdata = zone_setrawdata; 1715| 2| zone_iattach(zone, &load->callbacks.zone); 1716| | 1717| 2| CHECK(dns_db_beginload(db, &load->callbacks)); ------------------ | | 251| 2| { \ | | 252| 2| result = (r); \ | | 253| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 2] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 2| } ------------------ 1718| | 1719| 2| if (zone->zmgr != NULL && zone->db != NULL) { ------------------ | Branch (1719:6): [True: 0, False: 2] | Branch (1719:28): [True: 0, False: 0] ------------------ 1720| 0| CHECK(dns_master_loadfileasync( ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 1721| 0| zone->masterfile, dns_db_origin(db), dns_db_origin(db), 1722| 0| zone->rdclass, options, 0, &load->callbacks, zone->loop, 1723| 0| zone_loaddone, load, &zone->loadctx, 1724| 0| zone_registerinclude, zone, zone->mctx, 1725| 0| zone->masterformat, zone->maxttl)); 1726| | 1727| 0| return DNS_R_CONTINUE; 1728| 2| } else if (zone->stream != NULL) { ------------------ | Branch (1728:13): [True: 0, False: 2] ------------------ 1729| 0| FILE *stream = UNCONST(zone->stream); ------------------ | | 92| 0|#define UNCONST(ptr) ((void *)(uintptr_t)(ptr)) ------------------ 1730| 0| result = dns_master_loadstream( 1731| 0| stream, &zone->origin, &zone->origin, zone->rdclass, 1732| 0| options, &load->callbacks, zone->mctx); 1733| 2| } else { 1734| 2| result = dns_master_loadfile( 1735| 2| zone->masterfile, &zone->origin, &zone->origin, 1736| 2| zone->rdclass, options, 0, &load->callbacks, 1737| 2| zone_registerinclude, zone, zone->mctx, 1738| 2| zone->masterformat, zone->maxttl); 1739| 2| } 1740| | 1741| 2|cleanup: 1742| 2| if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE) { ------------------ | Branch (1742:6): [True: 0, False: 2] | Branch (1742:33): [True: 0, False: 0] ------------------ 1743| 0| dns_zone_rpz_disable_db(zone, load->db); 1744| 0| dns_zone_catz_disable_db(zone, load->db); 1745| 0| } 1746| | 1747| 2| tresult = dns_db_endload(db, &load->callbacks); 1748| 2| if (result == ISC_R_SUCCESS || result == DNS_R_SEENINCLUDE) { ------------------ | Branch (1748:6): [True: 2, False: 0] | Branch (1748:33): [True: 0, False: 0] ------------------ 1749| 2| result = tresult; 1750| 2| } 1751| | 1752| 2| zone_idetach(&load->callbacks.zone); 1753| 2| dns_db_detach(&load->db); 1754| 2| zone_idetach(&load->zone); 1755| | 1756| | isc_mem_put(zone->mctx, load, sizeof(*load)); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 1757| 2| return result; 1758| 2|} zone.c:get_primary_options: 1569| 2|get_primary_options(dns_zone_t *zone) { 1570| 2| unsigned int options; 1571| | 1572| 2| options = DNS_MASTER_ZONE | DNS_MASTER_RESIGN; ------------------ | | 34| 2|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ options = DNS_MASTER_ZONE | DNS_MASTER_RESIGN; ------------------ | | 55| 2|#define DNS_MASTER_RESIGN 0x00002000 ------------------ 1573| 2| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (1573:6): [True: 0, False: 2] | Branch (1573:42): [True: 0, False: 2] ------------------ 1574| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (1574:7): [True: 0, False: 2] ------------------ 1575| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (1575:7): [True: 0, False: 0] ------------------ 1576| 0| { 1577| 0| options |= DNS_MASTER_SECONDARY; ------------------ | | 36| 0|#define DNS_MASTER_SECONDARY 0x00000020 /*%< Secondary master file. */ ------------------ 1578| 0| } 1579| 2| if (zone->type == dns_zone_key) { ------------------ | Branch (1579:6): [True: 0, False: 2] ------------------ 1580| 0| options |= DNS_MASTER_KEY; ------------------ | | 56| 0|#define DNS_MASTER_KEY 0x00004000 /*%< Loading a key zone master file. */ ------------------ 1581| 0| } 1582| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNS)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1583| 0| options |= DNS_MASTER_CHECKNS; ------------------ | | 38| 0| 0x00000040 /*%< \ ------------------ 1584| 0| } 1585| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_FATALNS)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1586| 0| options |= DNS_MASTER_FATALNS; ------------------ | | 43| 0| 0x00000080 /*%< \ ------------------ 1587| 0| } 1588| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMES)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1589| 0| options |= DNS_MASTER_CHECKNAMES; ------------------ | | 47| 0|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ 1590| 0| } 1591| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMESFAIL)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1592| 0| options |= DNS_MASTER_CHECKNAMESFAIL; ------------------ | | 48| 0|#define DNS_MASTER_CHECKNAMESFAIL 0x00000200 ------------------ 1593| 0| } 1594| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKMX)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1595| 0| options |= DNS_MASTER_CHECKMX; ------------------ | | 52| 0|#define DNS_MASTER_CHECKMX 0x00000800 ------------------ 1596| 0| } 1597| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKMXFAIL)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1598| 0| options |= DNS_MASTER_CHECKMXFAIL; ------------------ | | 53| 0|#define DNS_MASTER_CHECKMXFAIL 0x00001000 ------------------ 1599| 0| } 1600| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKWILDCARD)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1601| 0| options |= DNS_MASTER_CHECKWILDCARD; ------------------ | | 50| 0| 0x00000400 /* Check for internal wildcards. \ ------------------ 1602| 0| } 1603| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKTTL)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1604| 0| options |= DNS_MASTER_CHECKTTL; ------------------ | | 58| 0|#define DNS_MASTER_CHECKTTL 0x00010000 /*%< Check max-zone-ttl */ ------------------ 1605| 0| } 1606| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKSVCB)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 1607| 0| options |= DNS_MASTER_CHECKSVCB; ------------------ | | 59| 0|#define DNS_MASTER_CHECKSVCB 0x00020000 /*%< Check SVBC records */ ------------------ 1608| 0| } 1609| | 1610| 2| return options; 1611| 2|} zone.c:zone_get_from_db: 4866| 2| uint32_t *minimum, unsigned int *errors) { 4867| 2| isc_result_t result; 4868| 2| isc_result_t answer = ISC_R_SUCCESS; 4869| 2| dns_dbversion_t *version = NULL; 4870| 2| dns_dbnode_t *node; 4871| | 4872| 2| REQUIRE(db != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4873| 2| REQUIRE(zone != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4874| | 4875| 2| dns_db_currentversion(db, &version); 4876| | 4877| 2| SET_IF_NOT_NULL(nscount, 0); ------------------ | | 100| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 2, False: 0] | | ------------------ | | 101| 2| *(obj) = (val); \ | | 102| 2| } ------------------ 4878| 2| SET_IF_NOT_NULL(soacount, 0); ------------------ | | 100| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 2, False: 0] | | ------------------ | | 101| 2| *(obj) = (val); \ | | 102| 2| } ------------------ 4879| 2| SET_IF_NOT_NULL(errors, 0); ------------------ | | 100| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 2, False: 0] | | ------------------ | | 101| 2| *(obj) = (val); \ | | 102| 2| } ------------------ 4880| 2| CLR_SOA_VALUES(); ------------------ | | 4805| 2| { \ | | 4806| 2| SET_SOA_VALUES(0, 0, 0, 0, 0, 0); \ | | ------------------ | | | | 4795| 2| { \ | | | | 4796| 2| SET_IF_NOT_NULL(soattl, soattl_v); \ | | | | ------------------ | | | | | | 100| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 101| 2| *(obj) = (val); \ | | | | | | 102| 2| } | | | | ------------------ | | | | 4797| 2| SET_IF_NOT_NULL(serial, serial_v); \ | | | | ------------------ | | | | | | 100| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 101| 2| *(obj) = (val); \ | | | | | | 102| 2| } | | | | ------------------ | | | | 4798| 2| SET_IF_NOT_NULL(refresh, refresh_v); \ | | | | ------------------ | | | | | | 100| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 101| 2| *(obj) = (val); \ | | | | | | 102| 2| } | | | | ------------------ | | | | 4799| 2| SET_IF_NOT_NULL(retry, retry_v); \ | | | | ------------------ | | | | | | 100| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 101| 2| *(obj) = (val); \ | | | | | | 102| 2| } | | | | ------------------ | | | | 4800| 2| SET_IF_NOT_NULL(expire, expire_v); \ | | | | ------------------ | | | | | | 100| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 101| 2| *(obj) = (val); \ | | | | | | 102| 2| } | | | | ------------------ | | | | 4801| 2| SET_IF_NOT_NULL(minimum, minimum_v); \ | | | | ------------------ | | | | | | 100| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 101| 2| *(obj) = (val); \ | | | | | | 102| 2| } | | | | ------------------ | | | | 4802| 2| } | | ------------------ | | 4807| 2| } ------------------ 4881| | 4882| 2| node = NULL; 4883| 2| result = dns_db_findnode(db, &zone->origin, false, &node); ------------------ | | 768| 2| dns__db_findnode(db, name, create, NULL, NULL, nodep DNS__DB_FILELINE) ------------------ 4884| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4884:6): [True: 0, False: 2] ------------------ 4885| 0| answer = result; 4886| 0| goto closeversion; 4887| 0| } 4888| | 4889| 2| if (nscount != NULL || errors != NULL) { ------------------ | Branch (4889:6): [True: 2, False: 0] | Branch (4889:25): [True: 0, False: 0] ------------------ 4890| 2| result = zone_count_ns_rr(zone, db, node, version, nscount, 4891| 2| errors, true); 4892| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4892:7): [True: 0, False: 2] ------------------ 4893| 0| answer = result; 4894| 0| } 4895| 2| } 4896| | 4897| 2| if (soacount != NULL || soattl != NULL || serial != NULL || ------------------ | Branch (4897:6): [True: 2, False: 0] | Branch (4897:26): [True: 0, False: 0] | Branch (4897:44): [True: 0, False: 0] ------------------ 4898| 0| refresh != NULL || retry != NULL || expire != NULL || ------------------ | Branch (4898:6): [True: 0, False: 0] | Branch (4898:25): [True: 0, False: 0] | Branch (4898:42): [True: 0, False: 0] ------------------ 4899| 0| minimum != NULL) ------------------ | Branch (4899:6): [True: 0, False: 0] ------------------ 4900| 2| { 4901| 2| result = zone_load_soa_rr(db, node, version, soacount, soattl, 4902| 2| serial, refresh, retry, expire, 4903| 2| minimum); 4904| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4904:7): [True: 0, False: 2] ------------------ 4905| 0| answer = result; 4906| 0| } 4907| 2| } 4908| | 4909| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 4910| 2|closeversion: 4911| 2| dns_db_closeversion(db, &version, false); ------------------ | | 731| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 4912| | 4913| 2| return answer; 4914| 2|} zone.c:zone_load_soa_rr: 4813| 2| uint32_t *minimum) { 4814| 2| isc_result_t result; 4815| 2| unsigned int count = 0; 4816| 2| dns_rdataset_t rdataset; 4817| | 4818| 2| dns_rdataset_init(&rdataset); 4819| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_soa, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 4820| 2| dns_rdatatype_none, 0, &rdataset, NULL); 4821| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (4821:6): [True: 0, False: 2] ------------------ 4822| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4823| 0| result = ISC_R_SUCCESS; 4824| 0| goto invalidate_rdataset; 4825| 0| } 4826| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4826:6): [True: 0, False: 2] ------------------ 4827| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4828| 0| goto invalidate_rdataset; 4829| 0| } 4830| | 4831| 2| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 252| 2| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 2| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 4| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 2, False: 2] | | | | ------------------ | | ------------------ ------------------ 4832| 2| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 2| { \ | | 148| 2| .data = NULL, \ | | 149| 2| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 2| { \ | | | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 2| } | | | | ------------------ | | ------------------ | | 150| 2| } ------------------ 4833| 2| dns_rdataset_current(&rdataset, &rdata); 4834| | 4835| 2| count++; 4836| 2| if (count == 1) { ------------------ | Branch (4836:7): [True: 2, False: 0] ------------------ 4837| 2| dns_rdata_soa_t soa; 4838| 2| result = dns_rdata_tostruct(&rdata, &soa, NULL); 4839| 2| SET_SOA_VALUES(rdataset.ttl, soa.serial, soa.refresh, ------------------ | | 4795| 2| { \ | | 4796| 2| SET_IF_NOT_NULL(soattl, soattl_v); \ | | ------------------ | | | | 100| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (100:6): [True: 2, False: 0] | | | | ------------------ | | | | 101| 2| *(obj) = (val); \ | | | | 102| 2| } | | ------------------ | | 4797| 2| SET_IF_NOT_NULL(serial, serial_v); \ | | ------------------ | | | | 100| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (100:6): [True: 2, False: 0] | | | | ------------------ | | | | 101| 2| *(obj) = (val); \ | | | | 102| 2| } | | ------------------ | | 4798| 2| SET_IF_NOT_NULL(refresh, refresh_v); \ | | ------------------ | | | | 100| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (100:6): [True: 2, False: 0] | | | | ------------------ | | | | 101| 2| *(obj) = (val); \ | | | | 102| 2| } | | ------------------ | | 4799| 2| SET_IF_NOT_NULL(retry, retry_v); \ | | ------------------ | | | | 100| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (100:6): [True: 2, False: 0] | | | | ------------------ | | | | 101| 2| *(obj) = (val); \ | | | | 102| 2| } | | ------------------ | | 4800| 2| SET_IF_NOT_NULL(expire, expire_v); \ | | ------------------ | | | | 100| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (100:6): [True: 2, False: 0] | | | | ------------------ | | | | 101| 2| *(obj) = (val); \ | | | | 102| 2| } | | ------------------ | | 4801| 2| SET_IF_NOT_NULL(minimum, minimum_v); \ | | ------------------ | | | | 100| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (100:6): [True: 2, False: 0] | | | | ------------------ | | | | 101| 2| *(obj) = (val); \ | | | | 102| 2| } | | ------------------ | | 4802| 2| } ------------------ 4840| 2| soa.retry, soa.expire, soa.minimum); 4841| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 4842| 2| } 4843| 2| } 4844| 2| dns_rdataset_disassociate(&rdataset); ------------------ | | 291| 2| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4845| | 4846| 2| result = ISC_R_SUCCESS; 4847| | 4848| 2|invalidate_rdataset: 4849| 2| SET_IF_NOT_NULL(soacount, count); ------------------ | | 100| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 2, False: 0] | | ------------------ | | 101| 2| *(obj) = (val); \ | | 102| 2| } ------------------ 4850| 2| if (count == 0) { ------------------ | Branch (4850:6): [True: 0, False: 2] ------------------ 4851| 0| CLR_SOA_VALUES(); ------------------ | | 4805| 0| { \ | | 4806| 0| SET_SOA_VALUES(0, 0, 0, 0, 0, 0); \ | | ------------------ | | | | 4795| 0| { \ | | | | 4796| 0| SET_IF_NOT_NULL(soattl, soattl_v); \ | | | | ------------------ | | | | | | 100| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 101| 0| *(obj) = (val); \ | | | | | | 102| 0| } | | | | ------------------ | | | | 4797| 0| SET_IF_NOT_NULL(serial, serial_v); \ | | | | ------------------ | | | | | | 100| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 101| 0| *(obj) = (val); \ | | | | | | 102| 0| } | | | | ------------------ | | | | 4798| 0| SET_IF_NOT_NULL(refresh, refresh_v); \ | | | | ------------------ | | | | | | 100| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 101| 0| *(obj) = (val); \ | | | | | | 102| 0| } | | | | ------------------ | | | | 4799| 0| SET_IF_NOT_NULL(retry, retry_v); \ | | | | ------------------ | | | | | | 100| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 101| 0| *(obj) = (val); \ | | | | | | 102| 0| } | | | | ------------------ | | | | 4800| 0| SET_IF_NOT_NULL(expire, expire_v); \ | | | | ------------------ | | | | | | 100| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 101| 0| *(obj) = (val); \ | | | | | | 102| 0| } | | | | ------------------ | | | | 4801| 0| SET_IF_NOT_NULL(minimum, minimum_v); \ | | | | ------------------ | | | | | | 100| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (100:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 101| 0| *(obj) = (val); \ | | | | | | 102| 0| } | | | | ------------------ | | | | 4802| 0| } | | ------------------ | | 4807| 0| } ------------------ 4852| 0| } 4853| | 4854| 2| dns_rdataset_invalidate(&rdataset); 4855| | 4856| 2| return result; 4857| 2|} zone.c:zone_iattach: 4947| 4|zone_iattach(dns_zone_t *source, dns_zone_t **target) { 4948| 4| REQUIRE(DNS_ZONE_VALID(source)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4949| 4| REQUIRE(LOCKED_ZONE(source)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4950| 4| REQUIRE(target != NULL && *target == NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4951| 4| INSIST(isc_refcount_increment0(&source->irefs) + ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | | Branch (54:11): [True: 4, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4952| 4| isc_refcount_current(&source->references) > 4953| 4| 0); 4954| 4| *target = source; 4955| 4|} zone.c:zone_idetach: 4972| 4|zone_idetach(dns_zone_t **zonep) { 4973| 4| dns_zone_t *zone; 4974| | 4975| | /* 4976| | * 'zone' locked by caller. 4977| | */ 4978| 4| REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4979| 4| REQUIRE(LOCKED_ZONE(*zonep)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 4980| | 4981| 4| zone = *zonep; 4982| 4| *zonep = NULL; 4983| | 4984| 4| INSIST(isc_refcount_decrement(&zone->irefs) - 1 + ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | | Branch (54:11): [True: 4, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4985| 4| isc_refcount_current(&zone->references) > 4986| 4| 0); 4987| 4|} zone.c:check_nsec3param: 3193| 2|check_nsec3param(dns_zone_t *zone, dns_db_t *db) { 3194| 2| bool ok = false; 3195| 2| dns_dbnode_t *node = NULL; 3196| 2| dns_dbversion_t *version = NULL; 3197| 2| dns_rdata_nsec3param_t nsec3param; 3198| 2| dns_rdataset_t rdataset; 3199| 2| isc_result_t result; 3200| 2| bool dynamic = (zone->type == dns_zone_primary) ------------------ | Branch (3200:17): [True: 2, False: 0] ------------------ 3201| 2| ? dns_zone_isdynamic(zone, false) 3202| 2| : false; 3203| | 3204| 2| dns_rdataset_init(&rdataset); 3205| 2| result = dns_db_findnode(db, &zone->origin, false, &node); ------------------ | | 768| 2| dns__db_findnode(db, name, create, NULL, NULL, nodep DNS__DB_FILELINE) ------------------ 3206| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3206:6): [True: 0, False: 2] ------------------ 3207| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3208| 0| "nsec3param lookup failure: %s", 3209| 0| isc_result_totext(result)); 3210| 0| return result; 3211| 0| } 3212| 2| dns_db_currentversion(db, &version); 3213| | 3214| 2| result = dns_db_findrdataset(db, node, version, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 3215| 2| dns_rdatatype_nsec3param, 3216| 2| dns_rdatatype_none, 0, &rdataset, NULL); 3217| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (3217:6): [True: 2, False: 0] ------------------ 3218| 2| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3219| 2| result = ISC_R_SUCCESS; 3220| 2| goto cleanup; 3221| 2| } 3222| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3222:6): [True: 0, False: 0] ------------------ 3223| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3224| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3225| 0| "nsec3param lookup failure: %s", 3226| 0| isc_result_totext(result)); 3227| 0| goto cleanup; 3228| 0| } 3229| | 3230| 0| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 252| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3231| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 0| { \ | | 148| 0| .data = NULL, \ | | 149| 0| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 0|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 0| { \ | | | | | | 27| 0| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 0| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 0| } | | | | ------------------ | | ------------------ | | 150| 0| } ------------------ 3232| | 3233| 0| dns_rdataset_current(&rdataset, &rdata); 3234| 0| result = dns_rdata_tostruct(&rdata, &nsec3param, NULL); 3235| 0| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ ------------------ 3236| | 3237| | /* 3238| | * For dynamic zones we must support every algorithm so we 3239| | * can regenerate all the NSEC3 chains. 3240| | * For non-dynamic zones we only need to find a supported 3241| | * algorithm. 3242| | */ 3243| 0| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NSEC3TESTZONE) && ------------------ | | 175| 0|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 0|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 0] | | ------------------ ------------------ 3244| 0| nsec3param.hash == DNS_NSEC3_UNKNOWNALG && !dynamic) ------------------ | | 49| 0|#define DNS_NSEC3_UNKNOWNALG ((dns_hash_t)245U) ------------------ | Branch (3244:7): [True: 0, False: 0] | Branch (3244:50): [True: 0, False: 0] ------------------ 3245| 0| { 3246| 0| dns_zone_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3247| 0| "nsec3 test \"unknown\" hash algorithm " 3248| 0| "found: %u", 3249| 0| nsec3param.hash); 3250| 0| ok = true; 3251| 0| } else if (!dns_nsec3_supportedhash(nsec3param.hash)) { ------------------ | Branch (3251:14): [True: 0, False: 0] ------------------ 3252| 0| if (dynamic) { ------------------ | Branch (3252:8): [True: 0, False: 0] ------------------ 3253| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3254| 0| "unsupported nsec3 hash algorithm" 3255| 0| " in dynamic zone: %u", 3256| 0| nsec3param.hash); 3257| 0| result = DNS_R_BADZONE; 3258| | /* Stop second error message. */ 3259| 0| ok = true; 3260| 0| break; 3261| 0| } else { 3262| 0| dns_zone_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3263| 0| "unsupported nsec3 hash " 3264| 0| "algorithm: %u", 3265| 0| nsec3param.hash); 3266| 0| } 3267| 0| } else { 3268| 0| ok = true; 3269| 0| } 3270| | 3271| | /* 3272| | * Warn if the zone has excessive NSEC3 iterations. 3273| | */ 3274| 0| if (nsec3param.iterations > dns_nsec3_maxiterations()) { ------------------ | Branch (3274:7): [True: 0, False: 0] ------------------ 3275| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3276| 0| "excessive NSEC3PARAM iterations %u > %u", 3277| 0| nsec3param.iterations, 3278| 0| dns_nsec3_maxiterations()); 3279| 0| } 3280| 0| } 3281| | 3282| 0| if (!ok) { ------------------ | Branch (3282:6): [True: 0, False: 0] ------------------ 3283| 0| result = DNS_R_BADZONE; 3284| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3285| 0| "no supported nsec3 hash algorithm"); 3286| 0| } 3287| | 3288| 2|cleanup: 3289| 2| dns_rdataset_cleanup(&rdataset); ------------------ | | 287| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (287:6): [True: 2, Folded] | | | Branch (287:26): [True: 0, False: 2] | | ------------------ | | 288| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 289| 0| } ------------------ 3290| 2| dns_db_closeversion(db, &version, false); ------------------ | | 731| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 3291| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 3292| 2| return result; 3293| 0|} zone.c:zone_namerd_tostr: 16101| 2|zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length) { 16102| 2| isc_result_t result = ISC_R_FAILURE; 16103| 2| isc_buffer_t buffer; 16104| | 16105| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 16106| 2| REQUIRE(length > 1U); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 16107| | 16108| | /* 16109| | * Leave space for terminating '\0'. 16110| | */ 16111| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 16112| 2| if (zone->type != dns_zone_redirect && zone->type != dns_zone_key) { ------------------ | Branch (16112:6): [True: 2, False: 0] | Branch (16112:41): [True: 2, False: 0] ------------------ 16113| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (16113:7): [True: 2, False: 0] ------------------ 16114| 2| result = dns_name_totext( 16115| 2| &zone->origin, DNS_NAME_OMITFINALDOT, &buffer); ------------------ | | 883| 2|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 16116| 2| } 16117| 2| if (result != ISC_R_SUCCESS && ------------------ | Branch (16117:7): [True: 0, False: 2] ------------------ 16118| 0| isc_buffer_availablelength(&buffer) >= ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16118:7): [True: 0, False: 0] ------------------ 16119| 0| (sizeof("") - 1)) 16120| 0| { 16121| 0| isc_buffer_putstr(&buffer, ""); 16122| 0| } 16123| | 16124| 2| if (isc_buffer_availablelength(&buffer) > 0) { ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16124:7): [True: 2, False: 0] ------------------ 16125| 2| isc_buffer_putstr(&buffer, "/"); 16126| 2| } 16127| 2| (void)dns_rdataclass_totext(zone->rdclass, &buffer); 16128| 2| } 16129| | 16130| 2| if (zone->view != NULL && strcmp(zone->view->name, "_bind") != 0 && ------------------ | Branch (16130:6): [True: 2, False: 0] | Branch (16130:28): [True: 2, False: 0] ------------------ 16131| 2| strcmp(zone->view->name, "_default") != 0 && ------------------ | Branch (16131:6): [True: 2, False: 0] ------------------ 16132| 2| strlen(zone->view->name) < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16132:6): [True: 2, False: 0] ------------------ 16133| 2| { 16134| 2| isc_buffer_putstr(&buffer, "/"); 16135| 2| isc_buffer_putstr(&buffer, zone->view->name); 16136| 2| } 16137| 2| if (dns__zone_inline_secure(zone) && ------------------ | Branch (16137:6): [True: 0, False: 2] ------------------ 16138| 0| 9U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16138:6): [True: 0, False: 0] ------------------ 16139| 0| { 16140| 0| isc_buffer_putstr(&buffer, " (signed)"); 16141| 0| } 16142| 2| if (dns__zone_inline_raw(zone) && ------------------ | Branch (16142:6): [True: 0, False: 2] ------------------ 16143| 0| 11U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16143:6): [True: 0, False: 0] ------------------ 16144| 0| { 16145| 0| isc_buffer_putstr(&buffer, " (unsigned)"); 16146| 0| } 16147| | 16148| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 16149| 2|} zone.c:zone_viewname_tostr: 16152| 2|zone_viewname_tostr(dns_zone_t *zone, char *buf, size_t length) { 16153| 2| isc_buffer_t buffer; 16154| | 16155| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 16156| 2| REQUIRE(length > 1U); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 16157| | 16158| | /* 16159| | * Leave space for terminating '\0'. 16160| | */ 16161| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 16162| | 16163| 2| if (zone->view == NULL) { ------------------ | Branch (16163:6): [True: 0, False: 2] ------------------ 16164| 0| isc_buffer_putstr(&buffer, "_none"); 16165| 2| } else if (strlen(zone->view->name) < ------------------ | Branch (16165:13): [True: 2, False: 0] ------------------ 16166| 2| isc_buffer_availablelength(&buffer)) ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 16167| 2| { 16168| 2| isc_buffer_putstr(&buffer, zone->view->name); 16169| 2| } else { 16170| 0| isc_buffer_putstr(&buffer, "_toolong"); 16171| 0| } 16172| | 16173| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 16174| 2|} zone.c:zone_count_ns_rr: 4741| 2| unsigned int *errors, bool logit) { 4742| 2| isc_result_t result; 4743| 2| unsigned int count = 0; 4744| 2| unsigned int ecount = 0; 4745| 2| dns_rdataset_t rdataset; 4746| 2| dns_rdata_ns_t ns; 4747| | 4748| 2| dns_rdataset_init(&rdataset); 4749| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_ns, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 4750| 2| dns_rdatatype_none, 0, &rdataset, NULL); 4751| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (4751:6): [True: 0, False: 2] ------------------ 4752| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4753| 0| goto success; 4754| 0| } 4755| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4755:6): [True: 0, False: 2] ------------------ 4756| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4757| 0| goto invalidate_rdataset; 4758| 0| } 4759| | 4760| 2| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 252| 2| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 2| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 4| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 2, False: 2] | | | | ------------------ | | ------------------ ------------------ 4761| 2| if (errors != NULL && zone->rdclass == dns_rdataclass_in && ------------------ | | 24| 4|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (4761:7): [True: 2, False: 0] | Branch (4761:25): [True: 2, False: 0] ------------------ 4762| 2| (zone->type == dns_zone_primary || ------------------ | Branch (4762:8): [True: 2, False: 0] ------------------ 4763| 0| zone->type == dns_zone_secondary || ------------------ | Branch (4763:8): [True: 0, False: 0] ------------------ 4764| 0| zone->type == dns_zone_mirror)) ------------------ | Branch (4764:8): [True: 0, False: 0] ------------------ 4765| 2| { 4766| 2| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 2| { \ | | 148| 2| .data = NULL, \ | | 149| 2| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 2| { \ | | | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 2| } | | | | ------------------ | | ------------------ | | 150| 2| } ------------------ 4767| 2| dns_rdataset_current(&rdataset, &rdata); 4768| | 4769| 2| result = dns_rdata_tostruct(&rdata, &ns, NULL); 4770| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 4771| 2| if (dns_name_issubdomain(&ns.name, &zone->origin) && ------------------ | Branch (4771:8): [True: 0, False: 2] ------------------ 4772| 0| !zone_check_ns(zone, db, version, &ns.name, logit)) ------------------ | Branch (4772:8): [True: 0, False: 0] ------------------ 4773| 0| { 4774| 0| ecount++; 4775| 0| } 4776| 2| } 4777| 2| count++; 4778| 2| } 4779| 2| dns_rdataset_disassociate(&rdataset); ------------------ | | 291| 2| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4780| | 4781| 2|success: 4782| 2| SET_IF_NOT_NULL(nscount, count); ------------------ | | 100| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 2, False: 0] | | ------------------ | | 101| 2| *(obj) = (val); \ | | 102| 2| } ------------------ 4783| 2| SET_IF_NOT_NULL(errors, ecount); ------------------ | | 100| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 2, False: 0] | | ------------------ | | 101| 2| *(obj) = (val); \ | | 102| 2| } ------------------ 4784| | 4785| 2| result = ISC_R_SUCCESS; 4786| | 4787| 2|invalidate_rdataset: 4788| 2| dns_rdataset_invalidate(&rdataset); 4789| | 4790| 2| return result; 4791| 2|} zone.c:zone_postload: 4067| 2| isc_result_t result) { 4068| 2| unsigned int soacount = 0; 4069| 2| unsigned int nscount = 0; 4070| 2| unsigned int errors = 0; 4071| 2| uint32_t serial, oldserial, refresh, retry, expire, minimum, soattl; 4072| 2| isc_time_t now; 4073| 2| bool needdump = false; 4074| 2| bool fixjournal = false; 4075| 2| bool hasinclude = DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 118| 2|#define DNS_ZONE_FLAG(z, f) ((atomic_load_relaxed(&(z)->flags) & (f)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ ------------------ 4076| 2| bool noprimary = false; 4077| 2| bool had_db = false; 4078| 2| bool is_dynamic = false; 4079| | 4080| 2| INSIST(LOCKED_ZONE(zone)); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4081| 2| if (dns__zone_inline_raw(zone)) { ------------------ | Branch (4081:6): [True: 0, False: 2] ------------------ 4082| 0| INSIST(LOCKED_ZONE(zone->secure)); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4083| 0| } 4084| | 4085| 2| now = isc_time_now(); 4086| | 4087| | /* 4088| | * Initiate zone transfer? We may need a error code that 4089| | * indicates that the "permanent" form does not exist. 4090| | * XXX better error feedback to log. 4091| | */ 4092| 2| if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE) { ------------------ | Branch (4092:6): [True: 0, False: 2] | Branch (4092:33): [True: 0, False: 0] ------------------ 4093| 0| if (zone->type == dns_zone_secondary || ------------------ | Branch (4093:7): [True: 0, False: 0] ------------------ 4094| 0| zone->type == dns_zone_mirror || ------------------ | Branch (4094:7): [True: 0, False: 0] ------------------ 4095| 0| zone->type == dns_zone_stub || ------------------ | Branch (4095:7): [True: 0, False: 0] ------------------ 4096| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (4096:8): [True: 0, False: 0] ------------------ 4097| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (4097:8): [True: 0, False: 0] ------------------ 4098| 0| { 4099| 0| if (result == ISC_R_FILENOTFOUND) { ------------------ | Branch (4099:8): [True: 0, False: 0] ------------------ 4100| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4101| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4102| 0| "no master file"); 4103| 0| } else if (result != DNS_R_NOMASTERFILE) { ------------------ | Branch (4103:15): [True: 0, False: 0] ------------------ 4104| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4105| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4106| 0| "loading from master file %s " 4107| 0| "failed: %s", 4108| 0| zone->masterfile, 4109| 0| isc_result_totext(result)); 4110| 0| } 4111| 0| } else if (zone->type == dns_zone_primary && ------------------ | Branch (4111:14): [True: 0, False: 0] ------------------ 4112| 0| dns__zone_inline_secure(zone) && ------------------ | Branch (4112:7): [True: 0, False: 0] ------------------ 4113| 0| result == ISC_R_FILENOTFOUND) ------------------ | Branch (4113:7): [True: 0, False: 0] ------------------ 4114| 0| { 4115| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4116| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4117| 0| "no master file, requesting db"); 4118| 0| maybe_send_secure(zone); 4119| 0| } else { 4120| 0| int level = ISC_LOG_ERROR; ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4121| 0| if (zone->type == dns_zone_key && ------------------ | Branch (4121:8): [True: 0, False: 0] ------------------ 4122| 0| result == ISC_R_FILENOTFOUND) ------------------ | Branch (4122:8): [True: 0, False: 0] ------------------ 4123| 0| { 4124| 0| level = ISC_LOG_DEBUG(1); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4125| 0| } 4126| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, level, 4127| 0| "loading from master file %s failed: %s", 4128| 0| zone->masterfile, 4129| 0| isc_result_totext(result)); 4130| 0| noprimary = true; 4131| 0| } 4132| | 4133| 0| if (zone->type != dns_zone_key) { ------------------ | Branch (4133:7): [True: 0, False: 0] ------------------ 4134| 0| goto cleanup; 4135| 0| } 4136| 0| } 4137| | 4138| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(2), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 4139| 2| "number of nodes in database: %u", dns_db_nodecount(db)); 4140| | 4141| 2| if (result == DNS_R_SEENINCLUDE) { ------------------ | Branch (4141:6): [True: 0, False: 2] ------------------ 4142| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4143| 2| } else { 4144| 2| DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 120| 2|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4145| 2| } 4146| | 4147| | /* 4148| | * If there's no master file for a key zone, then the zone is new: 4149| | * create an SOA record. (We do this now, instead of later, so that 4150| | * if there happens to be a journal file, we can roll forward from 4151| | * a sane starting point.) 4152| | */ 4153| 2| if (noprimary && zone->type == dns_zone_key) { ------------------ | Branch (4153:6): [True: 0, False: 2] | Branch (4153:19): [True: 0, False: 0] ------------------ 4154| 0| CHECK(add_soa(zone, db)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 4155| 0| } 4156| | 4157| | /* 4158| | * Apply update log, if any, on initial load. 4159| | */ 4160| 2| if (zone->journal != NULL && ------------------ | Branch (4160:6): [True: 2, False: 0] ------------------ 4161| 2| !DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NOMERGE) && ------------------ | | 175| 4|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ ------------------ | Branch (4161:6): [True: 2, False: 0] ------------------ 4162| 2| !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) ------------------ | | 118| 2|#define DNS_ZONE_FLAG(z, f) ((atomic_load_relaxed(&(z)->flags) & (f)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ ------------------ | Branch (4162:6): [True: 2, False: 0] ------------------ 4163| 2| { 4164| 2| CHECK(zone_journal_rollforward(zone, db, &needdump, ------------------ | | 251| 2| { \ | | 252| 2| result = (r); \ | | 253| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 2] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 2| } ------------------ 4165| 2| &fixjournal)); 4166| 2| } 4167| | 4168| | /* 4169| | * Obtain ns, soa and cname counts for top of zone. 4170| | */ 4171| 2| INSIST(db != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4172| 2| result = zone_get_from_db(zone, db, &nscount, &soacount, &soattl, 4173| 2| &serial, &refresh, &retry, &expire, &minimum, 4174| 2| &errors); 4175| 2| if (result != ISC_R_SUCCESS && zone->type != dns_zone_key) { ------------------ | Branch (4175:6): [True: 0, False: 2] | Branch (4175:33): [True: 0, False: 0] ------------------ 4176| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4177| 0| "could not find NS and/or SOA records"); 4178| 0| } 4179| | 4180| | /* 4181| | * Process any queued NSEC3PARAM change requests. Only for dynamic 4182| | * zones, an inline-signing zone will perform this action when 4183| | * receiving the secure db (receive_secure_db). 4184| | */ 4185| 2| is_dynamic = dns_zone_isdynamic(zone, true); 4186| 2| if (is_dynamic) { ------------------ | Branch (4186:6): [True: 0, False: 2] ------------------ 4187| 0| process_zone_setnsec3param(zone); 4188| 0| } 4189| | 4190| | /* 4191| | * Check to make sure the journal is up to date, and remove the 4192| | * journal file if it isn't, as we wouldn't be able to apply 4193| | * updates otherwise. 4194| | */ 4195| 2| if (zone->journal != NULL && is_dynamic && ------------------ | Branch (4195:6): [True: 2, False: 0] | Branch (4195:31): [True: 0, False: 2] ------------------ 4196| 0| !DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS)) ------------------ | | 175| 0|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 0|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ ------------------ | Branch (4196:6): [True: 0, False: 0] ------------------ 4197| 0| { 4198| 0| uint32_t jserial; 4199| 0| dns_journal_t *journal = NULL; 4200| 0| bool empty = false; 4201| | 4202| 0| result = dns_journal_open(zone->mctx, zone->journal, 4203| 0| DNS_JOURNAL_READ, &journal); ------------------ | | 44| 0|#define DNS_JOURNAL_READ 0x00000000 /* false */ ------------------ 4204| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4204:7): [True: 0, False: 0] ------------------ 4205| 0| jserial = dns_journal_last_serial(journal); 4206| 0| empty = dns_journal_empty(journal); 4207| 0| dns_journal_destroy(&journal); 4208| 0| } else { 4209| 0| jserial = serial; 4210| 0| result = ISC_R_SUCCESS; 4211| 0| } 4212| | 4213| 0| if (jserial != serial) { ------------------ | Branch (4213:7): [True: 0, False: 0] ------------------ 4214| 0| if (!empty) { ------------------ | Branch (4214:8): [True: 0, False: 0] ------------------ 4215| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4216| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4217| 0| "journal file is out of date: " 4218| 0| "removing journal file"); 4219| 0| } 4220| 0| if (remove(zone->journal) < 0 && errno != ENOENT) { ------------------ | Branch (4220:8): [True: 0, False: 0] | Branch (4220:37): [True: 0, False: 0] ------------------ 4221| 0| char strbuf[ISC_STRERRORSIZE]; 4222| 0| strerror_r(errno, strbuf, sizeof(strbuf)); ------------------ | | 33| 0|#define strerror_r isc_string_strerror_r ------------------ 4223| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, 4224| 0| DNS_LOGMODULE_ZONE, 4225| 0| ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4226| 0| "unable to remove journal " 4227| 0| "'%s': '%s'", 4228| 0| zone->journal, strbuf); 4229| 0| } 4230| 0| } 4231| 0| } 4232| | 4233| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 4234| 2| "loaded; checking validity"); 4235| | 4236| | /* 4237| | * Primary / Secondary / Mirror / Stub zones require both NS and SOA 4238| | * records at the top of the zone. 4239| | */ 4240| | 4241| 2| switch (zone->type) { 4242| 0| case dns_zone_dlz: ------------------ | Branch (4242:2): [True: 0, False: 2] ------------------ 4243| 2| case dns_zone_primary: ------------------ | Branch (4243:2): [True: 2, False: 0] ------------------ 4244| 2| case dns_zone_secondary: ------------------ | Branch (4244:2): [True: 0, False: 2] ------------------ 4245| 2| case dns_zone_mirror: ------------------ | Branch (4245:2): [True: 0, False: 2] ------------------ 4246| 2| case dns_zone_stub: ------------------ | Branch (4246:2): [True: 0, False: 2] ------------------ 4247| 2| case dns_zone_redirect: ------------------ | Branch (4247:2): [True: 0, False: 2] ------------------ 4248| 2| if (soacount != 1) { ------------------ | Branch (4248:7): [True: 0, False: 2] ------------------ 4249| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4250| 0| ISC_LOG_ERROR, "has %d SOA records", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4251| 0| soacount); 4252| 0| result = DNS_R_BADZONE; 4253| 0| } 4254| 2| if (nscount == 0) { ------------------ | Branch (4254:7): [True: 0, False: 2] ------------------ 4255| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4256| 0| ISC_LOG_ERROR, "has no NS records"); ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4257| 0| result = DNS_R_BADZONE; 4258| 0| } 4259| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4259:7): [True: 0, False: 2] ------------------ 4260| 0| goto cleanup; 4261| 0| } 4262| 2| if (zone->type == dns_zone_primary && errors != 0) { ------------------ | Branch (4262:7): [True: 2, False: 0] | Branch (4262:41): [True: 0, False: 2] ------------------ 4263| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 4264| 0| } 4265| 2| if (zone->type != dns_zone_stub && ------------------ | Branch (4265:7): [True: 2, False: 0] ------------------ 4266| 2| zone->type != dns_zone_redirect) ------------------ | Branch (4266:7): [True: 2, False: 0] ------------------ 4267| 2| { 4268| 2| CHECK(check_nsec3param(zone, db)); ------------------ | | 251| 2| { \ | | 252| 2| result = (r); \ | | 253| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 2] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 2| } ------------------ 4269| 2| } 4270| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4270:7): [True: 2, False: 0] ------------------ 4271| 2| DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKINTEGRITY) && ------------------ | | 175| 4|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 4272| 0| !integrity_checks(zone, db)) ------------------ | Branch (4272:7): [True: 0, False: 0] ------------------ 4273| 0| { 4274| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 4275| 0| } 4276| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4276:7): [True: 2, False: 0] ------------------ 4277| 2| DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKDUPRR) && ------------------ | | 175| 4|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 2] | | ------------------ ------------------ 4278| 0| !zone_check_dup(zone, db)) ------------------ | Branch (4278:7): [True: 0, False: 0] ------------------ 4279| 0| { 4280| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 4281| 0| } 4282| | 4283| 2| if (zone->type == dns_zone_primary) { ------------------ | Branch (4283:7): [True: 2, False: 0] ------------------ 4284| 2| result = dns_zone_cdscheck(zone, db, NULL); 4285| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4285:8): [True: 0, False: 2] ------------------ 4286| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4287| 0| "CDS/CDNSKEY consistency checks " 4288| 0| "failed"); 4289| 0| goto cleanup; 4290| 0| } 4291| 2| } 4292| | 4293| 2| result = check_reportchannel(zone, db); 4294| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4294:7): [True: 0, False: 2] ------------------ 4295| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4296| 0| "'log-report-channel' is set, but no " 4297| 0| "'*._er/TXT' wildcard found"); 4298| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 4299| 0| } 4300| | 4301| 2| CHECK(dns_zone_verifydb(zone, db, NULL)); ------------------ | | 251| 2| { \ | | 252| 2| result = (r); \ | | 253| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 2] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 2| } ------------------ 4302| | 4303| 2| if (zone->db != NULL) { ------------------ | Branch (4303:7): [True: 0, False: 2] ------------------ 4304| 0| unsigned int oldsoacount; 4305| | 4306| | /* 4307| | * This is checked in zone_replacedb() for 4308| | * secondary zones as they don't reload from disk. 4309| | */ 4310| 0| result = zone_get_from_db( 4311| 0| zone, zone->db, NULL, &oldsoacount, NULL, 4312| 0| &oldserial, NULL, NULL, NULL, NULL, NULL); 4313| 0| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ ------------------ 4314| 0| RUNTIME_CHECK(oldsoacount > 0U); ------------------ | | 241| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ ------------------ 4315| 0| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS) && ------------------ | | 175| 0|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 0|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (175:31): [True: 0, False: 0] | | ------------------ ------------------ 4316| 0| !isc_serial_gt(serial, oldserial)) ------------------ | Branch (4316:8): [True: 0, False: 0] ------------------ 4317| 0| { 4318| 0| uint32_t serialmin, serialmax; 4319| | 4320| 0| INSIST(zone->type == dns_zone_primary); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4321| 0| INSIST(zone->raw == NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 4322| | 4323| 0| if (serial == oldserial && ------------------ | Branch (4323:9): [True: 0, False: 0] ------------------ 4324| 0| zone_unchanged(zone->db, db, zone->mctx)) ------------------ | Branch (4324:9): [True: 0, False: 0] ------------------ 4325| 0| { 4326| 0| dns_zone_logc(zone, 4327| 0| DNS_LOGCATEGORY_ZONELOAD, 4328| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4329| 0| "ixfr-from-differences: " 4330| 0| "unchanged"); 4331| 0| zone->loadtime = loadtime; 4332| 0| goto done; 4333| 0| } 4334| | 4335| 0| serialmin = (oldserial + 1) & 0xffffffffU; 4336| 0| serialmax = (oldserial + 0x7fffffffU) & 4337| 0| 0xffffffffU; 4338| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4339| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4340| 0| "ixfr-from-differences: " 4341| 0| "new serial (%u) out of range " 4342| 0| "[%u - %u]", 4343| 0| serial, serialmin, serialmax); 4344| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 4345| 0| } else if (!isc_serial_ge(serial, oldserial)) { ------------------ | Branch (4345:15): [True: 0, False: 0] ------------------ 4346| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4347| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4348| 0| "zone serial (%u/%u) has gone " 4349| 0| "backwards", 4350| 0| serial, oldserial); 4351| 0| } else if (serial == oldserial && !hasinclude && ------------------ | Branch (4351:15): [True: 0, False: 0] | Branch (4351:38): [True: 0, False: 0] ------------------ 4352| 0| strcmp(zone->db_argv[0], "_builtin") != 0) ------------------ | Branch (4352:8): [True: 0, False: 0] ------------------ 4353| 0| { 4354| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4355| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4356| 0| "zone serial (%u) unchanged. " 4357| 0| "zone may fail to transfer " 4358| 0| "to secondaries.", 4359| 0| serial); 4360| 0| } 4361| 0| } 4362| | 4363| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4363:7): [True: 2, False: 0] ------------------ 4364| 2| (zone->update_acl != NULL || zone->ssutable != NULL) && ------------------ | Branch (4364:8): [True: 0, False: 2] | Branch (4364:36): [True: 0, False: 2] ------------------ 4365| 0| dns_zone_getsigresigninginterval(zone) < (3 * refresh) && ------------------ | Branch (4365:7): [True: 0, False: 0] ------------------ 4366| 0| dns_db_issecure(db)) ------------------ | Branch (4366:7): [True: 0, False: 0] ------------------ 4367| 0| { 4368| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4369| 0| ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4370| 0| "sig-re-signing-interval less than " 4371| 0| "3 * refresh."); 4372| 0| } 4373| | 4374| 2| zone->refresh = RANGE(refresh, zone->minrefresh, ------------------ | | 110| 2|#define RANGE(a, min, max) (((a) < (min)) ? (min) : ((a) < (max) ? (a) : (max))) | | ------------------ | | | Branch (110:29): [True: 2, False: 0] | | | Branch (110:54): [True: 0, False: 0] | | ------------------ ------------------ 4375| 2| zone->maxrefresh); 4376| 2| zone->retry = RANGE(retry, zone->minretry, zone->maxretry); ------------------ | | 110| 2|#define RANGE(a, min, max) (((a) < (min)) ? (min) : ((a) < (max) ? (a) : (max))) | | ------------------ | | | Branch (110:29): [True: 2, False: 0] | | | Branch (110:54): [True: 0, False: 0] | | ------------------ ------------------ 4377| 2| zone->expire = RANGE(expire, zone->refresh + zone->retry, ------------------ | | 110| 2|#define RANGE(a, min, max) (((a) < (min)) ? (min) : ((a) < (max) ? (a) : (max))) | | ------------------ | | | Branch (110:29): [True: 2, False: 0] | | | Branch (110:54): [True: 0, False: 0] | | ------------------ ------------------ 4378| 2| DNS_MAX_EXPIRE); 4379| 2| zone->soattl = soattl; 4380| 2| zone->minimum = minimum; 4381| 2| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HAVETIMERS); ------------------ | | 119| 2|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4382| | 4383| 2| if (zone->type == dns_zone_secondary || ------------------ | Branch (4383:7): [True: 0, False: 2] ------------------ 4384| 2| zone->type == dns_zone_mirror || ------------------ | Branch (4384:7): [True: 0, False: 2] ------------------ 4385| 2| zone->type == dns_zone_stub || ------------------ | Branch (4385:7): [True: 0, False: 2] ------------------ 4386| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (4386:8): [True: 0, False: 2] ------------------ 4387| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (4387:8): [True: 0, False: 0] ------------------ 4388| 0| { 4389| 0| isc_time_t t; 4390| 0| uint32_t delay; 4391| | 4392| 0| result = isc_file_getmodtime(zone->journal, &t); 4393| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4393:8): [True: 0, False: 0] ------------------ 4394| 0| result = isc_file_getmodtime(zone->masterfile, 4395| 0| &t); 4396| 0| } 4397| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4397:8): [True: 0, False: 0] ------------------ 4398| 0| DNS_ZONE_TIME_ADD(&t, zone->expire, ------------------ | | 367| 0| do { \ | | 368| 0| isc_interval_t _i; \ | | ------------------ | | | | 44| 0|#define isc_interval_t isc_time_t | | ------------------ | | 369| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 47| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 370| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (370:7): [True: 0, False: 0] | | ------------------ | | 371| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 372| 0| "epoch approaching: upgrade required: " \ | | 373| 0| "now + %s failed", \ | | 374| 0| #b); \ | | 375| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 47| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 376| 0| (void)isc_time_add((a), &_i, (c)); \ | | 377| 0| } \ | | 378| 0| } while (0) | | ------------------ | | | Branch (378:11): [Folded, False: 0] | | ------------------ ------------------ 4399| 0| &zone->expiretime); 4400| 0| } else { 4401| 0| DNS_ZONE_TIME_ADD(&now, zone->retry, ------------------ | | 367| 0| do { \ | | 368| 0| isc_interval_t _i; \ | | ------------------ | | | | 44| 0|#define isc_interval_t isc_time_t | | ------------------ | | 369| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 47| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 370| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (370:7): [True: 0, False: 0] | | ------------------ | | 371| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 372| 0| "epoch approaching: upgrade required: " \ | | 373| 0| "now + %s failed", \ | | 374| 0| #b); \ | | 375| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 47| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 376| 0| (void)isc_time_add((a), &_i, (c)); \ | | 377| 0| } \ | | 378| 0| } while (0) | | ------------------ | | | Branch (378:11): [Folded, False: 0] | | ------------------ ------------------ 4402| 0| &zone->expiretime); 4403| 0| } 4404| | 4405| 0| delay = (zone->retry - 4406| 0| isc_random_uniform((zone->retry * 3) / 4)); 4407| 0| DNS_ZONE_TIME_ADD(&now, delay, &zone->refreshtime); ------------------ | | 367| 0| do { \ | | 368| 0| isc_interval_t _i; \ | | ------------------ | | | | 44| 0|#define isc_interval_t isc_time_t | | ------------------ | | 369| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 47| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 370| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (370:7): [True: 0, False: 0] | | ------------------ | | 371| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 372| 0| "epoch approaching: upgrade required: " \ | | 373| 0| "now + %s failed", \ | | 374| 0| #b); \ | | 375| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 47| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 376| 0| (void)isc_time_add((a), &_i, (c)); \ | | 377| 0| } \ | | 378| 0| } while (0) | | ------------------ | | | Branch (378:11): [Folded, False: 0] | | ------------------ ------------------ 4408| 0| if (isc_time_compare(&zone->refreshtime, ------------------ | Branch (4408:8): [True: 0, False: 0] ------------------ 4409| 0| &zone->expiretime) >= 0) 4410| 0| { 4411| 0| DNS_ZONE_SETFLAG(zone, ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4412| 0| DNS_ZONEFLG_FIRSTREFRESH); 4413| 0| zone->refreshtime = now; 4414| 0| } else { 4415| | /* The zone is up to date. */ 4416| 0| DNS_ZONE_CLRFLAG(zone, ------------------ | | 120| 0|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4417| 0| DNS_ZONEFLG_FIRSTREFRESH); 4418| 0| } 4419| 0| } 4420| | 4421| 2| break; 4422| | 4423| 0| case dns_zone_key: ------------------ | Branch (4423:2): [True: 0, False: 2] ------------------ 4424| | /* Nothing needs to be done now */ 4425| 0| break; 4426| | 4427| 0| default: ------------------ | Branch (4427:2): [True: 0, False: 2] ------------------ 4428| 0| UNEXPECTED_ERROR("unexpected zone type %d", zone->type); ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 4429| 0| CLEANUP(ISC_R_UNEXPECTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 4430| 2| } 4431| | 4432| | /* 4433| | * Check for weak DNSKEY's. 4434| | */ 4435| 2| if (zone->type == dns_zone_primary) { ------------------ | Branch (4435:6): [True: 2, False: 0] ------------------ 4436| 2| zone_check_dnskeys(zone, db); 4437| 2| } 4438| | 4439| | /* 4440| | * Schedule DNSSEC key refresh. 4441| | */ 4442| 2| if (zone->type == dns_zone_primary && zone->kasp != NULL) { ------------------ | Branch (4442:6): [True: 2, False: 0] | Branch (4442:40): [True: 0, False: 2] ------------------ 4443| 0| zone->refreshkeytime = now; 4444| 0| } 4445| | 4446| 2| ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 112| 2|#define ZONEDB_LOCK(l, t) RWLOCK((l), (t)) | | ------------------ | | | | 30| 2| { \ | | | | 31| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | 32| 2| (t), __FILE__, __LINE__)); \ | | | | 33| 2| isc_rwlock_lock((lp), (t)); \ | | | | ------------------ | | | | | | 252| 2| { \ | | | | | | 253| 2| switch (type) { \ | | | | | | 254| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (254:3): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 255| 0| isc_rwlock_rdlock(rwl); \ | | | | | | 256| 0| break; \ | | | | | | 257| 2| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (257:3): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 258| 2| isc_rwlock_wrlock(rwl); \ | | | | | | 259| 2| break; \ | | | | | | 260| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (260:3): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 262| 2| } \ | | | | | | 263| 2| } | | | | ------------------ | | | | 34| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | 35| 2| (lp), (t), __FILE__, __LINE__)); \ | | | | 36| 2| } | | ------------------ ------------------ 4447| 2| if (zone->db != NULL) { ------------------ | Branch (4447:6): [True: 0, False: 2] ------------------ 4448| 0| had_db = true; 4449| 0| result = zone_replacedb(zone, db, false); 4450| 0| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 113| 0|#define ZONEDB_UNLOCK(l, t) RWUNLOCK((l), (t)) | | ------------------ | | | | 38| 0| { \ | | | | 39| 0| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 0| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 0| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 0| { \ | | | | | | 283| 0| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ ------------------ 4451| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4451:7): [True: 0, False: 0] ------------------ 4452| 0| goto cleanup; 4453| 0| } 4454| 2| } else { 4455| 2| zone_attachdb(zone, db); 4456| 2| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 113| 2|#define ZONEDB_UNLOCK(l, t) RWUNLOCK((l), (t)) | | ------------------ | | | | 38| 2| { \ | | | | 39| 2| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 2| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 2| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 2| { \ | | | | | | 283| 2| switch (type) { \ | | | | | | 284| 0| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 0| break; \ | | | | | | 287| 2| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 288| 2| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 2| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 2| } \ | | | | | | 293| 2| } | | | | ------------------ | | | | 42| 2| } | | ------------------ ------------------ 4457| 2| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADED | ------------------ | | 119| 2|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4458| 2| DNS_ZONEFLG_NEEDSTARTUPNOTIFY); 4459| 2| if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_SENDSECURE) && ------------------ | | 118| 4|#define DNS_ZONE_FLAG(z, f) ((atomic_load_relaxed(&(z)->flags) & (f)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (118:32): [True: 0, False: 2] | | ------------------ ------------------ 4460| 0| dns__zone_inline_raw(zone)) ------------------ | Branch (4460:7): [True: 0, False: 0] ------------------ 4461| 0| { 4462| 0| if (zone->secure->db == NULL) { ------------------ | Branch (4462:8): [True: 0, False: 0] ------------------ 4463| 0| zone_send_securedb(zone, db); 4464| 0| } else { 4465| 0| zone_send_secureserial(zone, serial); 4466| 0| } 4467| 0| } 4468| 2| } 4469| | 4470| | /* 4471| | * Finished loading inline-signing zone; need to get status 4472| | * from the raw side now. 4473| | */ 4474| 2| if (zone->type == dns_zone_primary && dns__zone_inline_secure(zone)) { ------------------ | Branch (4474:6): [True: 2, False: 0] | Branch (4474:40): [True: 0, False: 2] ------------------ 4475| 0| maybe_send_secure(zone); 4476| 0| } 4477| | 4478| 2| result = ISC_R_SUCCESS; 4479| | 4480| 2| if (fixjournal) { ------------------ | Branch (4480:6): [True: 0, False: 2] ------------------ 4481| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIXJOURNAL); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4482| 0| zone_journal_compact(zone, zone->db, 0); 4483| 0| } 4484| 2| if (needdump) { ------------------ | Branch (4484:6): [True: 0, False: 2] ------------------ 4485| 0| if (zone->type == dns_zone_key) { ------------------ | Branch (4485:7): [True: 0, False: 0] ------------------ 4486| 0| zone_needdump(zone, 30); 4487| 0| } else { 4488| 0| zone_needdump(zone, DNS_DUMP_DELAY); ------------------ | | 63| 0|#define DNS_DUMP_DELAY 900 /*%< 15 minutes */ ------------------ 4489| 0| } 4490| 0| } 4491| | 4492| 2| if (zone->loop != NULL) { ------------------ | Branch (4492:6): [True: 0, False: 2] ------------------ 4493| 0| if (zone->type == dns_zone_primary) { ------------------ | Branch (4493:7): [True: 0, False: 0] ------------------ 4494| 0| dns__zone_set_resigntime(zone); 4495| 0| resume_signingwithkey(zone); 4496| 0| resume_addnsec3chain(zone); 4497| 0| } 4498| | 4499| 0| is_dynamic = dns_zone_isdynamic(zone, false); 4500| 0| if (zone->type == dns_zone_primary && is_dynamic && ------------------ | Branch (4500:7): [True: 0, False: 0] | Branch (4500:41): [True: 0, False: 0] ------------------ 4501| 0| dns_db_issecure(db) && !dns__zone_inline_raw(zone)) ------------------ | Branch (4501:7): [True: 0, False: 0] | Branch (4501:30): [True: 0, False: 0] ------------------ 4502| 0| { 4503| 0| isc_stdtime_t resign; 4504| 0| dns_name_t *name; 4505| 0| dns_fixedname_t fixed; 4506| 0| dns_typepair_t typepair; 4507| | 4508| 0| name = dns_fixedname_initname(&fixed); 4509| | 4510| 0| result = dns_db_getsigningtime(db, &resign, name, 4511| 0| &typepair); 4512| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4512:8): [True: 0, False: 0] ------------------ 4513| 0| isc_stdtime_t timenow = isc_stdtime_now(); 4514| 0| char namebuf[DNS_NAME_FORMATSIZE]; 4515| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 4516| | 4517| 0| dns_name_format(name, namebuf, sizeof(namebuf)); 4518| 0| dns_rdatatype_format( 4519| 0| DNS_TYPEPAIR_COVERS(typepair), typebuf, ------------------ | | 37| 0| ({ \ | | 38| 0| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 39| 0| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 40| 0| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 26| 0|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 41| 0| __covers; \ | | 42| 0| }) ------------------ 4520| 0| sizeof(typebuf)); 4521| 0| dnssec_log( 4522| 0| zone, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4523| 0| "next resign: %s/%s " 4524| 0| "in %d seconds", 4525| 0| namebuf, typebuf, 4526| 0| resign - timenow - 4527| 0| dns_zone_getsigresigninginterval( 4528| 0| zone)); 4529| 0| } else { 4530| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4531| 0| "signed dynamic zone has no " 4532| 0| "resign event scheduled"); 4533| 0| } 4534| 0| } 4535| | 4536| 0| dns__zone_settimer(zone, &now); 4537| 0| } 4538| | 4539| | /* 4540| | * Clear old include list. 4541| | */ 4542| 2| ISC_LIST_FOREACH(zone->includes, inc, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 4543| 0| ISC_LIST_UNLINK(zone->includes, inc, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4544| 0| isc_mem_free(zone->mctx, inc->name); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 4545| 0| isc_mem_put(zone->mctx, inc, sizeof(*inc)); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 4546| 0| } 4547| 2| zone->nincludes = 0; 4548| | 4549| | /* 4550| | * Transfer new include list. 4551| | */ 4552| 2| ISC_LIST_FOREACH(zone->newincludes, inc, link) { ------------------ | | 234| 2| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 2| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 2] | | ------------------ | | 236| 2| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 2] | | ------------------ | | 237| 2| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 4553| 0| ISC_LIST_UNLINK(zone->newincludes, inc, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4554| 0| ISC_LIST_APPEND(zone->includes, inc, link); ------------------ | | 100| 0| do { \ | | 101| 0| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 0| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 0| do { \ | | | | 89| 0| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 0] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 0| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 0| (elt)->link.prev = (list).tail; \ | | | | 95| 0| (elt)->link.next = NULL; \ | | | | 96| 0| (list).tail = (elt); \ | | | | 97| 0| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 103| 0| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 0] | | ------------------ ------------------ 4555| 0| zone->nincludes++; 4556| 0| } 4557| | 4558| 2| if (!dns_db_ispersistent(db)) { ------------------ | Branch (4558:6): [True: 2, False: 0] ------------------ 4559| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 2|#define ISC_LOG_INFO (-1) ------------------ 4560| 2| "loaded serial %u%s", serial, 4561| 2| dns_db_issecure(db) ? " (DNSSEC signed)" : ""); ------------------ | Branch (4561:10): [True: 0, False: 2] ------------------ 4562| 2| } 4563| | 4564| 2| if (!had_db && zone->type == dns_zone_mirror) { ------------------ | Branch (4564:6): [True: 2, False: 0] | Branch (4564:17): [True: 0, False: 2] ------------------ 4565| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4566| 0| "mirror zone is now in use"); 4567| 0| } 4568| | 4569| 2| zone->loadtime = loadtime; 4570| 2| goto done; 4571| | 4572| 0|cleanup: 4573| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4573:6): [True: 0, False: 0] ------------------ 4574| 0| dns_zone_rpz_disable_db(zone, db); 4575| 0| dns_zone_catz_disable_db(zone, db); 4576| 0| } 4577| | 4578| 0| ISC_LIST_FOREACH(zone->newincludes, inc, link) { ------------------ | | 234| 0| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 0] | | ------------------ | | 236| 0| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 0] | | ------------------ | | 237| 0| elt = elt##_next, \ | | 238| 0| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL) | | ------------------ | | | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (238:21): [True: 0, False: 0] | | ------------------ ------------------ 4579| 0| ISC_LIST_UNLINK(zone->newincludes, inc, link); ------------------ | | 137| 0| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 0| do { \ | | | | 133| 0| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 0| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 0| do { \ | | | | | | 110| 0| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 0| } else { \ | | | | | | 113| 0| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 0| (list).tail = (elt)->link.prev; \ | | | | | | 115| 0| } \ | | | | | | 116| 0| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 0| } else { \ | | | | | | 119| 0| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 0| (list).head = (elt)->link.next; \ | | | | | | 121| 0| } \ | | | | | | 122| 0| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 0| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 0| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4580| 0| isc_mem_free(zone->mctx, inc->name); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 4581| 0| isc_mem_put(zone->mctx, inc, sizeof(*inc)); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 4582| 0| } 4583| 0| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (4583:6): [True: 0, False: 0] | Branch (4583:42): [True: 0, False: 0] ------------------ 4584| 0| zone->type == dns_zone_stub || zone->type == dns_zone_key || ------------------ | Branch (4584:6): [True: 0, False: 0] | Branch (4584:37): [True: 0, False: 0] ------------------ 4585| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (4585:7): [True: 0, False: 0] ------------------ 4586| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (4586:7): [True: 0, False: 0] ------------------ 4587| 0| { 4588| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIRSTREFRESH); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4589| | 4590| 0| if (zone->journal != NULL) { ------------------ | Branch (4590:7): [True: 0, False: 0] ------------------ 4591| 0| zone_saveunique(zone, zone->journal, "jn-XXXXXXXX"); 4592| 0| } 4593| 0| if (zone->masterfile != NULL) { ------------------ | Branch (4593:7): [True: 0, False: 0] ------------------ 4594| 0| zone_saveunique(zone, zone->masterfile, "db-XXXXXXXX"); 4595| 0| } 4596| | 4597| | /* Mark the zone for immediate refresh. */ 4598| 0| zone->refreshtime = now; 4599| 0| if (zone->loop != NULL) { ------------------ | Branch (4599:7): [True: 0, False: 0] ------------------ 4600| 0| dns__zone_settimer(zone, &now); 4601| 0| } 4602| 0| result = ISC_R_SUCCESS; 4603| 0| } else if (zone->type == dns_zone_primary || ------------------ | Branch (4603:13): [True: 0, False: 0] ------------------ 4604| 0| zone->type == dns_zone_redirect) ------------------ | Branch (4604:6): [True: 0, False: 0] ------------------ 4605| 0| { 4606| 0| if (!(dns__zone_inline_secure(zone) && ------------------ | Branch (4606:9): [True: 0, False: 0] ------------------ 4607| 0| result == ISC_R_FILENOTFOUND)) ------------------ | Branch (4607:9): [True: 0, False: 0] ------------------ 4608| 0| { 4609| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4610| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4611| 0| "not loaded due to errors."); 4612| 0| } else if (zone->type == dns_zone_primary) { ------------------ | Branch (4612:14): [True: 0, False: 0] ------------------ 4613| 0| result = ISC_R_SUCCESS; 4614| 0| } 4615| 0| } 4616| | 4617| 2|done: 4618| 2| DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_LOADPENDING); ------------------ | | 120| 2|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4619| | /* 4620| | * If this is an inline-signed zone and we were called for the raw 4621| | * zone, we need to clear DNS_ZONEFLG_LOADPENDING for the secure zone 4622| | * as well, but only if this is a reload, not an initial zone load: in 4623| | * the former case, zone_postload() will not be run for the secure 4624| | * zone; in the latter case, it will be. Check which case we are 4625| | * dealing with by consulting the DNS_ZONEFLG_LOADED flag for the 4626| | * secure zone: if it is set, this must be a reload. 4627| | */ 4628| 2| if (dns__zone_inline_raw(zone) && ------------------ | Branch (4628:6): [True: 0, False: 2] ------------------ 4629| 0| DNS_ZONE_FLAG(zone->secure, DNS_ZONEFLG_LOADED)) ------------------ | | 118| 0|#define DNS_ZONE_FLAG(z, f) ((atomic_load_relaxed(&(z)->flags) & (f)) != 0) | | ------------------ | | | | 28| 0|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ | | | Branch (118:32): [True: 0, False: 0] | | ------------------ ------------------ 4630| 0| { 4631| 0| DNS_ZONE_CLRFLAG(zone->secure, DNS_ZONEFLG_LOADPENDING); ------------------ | | 120| 0|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4632| | /* 4633| | * Re-start zone maintenance if it had been stalled 4634| | * due to DNS_ZONEFLG_LOADPENDING being set when 4635| | * zone_maintenance was called. 4636| | */ 4637| 0| if (zone->secure->loop != NULL) { ------------------ | Branch (4637:7): [True: 0, False: 0] ------------------ 4638| 0| dns__zone_settimer(zone->secure, &now); 4639| 0| } 4640| 0| } 4641| | 4642| 2| zone_debuglog(zone, __func__, 99, "done"); 4643| | 4644| 2| return result; 4645| 0|} zone.c:zone_journal_rollforward: 10304| 2| bool *fixjournal) { 10305| 2| dns_journal_t *journal = NULL; 10306| 2| unsigned int options; 10307| 2| isc_result_t result; 10308| | 10309| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (10309:6): [True: 2, False: 0] ------------------ 10310| 2| (dns__zone_inline_secure(zone) || ------------------ | Branch (10310:7): [True: 0, False: 2] ------------------ 10311| 2| (zone->update_acl != NULL || zone->ssutable != NULL))) ------------------ | Branch (10311:8): [True: 0, False: 2] | Branch (10311:36): [True: 0, False: 2] ------------------ 10312| 0| { 10313| 0| options = DNS_JOURNALOPT_RESIGN; ------------------ | | 42| 0|#define DNS_JOURNALOPT_RESIGN 0x00000001 ------------------ 10314| 2| } else { 10315| 2| options = 0; 10316| 2| } 10317| | 10318| 2| result = dns_journal_open(zone->mctx, zone->journal, DNS_JOURNAL_READ, ------------------ | | 44| 2|#define DNS_JOURNAL_READ 0x00000000 /* false */ ------------------ 10319| 2| &journal); 10320| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (10320:6): [True: 2, False: 0] ------------------ 10321| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(3), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 10322| 2| "no journal file, but that's OK "); 10323| 2| return ISC_R_SUCCESS; 10324| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (10324:13): [True: 0, False: 0] ------------------ 10325| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10326| 0| "journal open failed: %s", 10327| 0| isc_result_totext(result)); 10328| 0| return result; 10329| 0| } 10330| | 10331| 0| if (dns_journal_empty(journal)) { ------------------ | Branch (10331:6): [True: 0, False: 0] ------------------ 10332| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10333| 0| "journal empty"); 10334| 0| dns_journal_destroy(&journal); 10335| 0| return ISC_R_SUCCESS; 10336| 0| } 10337| | 10338| 0| result = dns_journal_rollforward(journal, db, options); 10339| 0| switch (result) { 10340| 0| case ISC_R_SUCCESS: ------------------ | Branch (10340:2): [True: 0, False: 0] ------------------ 10341| 0| *needdump = true; 10342| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 10343| 0| case DNS_R_UPTODATE: ------------------ | Branch (10343:2): [True: 0, False: 0] ------------------ 10344| 0| if (dns_journal_recovered(journal)) { ------------------ | Branch (10344:7): [True: 0, False: 0] ------------------ 10345| 0| *fixjournal = true; 10346| 0| dns_zone_logc( 10347| 0| zone, DNS_LOGCATEGORY_ZONELOAD, 10348| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10349| 0| "journal rollforward completed successfully " 10350| 0| "using old journal format: %s", 10351| 0| isc_result_totext(result)); 10352| 0| } else { 10353| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 10354| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10355| 0| "journal rollforward completed " 10356| 0| "successfully: %s", 10357| 0| isc_result_totext(result)); 10358| 0| } 10359| | 10360| 0| dns_journal_destroy(&journal); 10361| 0| return ISC_R_SUCCESS; 10362| 0| case ISC_R_NOTFOUND: ------------------ | Branch (10362:2): [True: 0, False: 0] ------------------ 10363| 0| case ISC_R_RANGE: ------------------ | Branch (10363:2): [True: 0, False: 0] ------------------ 10364| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10365| 0| "journal rollforward failed: journal out of sync " 10366| 0| "with zone"); 10367| 0| dns_journal_destroy(&journal); 10368| 0| return result; 10369| 0| default: ------------------ | Branch (10369:2): [True: 0, False: 0] ------------------ 10370| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10371| 0| "journal rollforward failed: %s", 10372| 0| isc_result_totext(result)); 10373| 0| dns_journal_destroy(&journal); 10374| 0| return result; 10375| 0| } 10376| 0|} zone.c:check_reportchannel: 4025| 2|check_reportchannel(dns_zone_t *zone, dns_db_t *db) { 4026| 2| isc_result_t result; 4027| 2| dns_rdataset_t rdataset = DNS_RDATASET_INIT; ------------------ | | 234| 2| { \ | | 235| 2| .magic = DNS_RDATASET_MAGIC, \ | | ------------------ | | | | 92| 2|#define DNS_RDATASET_MAGIC ISC_MAGIC('D', 'N', 'S', 'R') | | | | ------------------ | | | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 236| 2| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 2| { \ | | | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 2| } | | | | ------------------ | | ------------------ | | 237| 2| } ------------------ 4028| 2| dns_dbnode_t *node = NULL; 4029| 2| dns_dbversion_t *version = NULL; 4030| 2| dns_fixedname_t fixed; 4031| 2| dns_name_t *name = NULL; 4032| | 4033| | /* 4034| | * If this zone isn't logging reports, it's fine. 4035| | */ 4036| 2| if (!DNS_ZONE_OPTION(zone, DNS_ZONEOPT_LOGREPORTS)) { ------------------ | | 175| 2|#define DNS_ZONE_OPTION(z, o) ((atomic_load_relaxed(&(z)->options) & (o)) != 0) | | ------------------ | | | | 28| 2|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) | | ------------------ ------------------ | Branch (4036:6): [True: 2, False: 0] ------------------ 4037| 2| return ISC_R_SUCCESS; 4038| 2| } 4039| | 4040| | /* 4041| | * Otherwise, we need a '*._er' wildcard with a TXT rdataset. 4042| | */ 4043| 0| name = dns_fixedname_initname(&fixed); 4044| 0| CHECK(dns_name_concatenate(&er, &zone->origin, name)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 4045| 0| CHECK(dns_db_findnode(db, name, false, &node)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 4046| | 4047| 0| dns_db_currentversion(db, &version); 4048| | 4049| 0| result = dns_db_findrdataset(db, node, version, dns_rdatatype_txt, ------------------ | | 1125| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 0| sigrdataset DNS__DB_FILELINE) ------------------ 4050| 0| dns_rdatatype_none, 0, &rdataset, NULL); 4051| 0| dns_db_closeversion(db, &version, false); ------------------ | | 731| 0| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 4052| 0| dns_db_detachnode(&node); ------------------ | | 1024| 0|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 4053| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4053:6): [True: 0, False: 0] ------------------ 4054| 0| dns_rdataset_disassociate(&rdataset); ------------------ | | 291| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4055| 0| } 4056| | 4057| 0|cleanup: 4058| 0| return result; 4059| 0|} zone.c:zone_check_dnskeys: 2689| 2|zone_check_dnskeys(dns_zone_t *zone, dns_db_t *db) { 2690| 2| dns_dbnode_t *node = NULL; 2691| 2| dns_dbversion_t *version = NULL; 2692| 2| dns_rdata_dnskey_t dnskey; 2693| 2| dns_rdataset_t rdataset; 2694| 2| isc_result_t result; 2695| 2| bool logged_algorithm[DST_MAX_ALGS] = { 0 }; 2696| 2| bool alldeprecated = true; 2697| | 2698| 2| CHECK(dns_db_findnode(db, &zone->origin, false, &node)); ------------------ | | 251| 2| { \ | | 252| 2| result = (r); \ | | 253| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 2] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 2| } ------------------ 2699| | 2700| 2| dns_db_currentversion(db, &version); 2701| 2| dns_rdataset_init(&rdataset); 2702| 2| CHECK(dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, ------------------ | | 251| 2| { \ | | 252| 2| result = (r); \ | | 253| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 2, False: 0] | | ------------------ | | 254| 2| goto cleanup; \ | | 255| 2| } \ | | 256| 2| } ------------------ 2703| 2| dns_rdatatype_none, 0, &rdataset, NULL)); 2704| | 2705| 0| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 252| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 249| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 250| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (250:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2706| 0| char algbuf[DNS_SECALG_FORMATSIZE]; 2707| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 0| { \ | | 148| 0| .data = NULL, \ | | 149| 0| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 0|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 0| { \ | | | | | | 27| 0| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 0| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 0|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 0| } | | | | ------------------ | | ------------------ | | 150| 0| } ------------------ 2708| 0| dns_rdataset_current(&rdataset, &rdata); 2709| 0| result = dns_rdata_tostruct(&rdata, &dnskey, NULL); 2710| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2711| | 2712| | /* 2713| | * RFC 3110, section 4: Performance Considerations: 2714| | * 2715| | * A public exponent of 3 minimizes the effort needed to verify 2716| | * a signature. Use of 3 as the public exponent is weak for 2717| | * confidentiality uses since, if the same data can be collected 2718| | * encrypted under three different keys with an exponent of 3 2719| | * then, using the Chinese Remainder Theorem [NETSEC], the 2720| | * original plain text can be easily recovered. If a key is 2721| | * known to be used only for authentication, as is the case with 2722| | * DNSSEC, then an exponent of 3 is acceptable. However other 2723| | * applications in the future may wish to leverage DNS 2724| | * distributed keys for applications that do require 2725| | * confidentiality. For keys which might have such other uses, 2726| | * a more conservative choice would be 65537 (F4, the fourth 2727| | * fermat number). 2728| | */ 2729| 0| if (dnskey.datalen > 1 && dnskey.data[0] == 1 && ------------------ | Branch (2729:7): [True: 0, False: 0] | Branch (2729:29): [True: 0, False: 0] ------------------ 2730| 0| dnskey.data[1] == 3 && ------------------ | Branch (2730:7): [True: 0, False: 0] ------------------ 2731| 0| (dnskey.algorithm == DNS_KEYALG_RSAMD5 || ------------------ | Branch (2731:8): [True: 0, False: 0] ------------------ 2732| 0| dnskey.algorithm == DNS_KEYALG_RSASHA1 || ------------------ | Branch (2732:8): [True: 0, False: 0] ------------------ 2733| 0| dnskey.algorithm == DNS_KEYALG_NSEC3RSASHA1 || ------------------ | Branch (2733:8): [True: 0, False: 0] ------------------ 2734| 0| dnskey.algorithm == DNS_KEYALG_RSASHA256 || ------------------ | Branch (2734:8): [True: 0, False: 0] ------------------ 2735| 0| dnskey.algorithm == DNS_KEYALG_RSASHA512)) ------------------ | Branch (2735:8): [True: 0, False: 0] ------------------ 2736| 0| { 2737| 0| char algorithm[DNS_SECALG_FORMATSIZE]; 2738| 0| isc_region_t r; 2739| | 2740| 0| dns_rdata_toregion(&rdata, &r); 2741| 0| dns_secalg_format(dnskey.algorithm, algorithm, 2742| 0| sizeof(algorithm)); 2743| | 2744| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2745| 0| "weak %s (%u) key found (exponent=3, id=%u)", 2746| 0| algorithm, dnskey.algorithm, 2747| 0| dst_region_computeid(&r)); 2748| 0| } 2749| 0| switch (dnskey.algorithm) { 2750| 0| case DNS_KEYALG_RSAMD5: ------------------ | Branch (2750:3): [True: 0, False: 0] ------------------ 2751| 0| case DNS_KEYALG_DSA: ------------------ | Branch (2751:3): [True: 0, False: 0] ------------------ 2752| 0| case DNS_KEYALG_RSASHA1: ------------------ | Branch (2752:3): [True: 0, False: 0] ------------------ 2753| 0| case DNS_KEYALG_NSEC3DSA: ------------------ | Branch (2753:3): [True: 0, False: 0] ------------------ 2754| 0| case DNS_KEYALG_NSEC3RSASHA1: ------------------ | Branch (2754:3): [True: 0, False: 0] ------------------ 2755| 0| case DNS_KEYALG_ECCGOST: ------------------ | Branch (2755:3): [True: 0, False: 0] ------------------ 2756| 0| if (!logged_algorithm[dnskey.algorithm]) { ------------------ | Branch (2756:8): [True: 0, False: 0] ------------------ 2757| 0| dns_secalg_format(dnskey.algorithm, algbuf, 2758| 0| sizeof(algbuf)); 2759| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2760| 0| "deprecated DNSKEY algorithm found: " 2761| 0| "%u (%s)\n", 2762| 0| dnskey.algorithm, algbuf); 2763| 0| logged_algorithm[dnskey.algorithm] = true; 2764| 0| } 2765| 0| break; 2766| 0| default: ------------------ | Branch (2766:3): [True: 0, False: 0] ------------------ 2767| 0| alldeprecated = false; 2768| 0| break; 2769| 0| } 2770| 0| } 2771| 0| dns_rdataset_disassociate(&rdataset); ------------------ | | 291| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 2772| | 2773| 0| if (alldeprecated) { ------------------ | Branch (2773:6): [True: 0, False: 0] ------------------ 2774| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2775| 0| "all DNSKEY algorithms found are deprecated"); 2776| 0| } 2777| | 2778| 2|cleanup: 2779| 2| if (node != NULL) { ------------------ | Branch (2779:6): [True: 2, False: 0] ------------------ 2780| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 2781| 2| } 2782| 2| if (version != NULL) { ------------------ | Branch (2782:6): [True: 2, False: 0] ------------------ 2783| 2| dns_db_closeversion(db, &version, false); ------------------ | | 731| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 2784| 2| } 2785| 2|} zone.c:zone_debuglog: 13678| 6| ...) { 13679| 6| int level = ISC_LOG_DEBUG(debuglevel); ------------------ | | 36| 6|#define ISC_LOG_DEBUG(level) (level) ------------------ 13680| 6| va_list ap; 13681| | 13682| 6| va_start(ap, fmt); 13683| 6| dns_zone_logv(zone, DNS_LOGCATEGORY_GENERAL, level, me, fmt, ap); 13684| | va_end(ap); 13685| 6|} dns_zone_setclass: 51| 2|dns_zone_setclass(dns_zone_t *zone, dns_rdataclass_t rdclass) { 52| 2| char namebuf[1024]; 53| | 54| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 55| 2| REQUIRE(rdclass != dns_rdataclass_none); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 56| | 57| | /* 58| | * Test and set. 59| | */ 60| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 61| 2| INSIST(zone != zone->raw); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 62| 2| REQUIRE(zone->rdclass == dns_rdataclass_none || ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 63| 2| zone->rdclass == rdclass); 64| 2| zone->rdclass = rdclass; 65| | 66| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (66:6): [True: 2, False: 0] ------------------ 67| 2| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 166| 2| do { \ | | 167| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 2| (p) = NULL; \ | | 169| 2| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 2] | | ------------------ ------------------ 68| 2| } 69| 2| if (zone->strrdclass != NULL) { ------------------ | Branch (69:6): [True: 0, False: 2] ------------------ 70| 0| isc_mem_free(zone->mctx, zone->strrdclass); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 71| 0| } 72| | 73| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 74| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 75| 2| zone_rdclass_tostr(zone, namebuf, sizeof namebuf); 76| 2| zone->strrdclass = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 77| | 78| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (78:6): [True: 0, False: 2] ------------------ 79| 0| dns_zone_setclass(zone->raw, rdclass); 80| 0| } 81| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 82| 2|} dns_zone_settype: 125| 2|dns_zone_settype(dns_zone_t *zone, dns_zonetype_t type) { 126| 2| char namebuf[1024]; 127| | 128| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 129| 2| REQUIRE(type != dns_zone_none); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 130| | 131| | /* 132| | * Test and set. 133| | */ 134| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 135| 2| REQUIRE(zone->type == dns_zone_none || zone->type == type); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 136| 2| zone->type = type; 137| | 138| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (138:6): [True: 2, False: 0] ------------------ 139| 2| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 166| 2| do { \ | | 167| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 2| (p) = NULL; \ | | 169| 2| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 2] | | ------------------ ------------------ 140| 2| } 141| | 142| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 143| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 144| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 145| 2|} dns_zone_setdbtype: 181| 2| const char *const *dbargv) { 182| 2| char **argv = NULL; 183| 2| unsigned int i; 184| | 185| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 186| 2| REQUIRE(dbargc >= 1); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 187| 2| REQUIRE(dbargv != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 188| | 189| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 190| | 191| | /* Set up a new database argument list. */ 192| 2| argv = isc_mem_cget(zone->mctx, dbargc, sizeof(*argv)); ------------------ | | 130| 2| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 2| ({ \ | | | | 33| 2| typeof(a) _c; \ | | | | 34| 2| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 2| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 131| 2| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 2|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 193| 4| for (i = 0; i < dbargc; i++) { ------------------ | Branch (193:14): [True: 2, False: 2] ------------------ 194| 2| argv[i] = NULL; 195| 2| } 196| 4| for (i = 0; i < dbargc; i++) { ------------------ | Branch (196:14): [True: 2, False: 2] ------------------ 197| 2| argv[i] = isc_mem_strdup(zone->mctx, dbargv[i]); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 198| 2| } 199| | 200| | /* Free the old list. */ 201| 2| dns__zone_freedbargs(zone); 202| | 203| 2| zone->db_argc = dbargc; 204| 2| zone->db_argv = argv; 205| | 206| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 207| 2|} dns_zone_setview: 210| 2|dns_zone_setview(dns_zone_t *zone, dns_view_t *view) { 211| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 212| | 213| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 214| 2| dns__zone_setview_helper(zone, view); 215| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 216| 2|} dns_zone_setorigin: 226| 2|dns_zone_setorigin(dns_zone_t *zone, const dns_name_t *origin) { 227| 2| char namebuf[1024]; 228| | 229| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 230| 2| REQUIRE(origin != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 231| | 232| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 233| 2| INSIST(zone != zone->raw); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 234| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (234:6): [True: 0, False: 2] ------------------ 235| 0| dns_name_free(&zone->origin, zone->mctx); 236| 0| dns_name_init(&zone->origin); 237| 0| } 238| 2| dns_name_dup(origin, zone->mctx, &zone->origin); 239| | 240| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (240:6): [True: 0, False: 2] ------------------ 241| 0| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 242| 0| } 243| 2| if (zone->strname != NULL) { ------------------ | Branch (243:6): [True: 0, False: 2] ------------------ 244| 0| isc_mem_free(zone->mctx, zone->strname); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 245| 0| } 246| | 247| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 248| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 249| 2| zone_name_tostr(zone, namebuf, sizeof namebuf); 250| 2| zone->strname = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 251| | 252| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (252:6): [True: 0, False: 2] ------------------ 253| 0| dns_zone_setorigin(zone->raw, origin); 254| 0| } 255| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 256| 2|} dns_zone_expandzonefile: 438| 2| const char *typename) { 439| 2| isc_result_t result; 440| 2| foundtoken_t founds[ARRAY_SIZE(tokens)]; 441| 2| dns_fixedname_t fz; 442| 2| size_t tags = 0; 443| 2| token_names_t names = { .zonename = dns_fixedname_initname(&fz), 444| 2| .viewname = viewname, 445| 2| .typename = typename }; 446| | 447| 2| REQUIRE(zonename != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 448| 2| REQUIRE(filename != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 449| 2| REQUIRE(typename != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 450| | 451| 2| if (viewname == NULL) { ------------------ | Branch (451:6): [True: 2, False: 0] ------------------ 452| 2| names.viewname = ""; 453| 2| } 454| | 455| | /* Normalize the name by converting to lower case */ 456| 2| result = dns_name_downcase(zonename, names.zonename); 457| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 458| | 459| 38| for (size_t i = 0; i < ARRAY_SIZE(tokens); i++) { ------------------ | | 94| 38|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (459:21): [True: 36, False: 2] ------------------ 460| 36| const token_t *token = &tokens[i]; 461| 36| const char *p = strcasestr(filename, token->name); 462| | 463| 36| if (p != NULL) { ------------------ | Branch (463:7): [True: 0, False: 36] ------------------ 464| 0| founds[tags++] = 465| 0| (foundtoken_t){ .pos = p, 466| 0| .len = strlen(token->name), 467| 0| .parse = token->parse }; 468| 0| } 469| 36| } 470| | 471| 2| if (tags == 0) { ------------------ | Branch (471:6): [True: 2, False: 0] ------------------ 472| 2| putmem(b, filename, strlen(filename)); 473| 2| goto cleanup; 474| 2| } 475| | 476| | /* sort the tag offsets in order of occurrence */ 477| 0| qsort(founds, tags, sizeof(foundtoken_t), foundtoken_order); 478| | 479| 0| const char *p = filename; 480| 0| for (size_t i = 0; i < tags; i++) { ------------------ | Branch (480:21): [True: 0, False: 0] ------------------ 481| 0| foundtoken_t *token = &founds[i]; 482| | 483| 0| CHECK(putmem(b, p, token->pos - p)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 484| | 485| 0| p = token->pos; 486| 0| INSIST(p != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 487| 0| CHECK(token->parse(&names, token, b)); ------------------ | | 251| 0| { \ | | 252| 0| result = (r); \ | | 253| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 0] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 0| } ------------------ 488| | 489| | /* Advance the input pointer past the token */ 490| 0| p += founds[i].len; 491| 0| } 492| | 493| 0| const char *end = filename + strlen(filename); 494| 0| putmem(b, p, end - p); 495| | 496| 2|cleanup: 497| 2| isc_buffer_putuint8(b, 0); 498| 2|} dns_zone_setfile: 519| 2| dns_masterformat_t format, const dns_master_style_t *style) { 520| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 521| 2| REQUIRE(zone->stream == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 522| | 523| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 524| 2| setfilename(zone, &zone->masterfile, file); 525| 2| setstring(zone, &zone->initfile, initial_file); 526| 2| zone->masterformat = format; 527| 2| if (format == dns_masterformat_text) { ------------------ | Branch (527:6): [True: 2, False: 0] ------------------ 528| 2| zone->masterstyle = style; 529| 2| } 530| 2| default_journal(zone); 531| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 532| 2|} dns_zone_getdb: 928| 209|dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) { 929| 209| isc_result_t result = ISC_R_SUCCESS; 930| | 931| 209| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 932| | 933| 209| ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read); ------------------ | | 112| 209|#define ZONEDB_LOCK(l, t) RWLOCK((l), (t)) | | ------------------ | | | | 30| 209| { \ | | | | 31| 209| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | 32| 209| (t), __FILE__, __LINE__)); \ | | | | 33| 209| isc_rwlock_lock((lp), (t)); \ | | | | ------------------ | | | | | | 252| 209| { \ | | | | | | 253| 209| switch (type) { \ | | | | | | 254| 209| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (254:3): [True: 209, False: 0] | | | | | | ------------------ | | | | | | 255| 209| isc_rwlock_rdlock(rwl); \ | | | | | | 256| 209| break; \ | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (257:3): [True: 0, False: 209] | | | | | | ------------------ | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | 259| 0| break; \ | | | | | | 260| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (260:3): [True: 0, False: 209] | | | | | | ------------------ | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 262| 209| } \ | | | | | | 263| 209| } | | | | ------------------ | | | | 34| 209| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | 35| 209| (lp), (t), __FILE__, __LINE__)); \ | | | | 36| 209| } | | ------------------ ------------------ 934| 209| if (zone->db == NULL) { ------------------ | Branch (934:6): [True: 0, False: 209] ------------------ 935| 0| result = DNS_R_NOTLOADED; 936| 209| } else { 937| 209| dns_db_attach(zone->db, dpb); 938| 209| } 939| 209| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read); ------------------ | | 113| 209|#define ZONEDB_UNLOCK(l, t) RWUNLOCK((l), (t)) | | ------------------ | | | | 38| 209| { \ | | | | 39| 209| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 209| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 209| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 209| { \ | | | | | | 283| 209| switch (type) { \ | | | | | | 284| 209| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 209, False: 0] | | | | | | ------------------ | | | | | | 285| 209| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 209| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 209] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 209] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 209| } \ | | | | | | 293| 209| } | | | | ------------------ | | | | 42| 209| } | | ------------------ ------------------ 940| | 941| 209| return result; 942| 209|} dns_zone_gettype: 1403| 629|dns_zone_gettype(dns_zone_t *zone) { 1404| 629| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 629|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 629, False: 0] | | | | | Branch (42:11): [True: 629, False: 0] | | | | ------------------ | | | | 43| 629| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1405| | 1406| 629| return zone->type; 1407| 629|} dns_zone_getorigin: 1410| 374|dns_zone_getorigin(dns_zone_t *zone) { 1411| 374| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 374|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 748| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 374, False: 0] | | | | | Branch (42:11): [True: 374, False: 0] | | | | ------------------ | | | | 43| 374| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1412| | 1413| 374| return &zone->origin; 1414| 374|} dns_zone_setkeydirectory: 1657| 2|dns_zone_setkeydirectory(dns_zone_t *zone, const char *directory) { 1658| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1659| | 1660| 2| LOCK_ZONE(zone); ------------------ | | 80| 2| do { \ | | 81| 2| LOCK(&(z)->lock); \ | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ | | 82| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 83| 2| (z)->locked = true; \ | | 84| 2| } while (0) | | ------------------ | | | Branch (84:11): [Folded, False: 2] | | ------------------ ------------------ 1661| 2| setstring(zone, &zone->keydirectory, directory); 1662| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 88| 2| (z)->locked = false; \ | | 89| 2| UNLOCK(&(z)->lock); \ | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ | | 90| 2| } while (0) | | ------------------ | | | Branch (90:11): [Folded, False: 2] | | ------------------ ------------------ 1663| 2|} zoneproperties.c:putmem: 300| 2|putmem(isc_buffer_t *b, const char *base, size_t length) { 301| 2| size_t space = isc_buffer_availablelength(b) - 1; ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 302| 2| if (space < length) { ------------------ | Branch (302:6): [True: 0, False: 2] ------------------ 303| 0| isc_buffer_putmem(b, (const unsigned char *)base, space); 304| 0| return ISC_R_NOSPACE; 305| 0| } 306| | 307| 2| isc_buffer_putmem(b, (const unsigned char *)base, length); 308| 2| return ISC_R_SUCCESS; 309| 2|} zoneproperties.c:setfilename: 501| 2|setfilename(dns_zone_t *zone, char **field, const char *value) { 502| 2| char filename[PATH_MAX]; 503| 2| isc_buffer_t b; 504| | 505| 2| if (value == NULL) { ------------------ | Branch (505:6): [True: 0, False: 2] ------------------ 506| 0| *field = NULL; 507| 0| return; 508| 0| } 509| | 510| 2| isc_buffer_init(&b, filename, sizeof(filename)); 511| 2| dns_zone_expandzonefile(&b, value, &zone->origin, 512| 2| zone->view != NULL ? zone->view->name : NULL, ------------------ | Branch (512:5): [True: 0, False: 2] ------------------ 513| 2| dns_zonetype_name(zone->type)); 514| 2| setstring(zone, field, filename); 515| 2|} zoneproperties.c:setstring: 259| 8|setstring(dns_zone_t *zone, char **field, const char *value) { 260| 8| char *copy; 261| | 262| 8| if (value != NULL) { ------------------ | Branch (262:6): [True: 6, False: 2] ------------------ 263| 6| copy = isc_mem_strdup(zone->mctx, value); ------------------ | | 144| 6|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 264| 6| } else { 265| 2| copy = NULL; 266| 2| } 267| | 268| 8| if (*field != NULL) { ------------------ | Branch (268:6): [True: 0, False: 8] ------------------ 269| 0| isc_mem_free(zone->mctx, *field); ------------------ | | 166| 0| do { \ | | 167| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 0| (p) = NULL; \ | | 169| 0| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 0] | | ------------------ ------------------ 270| 0| } 271| | 272| 8| *field = copy; 273| 8|} zoneproperties.c:default_journal: 582| 2|default_journal(dns_zone_t *zone) { 583| 2| char *journal; 584| | 585| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 586| 2| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 587| | 588| 2| if (zone->masterfile != NULL) { ------------------ | Branch (588:6): [True: 2, False: 0] ------------------ 589| | /* Calculate string length including '\0'. */ 590| 2| int len = strlen(zone->masterfile) + sizeof(".jnl"); 591| 2| journal = isc_mem_allocate(zone->mctx, len); ------------------ | | 138| 2|#define isc_mem_allocate(c, s) isc__mem_allocate((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 592| 2| strlcpy(journal, zone->masterfile, len); 593| 2| strlcat(journal, ".jnl", len); 594| 2| } else { 595| 0| journal = NULL; 596| 0| } 597| 2| setstring(zone, &zone->journal, journal); 598| 2| if (journal != NULL) { ------------------ | Branch (598:6): [True: 2, False: 0] ------------------ 599| | isc_mem_free(zone->mctx, journal); ------------------ | | 166| 2| do { \ | | 167| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 2| (p) = NULL; \ | | 169| 2| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 2] | | ------------------ ------------------ 600| 2| } 601| 2|} zoneproperties.c:zone_namerd_tostr: 1245| 6|zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length) { 1246| 6| isc_result_t result = ISC_R_FAILURE; 1247| 6| isc_buffer_t buffer; 1248| | 1249| 6| REQUIRE(buf != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1250| 6| REQUIRE(length > 1U); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1251| | 1252| | /* 1253| | * Leave space for terminating '\0'. 1254| | */ 1255| 6| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 1256| 6| if (zone->type != dns_zone_redirect && zone->type != dns_zone_key) { ------------------ | Branch (1256:6): [True: 6, False: 0] | Branch (1256:41): [True: 6, False: 0] ------------------ 1257| 6| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (1257:7): [True: 6, False: 0] ------------------ 1258| 6| result = dns_name_totext( 1259| 6| &zone->origin, DNS_NAME_OMITFINALDOT, &buffer); ------------------ | | 883| 6|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 1260| 6| } 1261| 6| if (result != ISC_R_SUCCESS && ------------------ | Branch (1261:7): [True: 0, False: 6] ------------------ 1262| 0| isc_buffer_availablelength(&buffer) >= ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1262:7): [True: 0, False: 0] ------------------ 1263| 0| (sizeof("") - 1)) 1264| 0| { 1265| 0| isc_buffer_putstr(&buffer, ""); 1266| 0| } 1267| | 1268| 6| if (isc_buffer_availablelength(&buffer) > 0) { ------------------ | | 161| 6|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1268:7): [True: 6, False: 0] ------------------ 1269| 6| isc_buffer_putstr(&buffer, "/"); 1270| 6| } 1271| 6| (void)dns_rdataclass_totext(zone->rdclass, &buffer); 1272| 6| } 1273| | 1274| 6| if (zone->view != NULL && strcmp(zone->view->name, "_bind") != 0 && ------------------ | Branch (1274:6): [True: 0, False: 6] | Branch (1274:28): [True: 0, False: 0] ------------------ 1275| 0| strcmp(zone->view->name, "_default") != 0 && ------------------ | Branch (1275:6): [True: 0, False: 0] ------------------ 1276| 0| strlen(zone->view->name) < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1276:6): [True: 0, False: 0] ------------------ 1277| 0| { 1278| 0| isc_buffer_putstr(&buffer, "/"); 1279| 0| isc_buffer_putstr(&buffer, zone->view->name); 1280| 0| } 1281| 6| if (dns__zone_inline_secure(zone) && ------------------ | Branch (1281:6): [True: 0, False: 6] ------------------ 1282| 0| 9U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1282:6): [True: 0, False: 0] ------------------ 1283| 0| { 1284| 0| isc_buffer_putstr(&buffer, " (signed)"); 1285| 0| } 1286| 6| if (dns__zone_inline_raw(zone) && ------------------ | Branch (1286:6): [True: 0, False: 6] ------------------ 1287| 0| 11U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1287:6): [True: 0, False: 0] ------------------ 1288| 0| { 1289| 0| isc_buffer_putstr(&buffer, " (unsigned)"); 1290| 0| } 1291| | 1292| 6| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 6|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1293| 6|} zoneproperties.c:zone_name_tostr: 1296| 2|zone_name_tostr(dns_zone_t *zone, char *buf, size_t length) { 1297| 2| isc_result_t result = ISC_R_FAILURE; 1298| 2| isc_buffer_t buffer; 1299| | 1300| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1301| 2| REQUIRE(length > 1U); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1302| | 1303| | /* 1304| | * Leave space for terminating '\0'. 1305| | */ 1306| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 1307| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (1307:6): [True: 2, False: 0] ------------------ 1308| 2| result = dns_name_totext(&zone->origin, DNS_NAME_OMITFINALDOT, ------------------ | | 883| 2|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 1309| 2| &buffer); 1310| 2| } 1311| 2| if (result != ISC_R_SUCCESS && ------------------ | Branch (1311:6): [True: 0, False: 2] ------------------ 1312| 0| isc_buffer_availablelength(&buffer) >= (sizeof("") - 1)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1312:6): [True: 0, False: 0] ------------------ 1313| 0| { 1314| 0| isc_buffer_putstr(&buffer, ""); 1315| 0| } 1316| | 1317| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1318| 2|} zoneproperties.c:zone_rdclass_tostr: 1321| 2|zone_rdclass_tostr(dns_zone_t *zone, char *buf, size_t length) { 1322| 2| isc_buffer_t buffer; 1323| | 1324| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1325| 2| REQUIRE(length > 1U); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1326| | 1327| | /* 1328| | * Leave space for terminating '\0'. 1329| | */ 1330| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 1331| 2| (void)dns_rdataclass_totext(zone->rdclass, &buffer); 1332| | 1333| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1334| 2|} dns_zt_create: 98| 2|dns_zt_create(isc_mem_t *mctx, dns_view_t *view, dns_zt_t **ztp) { 99| 2| dns_qpmulti_t *multi = NULL; 100| 2| dns_zt_t *zt = NULL; 101| | 102| 2| REQUIRE(ztp != NULL && *ztp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 103| 2| REQUIRE(view != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 104| | 105| 2| dns_qpmulti_create(mctx, &ztqpmethods, view, &multi); 106| | 107| 2| zt = isc_mem_get(mctx, sizeof(*zt)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 108| 2| *zt = (dns_zt_t){ 109| 2| .magic = ZTMAGIC, ------------------ | | 37| 2|#define ZTMAGIC ISC_MAGIC('Z', 'T', 'b', 'l') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 110| 2| .multi = multi, 111| 2| .references = 1, 112| 2| }; 113| | 114| 2| isc_mem_attach(mctx, &zt->mctx); 115| | 116| 2| *ztp = zt; 117| 2|} dns_zt_mount: 138| 2|dns_zt_mount(dns_zt_t *zt, dns_zone_t *zone) { 139| 2| isc_result_t result; 140| 2| dns_qp_t *qp = NULL; 141| | 142| 2| REQUIRE(VALID_ZT(zt)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 143| | 144| 2| dns_qpmulti_write(zt->multi, &qp); 145| 2| result = dns_qp_insert(qp, zone, 0); 146| 2| dns_qp_compact(qp, DNS_QPGC_MAYBE); 147| 2| dns_qpmulti_commit(zt->multi, &qp); 148| | 149| 2| return result; 150| 2|} dns_zt_find: 170| 372| dns_zone_t **zonep) { 171| 372| isc_result_t result; 172| 372| dns_qpread_t qpr; 173| 372| void *pval = NULL; 174| 372| dns_ztfind_t exactmask = DNS_ZTFIND_NOEXACT | DNS_ZTFIND_EXACT; 175| 372| dns_ztfind_t exactopts = options & exactmask; 176| 372| dns_qpchain_t chain; 177| | 178| 372| REQUIRE(VALID_ZT(zt)); ------------------ | | 194| 372|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 744| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 372, False: 0] | | | | | Branch (42:11): [True: 372, False: 0] | | | | ------------------ | | | | 43| 372| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 179| 372| REQUIRE(exactopts != exactmask); ------------------ | | 194| 372|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 372| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 372, False: 0] | | | | ------------------ | | | | 43| 372| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 180| | 181| 372| dns_qpmulti_query(zt->multi, &qpr); 182| | 183| 372| if (exactopts == DNS_ZTFIND_EXACT) { ------------------ | Branch (183:6): [True: 0, False: 372] ------------------ 184| 0| result = dns_qp_getname(&qpr, name, DNS_DBNAMESPACE_NORMAL, 185| 0| &pval, NULL); 186| 372| } else { 187| 372| result = dns_qp_lookup(&qpr, name, DNS_DBNAMESPACE_NORMAL, NULL, 188| 372| &chain, &pval, NULL); 189| 372| if (exactopts == DNS_ZTFIND_NOEXACT && result == ISC_R_SUCCESS) ------------------ | Branch (189:7): [True: 0, False: 372] | Branch (189:42): [True: 0, False: 0] ------------------ 190| 0| { 191| | /* get pval from the previous chain link */ 192| 0| int len = dns_qpchain_length(&chain); 193| 0| if (len >= 2) { ------------------ | Branch (193:8): [True: 0, False: 0] ------------------ 194| 0| dns_qpchain_node(&chain, len - 2, &pval, NULL); 195| 0| result = DNS_R_PARTIALMATCH; 196| 0| } else { 197| 0| result = ISC_R_NOTFOUND; 198| 0| } 199| 0| } 200| 372| } 201| 372| dns_qpread_destroy(zt->multi, &qpr); 202| | 203| 372| if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) { ------------------ | Branch (203:6): [True: 132, False: 240] | Branch (203:33): [True: 77, False: 163] ------------------ 204| 209| dns_zone_t *zone = pval; 205| | /* 206| | * If DNS_ZTFIND_MIRROR is set and the zone which was 207| | * determined to be the deepest match for the supplied name is 208| | * a mirror zone which is expired or not yet loaded, treat it 209| | * as non-existent. This will trigger a fallback to recursion 210| | * instead of returning a SERVFAIL. 211| | * 212| | * Note that currently only the deepest match in the zone table 213| | * is checked. Consider a server configured with two mirror 214| | * zones: "bar" and its child, "foo.bar". If zone data is 215| | * available for "bar" but not for "foo.bar", a query with 216| | * QNAME equal to or below "foo.bar" will cause ISC_R_NOTFOUND 217| | * to be returned, not DNS_R_PARTIALMATCH, despite zone data 218| | * being available for "bar". This is considered to be an edge 219| | * case, handling which more appropriately is possible, but 220| | * arguably not worth the added complexity. 221| | */ 222| 209| if ((options & DNS_ZTFIND_MIRROR) != 0 && ------------------ | Branch (222:7): [True: 209, False: 0] ------------------ 223| 209| dns_zone_gettype(zone) == dns_zone_mirror && ------------------ | Branch (223:7): [True: 0, False: 209] ------------------ 224| 0| !dns_zone_isloaded(zone)) ------------------ | Branch (224:7): [True: 0, False: 0] ------------------ 225| 0| { 226| 0| result = ISC_R_NOTFOUND; 227| 209| } else { 228| 209| dns_zone_attach(zone, zonep); 229| 209| } 230| 209| } 231| | 232| 372| return result; 233| 372|} zt.c:ztqpattach: 64| 2| uint32_t ival ISC_ATTR_UNUSED) { 65| 2| dns_zone_t *zone = pval; 66| 2| dns_zone_ref(zone); 67| 2|} zt.c:ztqpmakekey: 78| 374| uint32_t ival ISC_ATTR_UNUSED) { 79| 374| dns_zone_t *zone = pval; 80| 374| dns_name_t *name = dns_zone_getorigin(zone); 81| 374| return dns_qpkey_fromname(key, name, DNS_DBNAMESPACE_NORMAL); 82| 374|} isc_base64_tobuffer: 175| 2|isc_base64_tobuffer(isc_lex_t *lexer, isc_buffer_t *target, int length) { 176| 2| unsigned int before, after; 177| 2| base64_decode_ctx_t ctx; 178| 2| isc_textregion_t *tr; 179| 2| isc_token_t token; 180| 2| bool eol; 181| | 182| 2| REQUIRE(length >= isc_one_or_more); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 183| | 184| 2| base64_decode_init(&ctx, length, target); 185| | 186| 2| before = isc_buffer_usedlength(target); ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 187| 16| while (!ctx.seen_end && (ctx.length != 0)) { ------------------ | Branch (187:9): [True: 14, False: 2] | Branch (187:26): [True: 14, False: 0] ------------------ 188| 14| unsigned int i; 189| | 190| 14| if (length > 0) { ------------------ | Branch (190:7): [True: 0, False: 14] ------------------ 191| 0| eol = false; 192| 14| } else { 193| 14| eol = true; 194| 14| } 195| 14| RETERR(isc_lex_getmastertoken(lexer, &token, ------------------ | | 272| 14| { \ | | 273| 14| isc_result_t _r = (x); \ | | 274| 14| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 14] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 14| } ------------------ 196| 14| isc_tokentype_string, eol)); 197| 14| if (token.type != isc_tokentype_string) { ------------------ | Branch (197:7): [True: 0, False: 14] ------------------ 198| 0| break; 199| 0| } 200| 14| tr = &token.value.as_textregion; 201| 710| for (i = 0; i < tr->length; i++) { ------------------ | Branch (201:15): [True: 696, False: 14] ------------------ 202| 696| RETERR(base64_decode_char(&ctx, tr->base[i])); ------------------ | | 272| 696| { \ | | 273| 696| isc_result_t _r = (x); \ | | 274| 696| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 696] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 696| } ------------------ 203| 696| } 204| 14| } 205| 2| after = isc_buffer_usedlength(target); ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 206| 2| if (ctx.length < 0 && !ctx.seen_end) { ------------------ | Branch (206:6): [True: 2, False: 0] | Branch (206:24): [True: 0, False: 2] ------------------ 207| 0| isc_lex_ungettoken(lexer, &token); 208| 0| } 209| 2| RETERR(base64_decode_finish(&ctx)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 210| 2| if (length == isc_one_or_more && before == after) { ------------------ | Branch (210:6): [True: 2, False: 0] | Branch (210:35): [True: 0, False: 2] ------------------ 211| 0| return ISC_R_UNEXPECTEDEND; 212| 0| } 213| 2| return ISC_R_SUCCESS; 214| 2|} base64.c:base64_decode_init: 97| 2|base64_decode_init(base64_decode_ctx_t *ctx, int length, isc_buffer_t *target) { 98| 2| ctx->digits = 0; 99| | ctx->seen_end = false; 100| 2| ctx->length = length; 101| 2| ctx->target = target; 102| 2|} base64.c:base64_decode_char: 105| 696|base64_decode_char(base64_decode_ctx_t *ctx, int c) { 106| 696| const char *s; 107| | 108| 696| if (ctx->seen_end) { ------------------ | Branch (108:6): [True: 0, False: 696] ------------------ 109| 0| return ISC_R_BADBASE64; 110| 0| } 111| 696| if ((s = strchr(base64, c)) == NULL) { ------------------ | Branch (111:6): [True: 0, False: 696] ------------------ 112| 0| return ISC_R_BADBASE64; 113| 0| } 114| 696| ctx->val[ctx->digits++] = (int)(s - base64); 115| 696| if (ctx->digits == 4) { ------------------ | Branch (115:6): [True: 174, False: 522] ------------------ 116| 174| int n; 117| 174| unsigned char buf[3]; 118| 174| if (ctx->val[0] == 64 || ctx->val[1] == 64) { ------------------ | Branch (118:7): [True: 0, False: 174] | Branch (118:28): [True: 0, False: 174] ------------------ 119| 0| return ISC_R_BADBASE64; 120| 0| } 121| 174| if (ctx->val[2] == 64 && ctx->val[3] != 64) { ------------------ | Branch (121:7): [True: 0, False: 174] | Branch (121:28): [True: 0, False: 0] ------------------ 122| 0| return ISC_R_BADBASE64; 123| 0| } 124| | /* 125| | * Check that bits that should be zero are. 126| | */ 127| 174| if (ctx->val[2] == 64 && (ctx->val[1] & 0xf) != 0) { ------------------ | Branch (127:7): [True: 0, False: 174] | Branch (127:28): [True: 0, False: 0] ------------------ 128| 0| return ISC_R_BADBASE64; 129| 0| } 130| | /* 131| | * We don't need to test for ctx->val[2] != 64 as 132| | * the bottom two bits of 64 are zero. 133| | */ 134| 174| if (ctx->val[3] == 64 && (ctx->val[2] & 0x3) != 0) { ------------------ | Branch (134:7): [True: 2, False: 172] | Branch (134:28): [True: 0, False: 2] ------------------ 135| 0| return ISC_R_BADBASE64; 136| 0| } 137| 174| n = (ctx->val[2] == 64) ? 1 : (ctx->val[3] == 64) ? 2 : 3; ------------------ | Branch (137:7): [True: 0, False: 174] | Branch (137:33): [True: 2, False: 172] ------------------ 138| 174| if (n != 3) { ------------------ | Branch (138:7): [True: 2, False: 172] ------------------ 139| 2| ctx->seen_end = true; 140| 2| if (ctx->val[2] == 64) { ------------------ | Branch (140:8): [True: 0, False: 2] ------------------ 141| 0| ctx->val[2] = 0; 142| 0| } 143| 2| if (ctx->val[3] == 64) { ------------------ | Branch (143:8): [True: 2, False: 0] ------------------ 144| 2| ctx->val[3] = 0; 145| 2| } 146| 2| } 147| 174| buf[0] = (ctx->val[0] << 2) | (ctx->val[1] >> 4); 148| 174| buf[1] = (ctx->val[1] << 4) | (ctx->val[2] >> 2); 149| 174| buf[2] = (ctx->val[2] << 6) | (ctx->val[3]); 150| 174| RETERR(mem_tobuffer(ctx->target, buf, n)); ------------------ | | 272| 174| { \ | | 273| 174| isc_result_t _r = (x); \ | | 274| 174| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 174] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 174| } ------------------ 151| 174| if (ctx->length >= 0) { ------------------ | Branch (151:7): [True: 0, False: 174] ------------------ 152| 0| if (n > ctx->length) { ------------------ | Branch (152:8): [True: 0, False: 0] ------------------ 153| 0| return ISC_R_BADBASE64; 154| 0| } else { 155| 0| ctx->length -= n; 156| 0| } 157| 0| } 158| 174| ctx->digits = 0; 159| 174| } 160| 696| return ISC_R_SUCCESS; 161| 696|} base64.c:mem_tobuffer: 253| 174|mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length) { 254| 174| isc_region_t tr; 255| | 256| 174| isc_buffer_availableregion(target, &tr); 257| 174| if (length > tr.length) { ------------------ | Branch (257:6): [True: 0, False: 174] ------------------ 258| 0| return ISC_R_NOSPACE; 259| 0| } 260| 174| memmove(tr.base, base, length); 261| 174| isc_buffer_add(target, length); 262| 174| return ISC_R_SUCCESS; 263| 174|} base64.c:base64_decode_finish: 164| 2|base64_decode_finish(base64_decode_ctx_t *ctx) { 165| 2| if (ctx->length > 0) { ------------------ | Branch (165:6): [True: 0, False: 2] ------------------ 166| 0| return ISC_R_UNEXPECTEDEND; 167| 0| } 168| 2| if (ctx->digits != 0) { ------------------ | Branch (168:6): [True: 0, False: 2] ------------------ 169| 0| return ISC_R_BADBASE64; 170| 0| } 171| 2| return ISC_R_SUCCESS; 172| 2|} isc_hmac: 140| 12| unsigned int *digestlen) { 141| 12| EVP_MAC_CTX *ctx; 142| 12| size_t maclen; 143| | 144| 12| REQUIRE(type < ISC_MD_MAX); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 145| | 146| 12| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (146:6): [True: 0, False: 12] ------------------ 147| 0| return ISC_R_NOTIMPLEMENTED; 148| 0| } 149| | 150| 12| ctx = EVP_MAC_CTX_new(evp_hmac); 151| 12| RUNTIME_CHECK(ctx != NULL); ------------------ | | 241| 12| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 12, False: 0] | | ------------------ ------------------ 152| | 153| 12| if (EVP_MAC_init(ctx, key, keylen, md_to_hmac_params[type]) != 1) { ------------------ | Branch (153:6): [True: 0, False: 12] ------------------ 154| 0| goto fail; 155| 0| } 156| | 157| 12| if (EVP_MAC_update(ctx, buf, len) != 1) { ------------------ | Branch (157:6): [True: 0, False: 12] ------------------ 158| 0| goto fail; 159| 0| } 160| | 161| 12| maclen = *digestlen; 162| 12| if (EVP_MAC_final(ctx, digest, &maclen, maclen) != 1) { ------------------ | Branch (162:6): [True: 0, False: 12] ------------------ 163| 0| goto fail; 164| 0| } 165| | 166| 12| *digestlen = maclen; 167| | 168| 12| EVP_MAC_CTX_free(ctx); 169| 12| return ISC_R_SUCCESS; 170| | 171| 0|fail: 172| 0| ERR_clear_error(); 173| 0| EVP_MAC_CTX_free(ctx); 174| 0| return ISC_R_CRYPTOFAILURE; 175| 12|} isc_hmac_key_create: 184| 2| isc_mem_t *mctx, isc_hmac_key_t **keyp) { 185| 2| isc_hmac_key_t *key; 186| 2| uint8_t digest[ISC_MAX_MD_SIZE]; 187| 2| unsigned int digest_len = sizeof(digest); 188| 2| size_t key_len; 189| | 190| 2| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 191| 2| REQUIRE(type < ISC_MD_MAX); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 192| | 193| 2| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (193:6): [True: 0, False: 2] ------------------ 194| 0| return ISC_R_NOTIMPLEMENTED; 195| 0| } 196| | 197| 2| if (len > (size_t)EVP_MD_block_size(isc__crypto_md[type])) { ------------------ | Branch (197:6): [True: 0, False: 2] ------------------ 198| 0| RETERR(isc_md(type, secret, len, digest, &digest_len)); ------------------ | | 272| 0| { \ | | 273| 0| isc_result_t _r = (x); \ | | 274| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 0] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 0| } ------------------ 199| 0| secret = digest; 200| 0| key_len = digest_len; 201| 2| } else { 202| 2| key_len = len; 203| 2| } 204| | 205| 2| key = isc_mem_get(mctx, STRUCT_FLEX_SIZE(key, secret, key_len)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 206| 2| *key = (isc_hmac_key_t){ 207| 2| .magic = hmac_key_magic, 208| 2| .len = key_len, 209| 2| .params = md_to_hmac_params[type], 210| 2| }; 211| 2| memmove(key->secret, secret, key_len); 212| 2| isc_mem_attach(mctx, &key->mctx); 213| | 214| 2| *keyp = key; 215| | 216| 2| return ISC_R_SUCCESS; 217| 2|} isc_hmac_key_expose: 237| 4|isc_hmac_key_expose(isc_hmac_key_t *key) { 238| 4| REQUIRE(key != NULL && key->magic == hmac_key_magic); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 239| | 240| 4| return (isc_region_t){ .base = key->secret, .length = key->len }; 241| 4|} isc_hmac_new: 260| 46|isc_hmac_new(void) { 261| 46| EVP_MAC_CTX *ctx = EVP_MAC_CTX_new(evp_hmac); 262| 46| RUNTIME_CHECK(ctx != NULL); ------------------ | | 241| 46| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 46, False: 0] | | ------------------ ------------------ 263| 46| return ctx; 264| 46|} isc_hmac_free: 267| 46|isc_hmac_free(isc_hmac_t *hmac) { 268| 46| EVP_MAC_CTX_free(hmac); 269| 46|} isc_hmac_init: 272| 46|isc_hmac_init(isc_hmac_t *hmac, isc_hmac_key_t *key) { 273| 46| REQUIRE(key != NULL && key->magic == hmac_key_magic); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 92| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 46, False: 0] | | | | | Branch (42:11): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 274| 46| REQUIRE(hmac != NULL); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 46| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 275| | 276| 46| if (EVP_MAC_init(hmac, key->secret, key->len, key->params) != 1) { ------------------ | Branch (276:6): [True: 0, False: 46] ------------------ 277| 0| ERR_clear_error(); 278| 0| return ISC_R_CRYPTOFAILURE; 279| 0| } 280| | 281| 46| return ISC_R_SUCCESS; 282| 46|} isc_hmac_update: 285| 311|isc_hmac_update(isc_hmac_t *hmac, const unsigned char *buf, const size_t len) { 286| 311| REQUIRE(hmac != NULL); ------------------ | | 194| 311|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 311| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 311, False: 0] | | | | ------------------ | | | | 43| 311| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 287| | 288| 311| if (buf == NULL || len == 0) { ------------------ | Branch (288:6): [True: 0, False: 311] | Branch (288:21): [True: 0, False: 311] ------------------ 289| 0| return ISC_R_SUCCESS; 290| 0| } 291| | 292| 311| if (EVP_MAC_update(hmac, buf, len) != 1) { ------------------ | Branch (292:6): [True: 0, False: 311] ------------------ 293| 0| ERR_clear_error(); 294| 0| return ISC_R_CRYPTOFAILURE; 295| 0| } 296| | 297| 311| return ISC_R_SUCCESS; 298| 311|} isc_hmac_final: 301| 46|isc_hmac_final(isc_hmac_t *hmac, isc_buffer_t *out) { 302| 46| size_t len; 303| | 304| 46| REQUIRE(hmac != NULL); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 46| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 305| | 306| 46| len = isc_buffer_availablelength(out); ------------------ | | 161| 46|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 307| 46| if (len < EVP_MAC_CTX_get_mac_size(hmac)) { ------------------ | Branch (307:6): [True: 0, False: 46] ------------------ 308| 0| return ISC_R_NOSPACE; 309| 0| } 310| | 311| 46| if (EVP_MAC_final(hmac, isc_buffer_used(out), &len, len) != 1) { ------------------ | | 149| 46| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ | Branch (311:6): [True: 0, False: 46] ------------------ 312| 0| ERR_clear_error(); 313| 0| return ISC_R_CRYPTOFAILURE; 314| 0| } 315| | 316| 46| isc_buffer_add(out, len); 317| | 318| 46| return ISC_R_SUCCESS; 319| 46|} isc_crypto_fips_mode: 322| 2|isc_crypto_fips_mode(void) { 323| | return EVP_default_properties_is_fips_enabled(NULL) != 0; 324| 2|} isc__crypto_initialize: 376| 2|isc__crypto_initialize(void) { 377| | /* 378| | * We call OPENSSL_cleanup() manually, in a correct order, thus disable 379| | * the automatic atexit() handler. 380| | */ 381| 2| uint64_t opts = OPENSSL_INIT_LOAD_CONFIG | OPENSSL_INIT_NO_ATEXIT; 382| | 383| 2| RUNTIME_CHECK(OPENSSL_init_ssl(opts, NULL) == 1); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 384| | 385| 2| register_algorithms(); 386| | 387| |#if defined(ENABLE_FIPS_MODE) 388| | if (isc_crypto_fips_enable() != ISC_R_SUCCESS) { 389| | ERR_clear_error(); 390| | FATAL_ERROR("Failed to toggle FIPS mode but is " 391| | "required for this build"); 392| | } 393| |#endif 394| | 395| | /* Protect ourselves against unseeded PRNG */ 396| 2| if (RAND_status() != 1) { ------------------ | Branch (396:6): [True: 0, False: 2] ------------------ 397| 0| isc_ossl_wrap_logged_toresult( ------------------ | | 26| 0| isc__ossl_wrap_logged_toresult(category, module, funcname, fallback, \ | | 27| 0| __FILE__, __LINE__) ------------------ 398| 0| ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_CRYPTO, 399| 0| "RAND_status", ISC_R_CRYPTOFAILURE); 400| 0| FATAL_ERROR("OpenSSL pseudorandom number generator " ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 401| 0| "cannot be initialized (see the `PRNG not " 402| 0| "seeded' message in the OpenSSL FAQ)"); 403| 0| } 404| 2|} ossl3.c:register_algorithms: 89| 2|register_algorithms(void) { 90| 2| if (!isc_crypto_fips_mode()) { ------------------ | Branch (90:6): [True: 2, False: 0] ------------------ 91| 2| md_register_algorithm(MD5); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 92| 2| } 93| | 94| 2| md_register_algorithm(SHA1); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 95| 2| md_register_algorithm(SHA224); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 96| 2| md_register_algorithm(SHA256); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 97| 2| md_register_algorithm(SHA384); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 98| 2| md_register_algorithm(SHA512); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 99| | 100| | /* We _must_ have HMAC */ 101| 2| evp_hmac = EVP_MAC_fetch(NULL, "HMAC", NULL); 102| 2| if (evp_hmac == NULL) { ------------------ | Branch (102:6): [True: 0, False: 2] ------------------ 103| 0| ERR_clear_error(); 104| 0| FATAL_ERROR("OpenSSL failed to find an HMAC implementation. " ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 105| 0| "Please make sure the default provider has an " 106| 0| "EVP_MAC-HMAC implementation"); 107| 0| } 108| | 109| 2| return ISC_R_SUCCESS; 110| 2|} isc___errno2result: 32| 8| unsigned int line) { 33| 8| char strbuf[ISC_STRERRORSIZE]; 34| | 35| 8| switch (posixerrno) { 36| 0| case ENOTDIR: ------------------ | Branch (36:2): [True: 0, False: 8] ------------------ 37| 0| case ELOOP: ------------------ | Branch (37:2): [True: 0, False: 8] ------------------ 38| 0| case EINVAL: /* XXX sometimes this is not for files */ ------------------ | Branch (38:2): [True: 0, False: 8] ------------------ 39| 0| case ENAMETOOLONG: ------------------ | Branch (39:2): [True: 0, False: 8] ------------------ 40| 0| case EBADF: ------------------ | Branch (40:2): [True: 0, False: 8] ------------------ 41| 0| return ISC_R_INVALIDFILE; 42| 0| case EISDIR: ------------------ | Branch (42:2): [True: 0, False: 8] ------------------ 43| 0| return ISC_R_NOTFILE; 44| 8| case ENOENT: ------------------ | Branch (44:2): [True: 8, False: 0] ------------------ 45| 8| return ISC_R_FILENOTFOUND; 46| 0| case EACCES: ------------------ | Branch (46:2): [True: 0, False: 8] ------------------ 47| 0| case EPERM: ------------------ | Branch (47:2): [True: 0, False: 8] ------------------ 48| 0| case EROFS: ------------------ | Branch (48:2): [True: 0, False: 8] ------------------ 49| 0| return ISC_R_NOPERM; 50| 0| case EEXIST: ------------------ | Branch (50:2): [True: 0, False: 8] ------------------ 51| 0| return ISC_R_FILEEXISTS; 52| 0| case EIO: ------------------ | Branch (52:2): [True: 0, False: 8] ------------------ 53| 0| return ISC_R_IOERROR; 54| 0| case ENOMEM: ------------------ | Branch (54:2): [True: 0, False: 8] ------------------ 55| 0| return ISC_R_NOMEMORY; 56| 0| case ENFILE: ------------------ | Branch (56:2): [True: 0, False: 8] ------------------ 57| 0| case EMFILE: ------------------ | Branch (57:2): [True: 0, False: 8] ------------------ 58| 0| return ISC_R_TOOMANYOPENFILES; 59| 0|#ifdef EDQUOT 60| 0| case EDQUOT: ------------------ | Branch (60:2): [True: 0, False: 8] ------------------ 61| 0| return ISC_R_DISCQUOTA; 62| 0|#endif /* ifdef EDQUOT */ 63| 0| case ENOSPC: ------------------ | Branch (63:2): [True: 0, False: 8] ------------------ 64| 0| return ISC_R_DISCFULL; 65| 0|#ifdef EOVERFLOW 66| 0| case EOVERFLOW: ------------------ | Branch (66:2): [True: 0, False: 8] ------------------ 67| 0| return ISC_R_RANGE; 68| 0|#endif /* ifdef EOVERFLOW */ 69| 0| case EPIPE: ------------------ | Branch (69:2): [True: 0, False: 8] ------------------ 70| 0|#ifdef ECONNRESET 71| 0| case ECONNRESET: ------------------ | Branch (71:2): [True: 0, False: 8] ------------------ 72| 0|#endif /* ifdef ECONNRESET */ 73| 0|#ifdef ECONNABORTED 74| 0| case ECONNABORTED: ------------------ | Branch (74:2): [True: 0, False: 8] ------------------ 75| 0|#endif /* ifdef ECONNABORTED */ 76| 0| return ISC_R_CONNECTIONRESET; 77| 0|#ifdef ENOTCONN 78| 0| case ENOTCONN: ------------------ | Branch (78:2): [True: 0, False: 8] ------------------ 79| 0| return ISC_R_NOTCONNECTED; 80| 0|#endif /* ifdef ENOTCONN */ 81| 0|#ifdef ETIMEDOUT 82| 0| case ETIMEDOUT: ------------------ | Branch (82:2): [True: 0, False: 8] ------------------ 83| 0| return ISC_R_TIMEDOUT; 84| 0|#endif /* ifdef ETIMEDOUT */ 85| 0|#ifdef ENOBUFS 86| 0| case ENOBUFS: ------------------ | Branch (86:2): [True: 0, False: 8] ------------------ 87| 0| return ISC_R_NORESOURCES; 88| 0|#endif /* ifdef ENOBUFS */ 89| 0|#ifdef EAFNOSUPPORT 90| 0| case EAFNOSUPPORT: ------------------ | Branch (90:2): [True: 0, False: 8] ------------------ 91| 0| return ISC_R_FAMILYNOSUPPORT; 92| 0|#endif /* ifdef EAFNOSUPPORT */ 93| 0|#ifdef ENETDOWN 94| 0| case ENETDOWN: ------------------ | Branch (94:2): [True: 0, False: 8] ------------------ 95| 0| return ISC_R_NETDOWN; 96| 0|#endif /* ifdef ENETDOWN */ 97| 0|#ifdef EHOSTDOWN 98| 0| case EHOSTDOWN: ------------------ | Branch (98:2): [True: 0, False: 8] ------------------ 99| 0| return ISC_R_HOSTDOWN; 100| 0|#endif /* ifdef EHOSTDOWN */ 101| 0|#ifdef ENETUNREACH 102| 0| case ENETUNREACH: ------------------ | Branch (102:2): [True: 0, False: 8] ------------------ 103| 0| return ISC_R_NETUNREACH; 104| 0|#endif /* ifdef ENETUNREACH */ 105| 0|#ifdef EHOSTUNREACH 106| 0| case EHOSTUNREACH: ------------------ | Branch (106:2): [True: 0, False: 8] ------------------ 107| 0| return ISC_R_HOSTUNREACH; 108| 0|#endif /* ifdef EHOSTUNREACH */ 109| 0|#ifdef EADDRINUSE 110| 0| case EADDRINUSE: ------------------ | Branch (110:2): [True: 0, False: 8] ------------------ 111| 0| return ISC_R_ADDRINUSE; 112| 0|#endif /* ifdef EADDRINUSE */ 113| 0| case EADDRNOTAVAIL: ------------------ | Branch (113:2): [True: 0, False: 8] ------------------ 114| 0| return ISC_R_ADDRNOTAVAIL; 115| 0| case ECONNREFUSED: ------------------ | Branch (115:2): [True: 0, False: 8] ------------------ 116| 0| return ISC_R_CONNREFUSED; 117| 0| default: ------------------ | Branch (117:2): [True: 0, False: 8] ------------------ 118| 0| if (dolog) { ------------------ | Branch (118:7): [True: 0, False: 0] ------------------ 119| 0| strerror_r(posixerrno, strbuf, sizeof(strbuf)); ------------------ | | 33| 0|#define strerror_r isc_string_strerror_r ------------------ 120| 0| UNEXPECTED_ERROR(file, line, ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 121| 0| "unable to convert errno " 122| 0| "to isc_result: %d: %s", 123| 0| posixerrno, strbuf); 124| 0| } 125| | /* 126| | * XXXDCL would be nice if perhaps this function could 127| | * return the system's error string, so the caller 128| | * might have something more descriptive than "unexpected 129| | * error" to log with. 130| | */ 131| 0| return ISC_R_UNEXPECTED; 132| 8| } 133| 8|} isc_file_getmodtime: 153| 2|isc_file_getmodtime(const char *file, isc_time_t *modtime) { 154| 2| isc_result_t result; 155| 2| struct stat stats; 156| | 157| 2| REQUIRE(file != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 158| 2| REQUIRE(modtime != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 159| | 160| 2| result = file_stats(file, &stats); 161| | 162| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (162:6): [True: 2, False: 0] ------------------ 163| 2|#if defined(HAVE_STAT_NSEC) 164| 2| isc_time_set(modtime, stats.st_mtime, stats.st_mtim.tv_nsec); 165| |#else /* if defined(HAVE_STAT_NSEC) */ 166| | isc_time_set(modtime, stats.st_mtime, 0); 167| |#endif /* if defined(HAVE_STAT_NSEC) */ 168| 2| } 169| | 170| 2| return result; 171| 2|} isc_file_exists: 429| 6|isc_file_exists(const char *pathname) { 430| 6| struct stat stats; 431| | 432| 6| REQUIRE(pathname != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 433| | 434| 6| return file_stats(pathname, &stats) == ISC_R_SUCCESS; 435| 6|} isc_file_sanitize: 706| 2| char *path, size_t length) { 707| 2| char buf[PATH_MAX]; 708| 2| unsigned char digest[ISC_MAX_MD_SIZE]; 709| 2| unsigned int digestlen; 710| 2| char hash[ISC_MAX_MD_SIZE * 2 + 1]; 711| 2| size_t l = 0; 712| | 713| 2| REQUIRE(base != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 714| 2| REQUIRE(path != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 715| | 716| 2| l = strlen(base) + 1; 717| | 718| | /* 719| | * allow room for a full sha256 hash (64 chars 720| | * plus null terminator) 721| | */ 722| 2| if (l < 65U) { ------------------ | Branch (722:6): [True: 2, False: 0] ------------------ 723| 2| l = 65; 724| 2| } 725| | 726| 2| if (dir != NULL) { ------------------ | Branch (726:6): [True: 0, False: 2] ------------------ 727| 0| l += strlen(dir) + 1; 728| 0| } 729| 2| if (ext != NULL) { ------------------ | Branch (729:6): [True: 2, False: 0] ------------------ 730| 2| l += strlen(ext) + 1; 731| 2| } 732| | 733| 2| if (l > length || l > (unsigned int)PATH_MAX) { ------------------ | Branch (733:6): [True: 0, False: 2] | Branch (733:20): [True: 0, False: 2] ------------------ 734| 0| return ISC_R_NOSPACE; 735| 0| } 736| | 737| | /* Check whether the full-length SHA256 hash filename exists */ 738| 2| RETERR(isc_md(ISC_MD_SHA256, (const unsigned char *)base, strlen(base), ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 739| 2| digest, &digestlen)); 740| | 741| 2| RETERR(digest2hex(digest, digestlen, hash, sizeof(hash))); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 742| | 743| 2| snprintf(buf, sizeof(buf), "%s%s%s%s%s", dir != NULL ? dir : "", ------------------ | Branch (743:43): [True: 0, False: 2] ------------------ 744| 2| dir != NULL ? "/" : "", hash, ext != NULL ? "." : "", ------------------ | Branch (744:4): [True: 0, False: 2] | Branch (744:34): [True: 2, False: 0] ------------------ 745| 2| ext != NULL ? ext : ""); ------------------ | Branch (745:4): [True: 2, False: 0] ------------------ 746| 2| if (isc_file_exists(buf)) { ------------------ | Branch (746:6): [True: 0, False: 2] ------------------ 747| 0| strlcpy(path, buf, length); 748| 0| return ISC_R_SUCCESS; 749| 0| } 750| | 751| | /* Check for a truncated SHA256 hash filename */ 752| 2| hash[16] = '\0'; 753| 2| snprintf(buf, sizeof(buf), "%s%s%s%s%s", dir != NULL ? dir : "", ------------------ | Branch (753:43): [True: 0, False: 2] ------------------ 754| 2| dir != NULL ? "/" : "", hash, ext != NULL ? "." : "", ------------------ | Branch (754:4): [True: 0, False: 2] | Branch (754:34): [True: 2, False: 0] ------------------ 755| 2| ext != NULL ? ext : ""); ------------------ | Branch (755:4): [True: 2, False: 0] ------------------ 756| 2| if (isc_file_exists(buf)) { ------------------ | Branch (756:6): [True: 0, False: 2] ------------------ 757| 0| strlcpy(path, buf, length); 758| 0| return ISC_R_SUCCESS; 759| 0| } 760| | 761| | /* 762| | * If neither hash filename already exists, then we'll use 763| | * the original base name if it has no disallowed characters, 764| | * or the truncated hash name if it does. 765| | */ 766| 2| if (strpbrk(base, DISALLOW) != NULL) { ------------------ | | 687| 2|#define DISALLOW "\\/ABCDEFGHIJKLMNOPQRSTUVWXYZ" ------------------ | Branch (766:6): [True: 0, False: 2] ------------------ 767| 0| strlcpy(path, buf, length); 768| 0| return ISC_R_SUCCESS; 769| 0| } 770| | 771| 2| snprintf(buf, sizeof(buf), "%s%s%s%s%s", dir != NULL ? dir : "", ------------------ | Branch (771:43): [True: 0, False: 2] ------------------ 772| 2| dir != NULL ? "/" : "", base, ext != NULL ? "." : "", ------------------ | Branch (772:4): [True: 0, False: 2] | Branch (772:34): [True: 2, False: 0] ------------------ 773| 2| ext != NULL ? ext : ""); ------------------ | Branch (773:4): [True: 2, False: 0] ------------------ 774| 2| strlcpy(path, buf, length); 775| 2| return ISC_R_SUCCESS; 776| 2|} file.c:file_stats: 81| 8|file_stats(const char *file, struct stat *stats) { 82| 8| isc_result_t result = ISC_R_SUCCESS; 83| | 84| 8| REQUIRE(file != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 85| 8| REQUIRE(stats != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 86| | 87| 8| if (stat(file, stats) != 0) { ------------------ | Branch (87:6): [True: 4, False: 4] ------------------ 88| 4| result = isc__errno2result(errno); ------------------ | | 25| 4|#define isc__errno2result(x) isc___errno2result(x, true, __FILE__, __LINE__) ------------------ 89| 4| } 90| | 91| 8| return result; 92| 8|} file.c:digest2hex: 691| 2| size_t hashlen) { 692| 2| unsigned int i; 693| 2| int ret; 694| 66| for (i = 0; i < digestlen; i++) { ------------------ | Branch (694:14): [True: 64, False: 2] ------------------ 695| 64| size_t left = hashlen - i * 2; 696| 64| ret = snprintf(hash + i * 2, left, "%02x", digest[i]); 697| 64| if (ret < 0 || (size_t)ret >= left) { ------------------ | Branch (697:7): [True: 0, False: 64] | Branch (697:18): [True: 0, False: 64] ------------------ 698| 0| return ISC_R_NOSPACE; 699| 0| } 700| 64| } 701| 2| return ISC_R_SUCCESS; 702| 2|} isc__hash_initialize: 30| 2|isc__hash_initialize(void) { 31| | /* 32| | * Set a constant key to help in problem reproduction should 33| | * fuzzing find a crash or a hang. 34| | */ 35| 2| uint8_t key[16] = { 1 }; 36| |#if !FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 37| | isc_random_buf(key, sizeof(key)); 38| |#endif /* if FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */ 39| 2| STATIC_ASSERT(sizeof(key) >= sizeof(isc_hash_key), ------------------ | | 150| 2|#define STATIC_ASSERT(cond, msg) _Static_assert(cond, msg) ------------------ 40| 2| "sizeof(key) < sizeof(isc_hash_key)"); 41| 2| memmove(isc_hash_key, key, sizeof(isc_hash_key)); 42| 2|} isc_hash32_init: 57| 623|isc_hash32_init(isc_hash32_t *restrict state) { 58| 623| isc_halfsiphash13_init(state, isc_hash_key); 59| 623|} isc_hash32_hash: 63| 623| const size_t length, const bool case_sensitive) { 64| 623| REQUIRE(length == 0 || data != NULL); ------------------ | | 194| 623|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 623] | | | | | Branch (42:11): [True: 623, False: 0] | | | | ------------------ | | | | 43| 623| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 65| | 66| 623| isc_halfsiphash13_hash(state, data, length, case_sensitive); 67| 623|} isc_hash32_finalize: 70| 623|isc_hash32_finalize(isc_hash32_t *restrict state) { 71| 623| uint32_t hval; 72| | 73| 623| isc_halfsiphash13_finalize(state, (uint8_t *)&hval); 74| | 75| 623| return hval; 76| 623|} isc_hashmap_create: 209| 8|isc_hashmap_create(isc_mem_t *mctx, uint8_t bits, isc_hashmap_t **hashmapp) { 210| 8| isc_hashmap_t *hashmap = isc_mem_get(mctx, sizeof(*hashmap)); ------------------ | | 128| 8|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 211| | 212| 8| REQUIRE(hashmapp != NULL && *hashmapp == NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 213| 8| REQUIRE(mctx != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 214| 8| REQUIRE(bits >= HASHMAP_MIN_BITS && bits <= HASHMAP_MAX_BITS); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 215| | 216| 8| *hashmap = (isc_hashmap_t){ 217| 8| .magic = ISC_HASHMAP_MAGIC, ------------------ | | 57| 8|#define ISC_HASHMAP_MAGIC ISC_MAGIC('H', 'M', 'a', 'p') | | ------------------ | | | | 31| 8|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 218| 8| }; 219| 8| isc_mem_attach(mctx, &hashmap->mctx); 220| | 221| 8| hashmap_create_table(hashmap, 0, bits); 222| | 223| 8| hashmap->magic = ISC_HASHMAP_MAGIC; ------------------ | | 57| 8|#define ISC_HASHMAP_MAGIC ISC_MAGIC('H', 'M', 'a', 'p') | | ------------------ | | | | 31| 8|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 224| | 225| 8| *hashmapp = hashmap; 226| 8|} isc_hashmap_find: 294| 621| isc_hashmap_match_fn match, const void *key, void **valuep) { 295| 621| REQUIRE(ISC_HASHMAP_VALID(hashmap)); ------------------ | | 194| 621|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 621, False: 0] | | | | | Branch (42:11): [True: 621, False: 0] | | | | ------------------ | | | | 43| 621| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 296| 621| REQUIRE(valuep == NULL || *valuep == NULL); ------------------ | | 194| 621|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 621] | | | | | Branch (42:11): [True: 621, False: 0] | | | | ------------------ | | | | 43| 621| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 297| | 298| 621| uint8_t idx = hashmap->hindex; 299| 621| hashmap_node_t *node = hashmap_find(hashmap, hashval, match, key, 300| 621| &(uint32_t){ 0 }, &idx); 301| 621| if (node == NULL) { ------------------ | Branch (301:6): [True: 399, False: 222] ------------------ 302| 399| return ISC_R_NOTFOUND; 303| 399| } 304| | 305| 222| INSIST(node->key != NULL); ------------------ | | 198| 222|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 222| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 222, False: 0] | | | | ------------------ | | | | 55| 222| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 306| | SET_IF_NOT_NULL(valuep, node->value); ------------------ | | 100| 222| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 222, False: 0] | | ------------------ | | 101| 222| *(obj) = (val); \ | | 102| 222| } ------------------ 307| 222| return ISC_R_SUCCESS; 308| 621|} isc_hashmap_add: 568| 2| void **foundp) { 569| 2| REQUIRE(ISC_HASHMAP_VALID(hashmap)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 570| 2| REQUIRE(key != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 571| | 572| 2| if (rehashing_in_progress(hashmap)) { ------------------ | Branch (572:6): [True: 0, False: 2] ------------------ 573| 0| hashmap_rehash_one(hashmap); 574| 2| } else if (over_threshold(hashmap)) { ------------------ | Branch (574:13): [True: 0, False: 2] ------------------ 575| 0| hashmap_rehash_start_grow(hashmap); 576| 0| hashmap_rehash_one(hashmap); 577| 0| } 578| | 579| 2| if (rehashing_in_progress(hashmap)) { ------------------ | Branch (579:6): [True: 0, False: 2] ------------------ 580| 0| uint8_t fidx = hashmap_nexttable(hashmap->hindex); 581| 0| uint32_t psl; 582| | 583| | /* Look for the value in the old table */ 584| 0| hashmap_node_t *found = hashmap_find(hashmap, hashval, match, 585| 0| key, &psl, &fidx); 586| 0| if (found != NULL) { ------------------ | Branch (586:7): [True: 0, False: 0] ------------------ 587| 0| INSIST(found->key != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 588| 0| SET_IF_NOT_NULL(foundp, found->value); ------------------ | | 100| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 0] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 589| 0| return ISC_R_EXISTS; 590| 0| } 591| 0| } 592| | 593| 2| return hashmap_add(hashmap, hashval, match, key, value, foundp, 594| 2| hashmap->hindex); 595| 2|} hashmap.c:hashmap_create_table: 168| 8| const uint8_t bits) { 169| 8| REQUIRE(hashmap->tables[idx].hashbits == HASHMAP_NO_BITS); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 170| 8| REQUIRE(hashmap->tables[idx].table == NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 171| 8| REQUIRE(bits >= HASHMAP_MIN_BITS); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 172| 8| REQUIRE(bits <= HASHMAP_MAX_BITS); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 173| | 174| 8| hashmap->tables[idx] = (hashmap_table_t){ 175| 8| .hashbits = bits, 176| 8| .hashmask = HASHSIZE(bits) - 1, ------------------ | | 63| 8|#define HASHSIZE(bits) (UINT64_C(1) << (bits)) ------------------ 177| 8| .size = HASHSIZE(bits), ------------------ | | 63| 8|#define HASHSIZE(bits) (UINT64_C(1) << (bits)) ------------------ 178| 8| }; 179| | 180| 8| hashmap->tables[idx].table = 181| | isc_mem_cget(hashmap->mctx, hashmap->tables[idx].size, ------------------ | | 130| 8| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 8| ({ \ | | | | 33| 8| typeof(a) _c; \ | | | | 34| 8| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 8| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 8|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 8| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 8| _c; \ | | | | 37| 8| }) | | ------------------ | | 131| 8| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 8|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 182| 8| sizeof(hashmap->tables[idx].table[0])); 183| 8|} hashmap.c:hashmap_find: 253| 621| uint8_t *idxp) { 254| 621| uint32_t hash; 255| 621| uint32_t psl; 256| 621| uint8_t idx = *idxp; 257| 621| uint32_t pos; 258| | 259| 621|nexttable: 260| 621| psl = 0; 261| 621| hash = isc_hash_bits32(hashval, hashmap->tables[idx].hashbits); 262| | 263| 621| while (true) { ------------------ | Branch (263:9): [True: 621, Folded] ------------------ 264| 621| hashmap_node_t *node = NULL; 265| | 266| 621| pos = (hash + psl) & hashmap->tables[idx].hashmask; 267| | 268| 621| node = &hashmap->tables[idx].table[pos]; 269| | 270| 621| if (node->key == NULL || psl > node->psl) { ------------------ | Branch (270:7): [True: 399, False: 222] | Branch (270:28): [True: 0, False: 222] ------------------ 271| 399| break; 272| 399| } 273| | 274| 222| if (node->hashval == hashval) { ------------------ | Branch (274:7): [True: 222, False: 0] ------------------ 275| 222| if (match(node->value, key)) { ------------------ | Branch (275:8): [True: 222, False: 0] ------------------ 276| 222| *pslp = psl; 277| 222| *idxp = idx; 278| 222| return node; 279| 222| } 280| 222| } 281| | 282| 0| psl++; 283| 0| } 284| 399| if (try_nexttable(hashmap, idx)) { ------------------ | Branch (284:6): [True: 0, False: 399] ------------------ 285| 0| idx = hashmap_nexttable(idx); 286| 0| goto nexttable; 287| 0| } 288| | 289| 399| return NULL; 290| 399|} hashmap.c:try_nexttable: 129| 399|try_nexttable(const isc_hashmap_t *hashmap, uint8_t idx) { 130| 399| return idx == hashmap->hindex && rehashing_in_progress(hashmap); ------------------ | Branch (130:9): [True: 399, False: 0] | Branch (130:35): [True: 0, False: 399] ------------------ 131| 399|} hashmap.c:rehashing_in_progress: 123| 403|rehashing_in_progress(const isc_hashmap_t *hashmap) { 124| 403| return hashmap->tables[hashmap_nexttable(hashmap->hindex)].table != 125| | NULL; 126| 403|} hashmap.c:over_threshold: 482| 2|over_threshold(isc_hashmap_t *hashmap) { 483| 2| uint32_t bits = hashmap->tables[hashmap->hindex].hashbits; 484| 2| if (bits == HASHMAP_MAX_BITS) { ------------------ | | 67| 2|#define HASHMAP_MAX_BITS 32U ------------------ | Branch (484:6): [True: 0, False: 2] ------------------ 485| 0| return false; 486| 0| } 487| 2| size_t threshold = APPROX_90_PERCENT(HASHSIZE(bits)); ------------------ | | 45| 2|#define APPROX_90_PERCENT(x) (((x) * 921) >> 10) ------------------ 488| 2| return hashmap->count > threshold; 489| 2|} hashmap.c:hashmap_nexttable: 118| 403|hashmap_nexttable(uint8_t idx) { 119| 403| return (idx == 0) ? 1 : 0; ------------------ | Branch (119:9): [True: 403, False: 0] ------------------ 120| 403|} hashmap.c:hashmap_add: 504| 2| void **foundp, uint8_t idx) { 505| 2| uint32_t hash; 506| 2| uint32_t psl = 0; 507| 2| hashmap_node_t node; 508| 2| hashmap_node_t *current = NULL; 509| 2| uint32_t pos; 510| | 511| 2| INSIST(atomic_load_acquire(&hashmap->iterators) == 0); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 512| | 513| 2| hash = isc_hash_bits32(hashval, hashmap->tables[idx].hashbits); 514| | 515| | /* Initialize the node to be store to 'node' */ 516| 2| hashmap_node_init(&node, hashval, key, value); 517| | 518| 2| psl = 0; 519| 2| while (true) { ------------------ | Branch (519:9): [True: 2, Folded] ------------------ 520| 2| pos = (hash + psl) & hashmap->tables[idx].hashmask; 521| | 522| 2| current = &hashmap->tables[idx].table[pos]; 523| | 524| | /* Found an empty node */ 525| 2| if (current->key == NULL) { ------------------ | Branch (525:7): [True: 2, False: 0] ------------------ 526| 2| break; 527| 2| } 528| | 529| 0| if (current->hashval == hashval) { ------------------ | Branch (529:7): [True: 0, False: 0] ------------------ 530| 0| if (match != NULL && match(current->value, key)) { ------------------ | Branch (530:8): [True: 0, False: 0] | Branch (530:25): [True: 0, False: 0] ------------------ 531| 0| SET_IF_NOT_NULL(foundp, current->value); ------------------ | | 100| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 0, False: 0] | | ------------------ | | 101| 0| *(obj) = (val); \ | | 102| 0| } ------------------ 532| 0| return ISC_R_EXISTS; 533| 0| } 534| 0| } 535| | 536| | /* Found rich node */ 537| 0| if (node.psl > current->psl) { ------------------ | Branch (537:7): [True: 0, False: 0] ------------------ 538| | /* Swap the poor with the rich node */ 539| 0| ISC_SWAP(*current, node); ------------------ | | 301| 0| { \ | | 302| 0| typeof(a) __tmp_swap = a; \ | | 303| 0| a = b; \ | | 304| 0| b = __tmp_swap; \ | | 305| 0| } ------------------ 540| 0| } 541| | 542| 0| node.psl++; 543| 0| psl++; 544| 0| } 545| | 546| | /* 547| | * Possible optimalization - start growing when the poor node is too far 548| | */ 549| |#if ISC_HASHMAP_GROW_FAST 550| | if (psl > hashmap->hashbits[idx]) { 551| | if (!rehashing_in_progress(hashmap)) { 552| | hashmap_rehash_start_grow(hashmap); 553| | } 554| | } 555| |#endif 556| | 557| 2| hashmap->count++; 558| | 559| | /* We found an empty place, store entry into current node */ 560| 2| *current = node; 561| | 562| 2| return ISC_R_SUCCESS; 563| 2|} hashmap.c:hashmap_node_init: 135| 2| const uint8_t *key, void *value) { 136| 2| *node = (hashmap_node_t){ 137| 2| .value = value, 138| 2| .hashval = hashval, 139| 2| .key = key, 140| 2| .psl = 0, 141| 2| }; 142| 2|} isc_heap_create: 84| 2| unsigned int size_increment, isc_heap_t **heapp) { 85| 2| isc_heap_t *heap; 86| | 87| 2| REQUIRE(heapp != NULL && *heapp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 88| 2| REQUIRE(compare != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 89| | 90| 2| heap = isc_mem_get(mctx, sizeof(*heap)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 91| 2| heap->magic = HEAP_MAGIC; ------------------ | | 46| 2|#define HEAP_MAGIC ISC_MAGIC('H', 'E', 'A', 'P') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 92| 2| heap->size = 0; 93| 2| heap->mctx = NULL; 94| 2| isc_mem_attach(mctx, &heap->mctx); 95| 2| if (size_increment == 0) { ------------------ | Branch (95:6): [True: 2, False: 0] ------------------ 96| 2| heap->size_increment = SIZE_INCREMENT; ------------------ | | 44| 2|#define SIZE_INCREMENT 1024 ------------------ 97| 2| } else { 98| 0| heap->size_increment = size_increment; 99| 0| } 100| 2| heap->last = 0; 101| 2| heap->array = NULL; 102| 2| heap->compare = compare; 103| 2| heap->index = idx; 104| | 105| 2| *heapp = heap; 106| 2|} name.c:isc_ascii_lowercmp: 171| 14|isc_ascii_lowercmp(const uint8_t *a, const uint8_t *b, unsigned int len) { 172| 14| uint64_t a8 = 0, b8 = 0; 173| 14| while (len >= 8) { ------------------ | Branch (173:9): [True: 0, False: 14] ------------------ 174| 0| a8 = isc_ascii_tolower8(htobe64(isc__ascii_load8(a))); 175| 0| b8 = isc_ascii_tolower8(htobe64(isc__ascii_load8(b))); 176| 0| if (a8 != b8) { ------------------ | Branch (176:7): [True: 0, False: 0] ------------------ 177| 0| goto ret; 178| 0| } 179| 0| len -= 8; 180| 0| a += 8; 181| 0| b += 8; 182| 0| } 183| 56| while (len-- > 0) { ------------------ | Branch (183:9): [True: 42, False: 14] ------------------ 184| 42| a8 = isc_ascii_tolower(*a++); ------------------ | | 31| 42|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 185| 42| b8 = isc_ascii_tolower(*b++); ------------------ | | 31| 42|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 186| 42| if (a8 != b8) { ------------------ | Branch (186:7): [True: 0, False: 42] ------------------ 187| 0| goto ret; 188| 0| } 189| 42| } 190| 14|ret: 191| 14| if (a8 < b8) { ------------------ | Branch (191:6): [True: 0, False: 14] ------------------ 192| 0| return -1; 193| 0| } 194| 14| if (a8 > b8) { ------------------ | Branch (194:6): [True: 0, False: 14] ------------------ 195| 0| return +1; 196| 0| } 197| 14| return 0; 198| 14|} name.c:isc_ascii_tolower8: 71| 3.32k|isc_ascii_tolower8(uint64_t octets) { 72| | /* 73| | * Multiply a single-byte constant by `all_bytes` to replicate 74| | * it to all eight bytes in a word. 75| | */ 76| 3.32k| uint64_t all_bytes = 0x0101010101010101; 77| | /* 78| | * Clear the top bit of each byte to make space for a per-byte flag. 79| | */ 80| 3.32k| uint64_t heptets = octets & (0x7F * all_bytes); 81| | /* 82| | * We will need to avoid going wrong if our flag bits were originally 83| | * set, and clear calculation leftovers in our non-flag bits 84| | */ 85| 3.32k| uint64_t is_ascii = ~octets & (0x80 * all_bytes); 86| | /* 87| | * To compare a heptet to `N`, we can add `0x7F - N` so that carry 88| | * propagation will set the flag when our heptet is greater than `N` 89| | */ 90| 3.32k| uint64_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes; 91| | /* 92| | * Add one for greater-than-or-equal comparison 93| | */ 94| 3.32k| uint64_t is_ge_A = heptets + (0x80 - 'A') * all_bytes; 95| | /* 96| | * Now we have what we need to identify the ascii uppercase bytes 97| | */ 98| 3.32k| uint64_t is_upper = (is_ge_A ^ is_gt_Z) & is_ascii; 99| | /* 100| | * Move the is_upper flag bits to bit 0x20 (which is 'a' - 'A') 101| | * and use them to adjust each byte as required 102| | */ 103| 3.32k| return octets | (is_upper >> 2); 104| 3.32k|} name.c:isc__ascii_load8: 124| 3.32k|isc__ascii_load8(const uint8_t *ptr) { 125| 3.32k| uint64_t bytes = 0; 126| 3.32k| memmove(&bytes, ptr, sizeof(bytes)); 127| 3.32k| return bytes; 128| 3.32k|} name.c:isc_ascii_lowerequal: 135| 1.39k| unsigned int len) { 136| 1.39k| uint64_t a8 = 0, b8 = 0; 137| 1.39k| if (len >= 8) { ------------------ | Branch (137:6): [True: 955, False: 443] ------------------ 138| 955| const uint8_t *a_tail = a + len - 8; 139| 955| const uint8_t *b_tail = b + len - 8; 140| 1.66k| while (len >= 8) { ------------------ | Branch (140:10): [True: 970, False: 694] ------------------ 141| 970| a8 = isc_ascii_tolower8(isc__ascii_load8(a)); 142| 970| b8 = isc_ascii_tolower8(isc__ascii_load8(b)); 143| 970| if (a8 != b8) { ------------------ | Branch (143:8): [True: 261, False: 709] ------------------ 144| 261| return false; 145| 261| } 146| 709| len -= 8; 147| 709| a += 8; 148| 709| b += 8; 149| 709| } 150| | 151| 694| a8 = isc_ascii_tolower8(isc__ascii_load8(a_tail)); 152| 694| b8 = isc_ascii_tolower8(isc__ascii_load8(b_tail)); 153| 694| return a8 == b8; 154| 955| } 155| | 156| 886| while (len-- > 0) { ------------------ | Branch (156:9): [True: 443, False: 443] ------------------ 157| 443| if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 443|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 443|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ | Branch (157:7): [True: 0, False: 443] ------------------ 158| 0| return false; 159| 0| } 160| 443| } 161| 443| return true; 162| 443|} name.c:isc_ascii_lowercopy: 47| 327|isc_ascii_lowercopy(uint8_t *dst, const uint8_t *src, unsigned int len) { 48| 3.59k| while (len-- > 0) { ------------------ | Branch (48:9): [True: 3.26k, False: 327] ------------------ 49| 3.26k| *dst++ = isc__ascii_tolower1(*src++); 50| 3.26k| } 51| 327|} name.c:isc__ascii_tolower1: 39| 3.26k|isc__ascii_tolower1(uint8_t c) { 40| 3.26k| return c + ('a' - 'A') * ('A' <= c && c <= 'Z'); ------------------ | Branch (40:28): [True: 2.28k, False: 981] | Branch (40:40): [True: 0, False: 2.28k] ------------------ 41| 3.26k|} hash.c:isc__ascii_tolower1: 39| 1.24k|isc__ascii_tolower1(uint8_t c) { 40| 1.24k| return c + ('a' - 'A') * ('A' <= c && c <= 'Z'); ------------------ | Branch (40:28): [True: 623, False: 623] | Branch (40:40): [True: 0, False: 623] ------------------ 41| 1.24k|} hash.c:isc_ascii_tolower4: 110| 1.24k|isc_ascii_tolower4(uint32_t octets) { 111| 1.24k| uint32_t all_bytes = 0x01010101; 112| 1.24k| uint32_t heptets = octets & (0x7F * all_bytes); 113| 1.24k| uint32_t is_ascii = ~octets & (0x80 * all_bytes); 114| 1.24k| uint32_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes; 115| 1.24k| uint32_t is_ge_A = heptets + (0x80 - 'A') * all_bytes; 116| 1.24k| uint32_t is_upper = (is_ge_A ^ is_gt_Z) & is_ascii; 117| 1.24k| return octets | (is_upper >> 2); 118| 1.24k|} hash.c:isc_rotate_left32: 81| 22.4k|isc_rotate_left32(const uint32_t x, uint32_t n) { 82| 22.4k| return (x << n) | (x >> (32 - n)); 83| 22.4k|} dns_message_checksig.c:isc_buffer_putuint8: 869| 2.25k|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 2.25k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 2.25k| { \ | | 858| 2.25k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 2.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 4.50k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 2.25k, False: 0] | | | | | | | Branch (42:11): [True: 2.25k, False: 0] | | | | | | ------------------ | | | | | | 43| 2.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 2.25k| \ | | 860| 2.25k| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 2.25k] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 2.25k| \ | | 865| 2.25k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 2.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2.25k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2.25k, False: 0] | | | | | | ------------------ | | | | | | 43| 2.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 2.25k| } ------------------ 871| | 872| 2.25k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 2.25k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 2.25k| b->used += sizeof(val); 874| 2.25k| cp[0] = val; 875| 2.25k|} dns_message_checksig.c:isc_buffer_init: 524| 1.80k| const unsigned int length) { 525| 1.80k| REQUIRE(b != NULL); ------------------ | | 194| 1.80k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.80k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.80k, False: 0] | | | | ------------------ | | | | 43| 1.80k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 1.80k| *b = (isc_buffer_t){ 528| 1.80k| .base = base, 529| 1.80k| .length = length, 530| 1.80k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 1.80k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 1.80k| { \ | | | | 27| 1.80k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 1.80k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 1.80k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 1.80k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 1.80k| } | | ------------------ ------------------ 531| 1.80k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 1.80k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 1.80k| }; 533| 1.80k|} dns_message_checksig.c:isc_buffer_putmem: 965| 2.93k| const unsigned int length) { 966| 2.93k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2.93k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.87k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.93k, False: 0] | | | | | Branch (42:11): [True: 2.93k, False: 0] | | | | ------------------ | | | | 43| 2.93k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 967| | 968| 2.93k| if (b->mctx) { ------------------ | Branch (968:6): [True: 0, False: 2.93k] ------------------ 969| 0| isc_result_t result = isc_buffer_reserve(b, length); 970| 0| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 194| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 971| 0| } 972| | 973| 2.93k| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 194| 2.93k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.93k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.93k, False: 0] | | | | ------------------ | | | | 43| 2.93k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 974| | 975| 2.93k| if (length > 0U) { ------------------ | Branch (975:6): [True: 2.92k, False: 8] ------------------ 976| 2.92k| memmove(isc_buffer_used(b), base, length); ------------------ | | 149| 2.92k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 977| 2.92k| b->used += length; 978| 2.92k| } 979| 2.93k|} dns_message_checksig.c:isc_buffer_putuint16: 897| 18.7k|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 898| 18.7k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 18.7k| { \ | | 858| 18.7k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 18.7k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 37.5k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 18.7k, False: 0] | | | | | | | Branch (42:11): [True: 18.7k, False: 0] | | | | | | ------------------ | | | | | | 43| 18.7k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 18.7k| \ | | 860| 18.7k| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 18.7k] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 18.7k| \ | | 865| 18.7k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 18.7k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 18.7k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 18.7k, False: 0] | | | | | | ------------------ | | | | | | 43| 18.7k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 18.7k| } ------------------ 899| | 900| 18.7k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 18.7k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 901| 18.7k| b->used += sizeof(val); 902| 18.7k| ISC_U16TO8_BE(cp, val); ------------------ | | 221| 18.7k| (p)[0] = (uint8_t)((v) >> 8); \ | | 222| 18.7k| (p)[1] = (uint8_t)((v)); ------------------ 903| 18.7k|} dns_message_checksig.c:isc_buffer_putuint32: 925| 1.79k|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 926| 1.79k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 1.79k| { \ | | 858| 1.79k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 1.79k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 3.59k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 1.79k, False: 0] | | | | | | | Branch (42:11): [True: 1.79k, False: 0] | | | | | | ------------------ | | | | | | 43| 1.79k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 1.79k| \ | | 860| 1.79k| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 1.79k] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 1.79k| \ | | 865| 1.79k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 1.79k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 1.79k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 1.79k, False: 0] | | | | | | ------------------ | | | | | | 43| 1.79k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 1.79k| } ------------------ 927| | 928| 1.79k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 1.79k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 929| 1.79k| b->used += sizeof(val); 930| | 931| 1.79k| ISC_U32TO8_BE(cp, val); ------------------ | | 227| 1.79k| (p)[0] = (uint8_t)((v) >> 24); \ | | 228| 1.79k| (p)[1] = (uint8_t)((v) >> 16); \ | | 229| 1.79k| (p)[2] = (uint8_t)((v) >> 8); \ | | 230| 1.79k| (p)[3] = (uint8_t)((v)); ------------------ 932| 1.79k|} fixedname.c:isc_buffer_init: 524| 4.26k| const unsigned int length) { 525| 4.26k| REQUIRE(b != NULL); ------------------ | | 194| 4.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.26k, False: 0] | | | | ------------------ | | | | 43| 4.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 4.26k| *b = (isc_buffer_t){ 528| 4.26k| .base = base, 529| 4.26k| .length = length, 530| 4.26k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.26k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.26k| { \ | | | | 27| 4.26k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.26k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.26k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.26k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.26k| } | | ------------------ ------------------ 531| 4.26k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 4.26k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 4.26k| }; 533| 4.26k|} message.c:isc_buffer_allocate: 1077| 2.16k| const unsigned int length) { 1078| 2.16k| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.33k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1079| | 1080| 2.16k| isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length); ------------------ | | 128| 2.16k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1081| 2.16k| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1082| | 1083| 2.16k| isc_buffer_init(dbuf, bdata, length); 1084| 2.16k| dbuf->extra = length; 1085| 2.16k| isc_buffer_setmctx(dbuf, mctx); 1086| | 1087| 2.16k| *dbufp = dbuf; 1088| 2.16k|} message.c:isc_buffer_setmctx: 1091| 2.16k|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1092| 2.16k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.33k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1093| | 1094| 2.16k| b->mctx = mctx; 1095| 2.16k|} message.c:isc_buffer_free: 1154| 2.16k|isc_buffer_free(isc_buffer_t **restrict dbufp) { 1155| 2.16k| REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp)); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8.67k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1156| 2.16k| REQUIRE((*dbufp)->mctx != NULL); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1157| | 1158| 2.16k| isc_buffer_t *dbuf = *dbufp; 1159| 2.16k| isc_mem_t *mctx = dbuf->mctx; 1160| 2.16k| unsigned int extra = dbuf->extra; 1161| | 1162| 2.16k| *dbufp = NULL; /* destroy external reference */ 1163| | 1164| 2.16k| isc_buffer_clearmctx(dbuf); 1165| | 1166| 2.16k| isc_buffer_invalidate(dbuf); 1167| | isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra); ------------------ | | 150| 2.16k| do { \ | | 151| 2.16k| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2.16k| (p) = NULL; \ | | 153| 2.16k| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2.16k] | | ------------------ ------------------ 1168| 2.16k|} message.c:isc_buffer_clearmctx: 1098| 2.16k|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1099| 2.16k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.33k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1100| | 1101| 2.16k| if (b->dynamic) { ------------------ | Branch (1101:6): [True: 0, False: 2.16k] ------------------ 1102| 0| isc_mem_put(b->mctx, b->base, b->length); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 1103| 0| b->dynamic = false; 1104| 0| } 1105| | 1106| | b->mctx = NULL; 1107| 2.16k|} message.c:isc_buffer_invalidate: 577| 2.16k|isc_buffer_invalidate(isc_buffer_t *restrict b) { 578| 2.16k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.33k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | | Branch (42:11): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 579| 2.16k| REQUIRE(!ISC_LINK_LINKED(b, link)); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 580| 2.16k| REQUIRE(b->mctx == NULL); ------------------ | | 194| 2.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.16k, False: 0] | | | | ------------------ | | | | 43| 2.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 581| | 582| 2.16k| *b = (isc_buffer_t){ 583| 2.16k| .magic = 0, 584| 2.16k| }; 585| 2.16k|} message.c:isc_buffer_usedregion: 616| 2.01k| isc_region_t *restrict r) { 617| 2.01k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.01k, False: 0] | | | | | Branch (42:11): [True: 2.01k, False: 0] | | | | ------------------ | | | | 43| 2.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 2.01k| REQUIRE(r != NULL); ------------------ | | 194| 2.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.01k, False: 0] | | | | ------------------ | | | | 43| 2.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 2.01k| r->base = b->base; 621| 2.01k| r->length = b->used; 622| 2.01k|} message.c:isc_buffer_remainingregion: 730| 9.07k|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 731| 9.07k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 9.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 18.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 9.07k, False: 0] | | | | | Branch (42:11): [True: 9.07k, False: 0] | | | | ------------------ | | | | 43| 9.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 9.07k| REQUIRE(r != NULL); ------------------ | | 194| 9.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 9.07k, False: 0] | | | | ------------------ | | | | 43| 9.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| | 734| 9.07k| r->base = isc_buffer_current(b); ------------------ | | 145| 9.07k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 735| 9.07k| r->length = isc_buffer_remaininglength(b); ------------------ | | 159| 9.07k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 736| 9.07k|} message.c:isc_buffer_getuint16: 888| 17.5k|isc_buffer_getuint16(isc_buffer_t *restrict b) { 889| 17.5k| uint16_t val = 0; 890| 17.5k| isc_result_t result = isc_buffer_peekuint16(b, &val); 891| 17.5k| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 17.5k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 17.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 17.5k, False: 0] | | | | ------------------ | | | | 49| 17.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 892| 17.5k| b->current += sizeof(val); 893| 17.5k| return val; 894| 17.5k|} message.c:isc_buffer_peekuint16: 878| 17.5k|isc_buffer_peekuint16(const isc_buffer_t *restrict b, uint16_t *valp) { 879| 17.5k| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 17.5k| { \ | | 832| 17.5k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 17.5k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 35.0k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 17.5k, False: 0] | | | | | | | Branch (42:11): [True: 17.5k, False: 0] | | | | | | ------------------ | | | | | | 43| 17.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 17.5k| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 17.5k] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 17.5k| } ------------------ 880| | 881| 17.5k| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 17.5k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 882| | 883| | SET_IF_NOT_NULL(valp, ISC_U8TO16_BE(cp)); ------------------ | | 100| 17.5k| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 17.5k, False: 0] | | ------------------ | | 101| 17.5k| *(obj) = (val); \ | | 102| 17.5k| } ------------------ 884| 17.5k| return ISC_R_SUCCESS; 885| 17.5k|} message.c:isc_buffer_add: 652| 1.05k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 1.05k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 1.05k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.11k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.05k, False: 0] | | | | | Branch (42:11): [True: 1.05k, False: 0] | | | | ------------------ | | | | 43| 1.05k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 1.05k| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 1.05k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.05k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.05k, False: 0] | | | | ------------------ | | | | 43| 1.05k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 1.05k| b->used += n; 657| 1.05k|} message.c:isc_buffer_reserve: 1110| 208|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1111| 208| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1112| | 1113| 208| size_t len; 1114| | 1115| 208| len = dbuf->length; 1116| 208| if ((len - dbuf->used) >= size) { ------------------ | Branch (1116:6): [True: 208, False: 0] ------------------ 1117| 208| return ISC_R_SUCCESS; 1118| 208| } 1119| | 1120| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1120:6): [True: 0, False: 0] ------------------ 1121| 0| return ISC_R_NOSPACE; 1122| 0| } 1123| | 1124| | /* Round to nearest buffer size increment */ 1125| 0| len = size + dbuf->used; 1126| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 292| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1127| | 1128| | /* Cap at UINT_MAX */ 1129| 0| if (len > UINT_MAX) { ------------------ | Branch (1129:6): [True: 0, False: 0] ------------------ 1130| 0| len = UINT_MAX; 1131| 0| } 1132| | 1133| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1133:6): [True: 0, False: 0] ------------------ 1134| 0| return ISC_R_NOMEMORY; 1135| 0| } 1136| | 1137| 0| if (!dbuf->dynamic) { ------------------ | Branch (1137:6): [True: 0, False: 0] ------------------ 1138| 0| void *old_base = dbuf->base; 1139| 0| dbuf->base = isc_mem_get(dbuf->mctx, len); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1140| 0| if (old_base != NULL) { ------------------ | Branch (1140:7): [True: 0, False: 0] ------------------ 1141| 0| memmove(dbuf->base, old_base, dbuf->used); 1142| 0| } 1143| 0| dbuf->dynamic = true; 1144| 0| } else { 1145| 0| dbuf->base = isc_mem_creget(dbuf->mctx, dbuf->base, ------------------ | | 135| 0| isc__mem_reget((c), (p), ISC_CHECKED_MUL((o), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 136| 0| ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 137| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1146| 0| dbuf->length, len, sizeof(char)); 1147| 0| } 1148| 0| dbuf->length = (unsigned int)len; 1149| | 1150| 0| return ISC_R_SUCCESS; 1151| 0|} message.c:isc_buffer_init: 524| 3.22k| const unsigned int length) { 525| 3.22k| REQUIRE(b != NULL); ------------------ | | 194| 3.22k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.22k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.22k, False: 0] | | | | ------------------ | | | | 43| 3.22k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 3.22k| *b = (isc_buffer_t){ 528| 3.22k| .base = base, 529| 3.22k| .length = length, 530| 3.22k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 3.22k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 3.22k| { \ | | | | 27| 3.22k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.22k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 3.22k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.22k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 3.22k| } | | ------------------ ------------------ 531| 3.22k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 3.22k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 3.22k| }; 533| 3.22k|} message.c:isc_buffer_putmem: 965| 208| const unsigned int length) { 966| 208| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 208, False: 0] | | | | | Branch (42:11): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 967| | 968| 208| if (b->mctx) { ------------------ | Branch (968:6): [True: 208, False: 0] ------------------ 969| 208| isc_result_t result = isc_buffer_reserve(b, length); 970| 208| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 971| 208| } 972| | 973| 208| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 194| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 208, False: 0] | | | | ------------------ | | | | 43| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 974| | 975| 208| if (length > 0U) { ------------------ | Branch (975:6): [True: 208, False: 0] ------------------ 976| 208| memmove(isc_buffer_used(b), base, length); ------------------ | | 149| 208| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 977| 208| b->used += length; 978| 208| } 979| 208|} message.c:isc_buffer_getuint32: 916| 1.58k|isc_buffer_getuint32(isc_buffer_t *restrict b) { 917| 1.58k| uint32_t val = 0; 918| 1.58k| isc_result_t result = isc_buffer_peekuint32(b, &val); 919| 1.58k| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 1.58k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.58k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.58k, False: 0] | | | | ------------------ | | | | 49| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 920| 1.58k| b->current += sizeof(val); 921| 1.58k| return val; 922| 1.58k|} message.c:isc_buffer_peekuint32: 906| 1.58k|isc_buffer_peekuint32(const isc_buffer_t *restrict b, uint32_t *valp) { 907| 1.58k| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 1.58k| { \ | | 832| 1.58k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 1.58k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 3.16k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 1.58k, False: 0] | | | | | | | Branch (42:11): [True: 1.58k, False: 0] | | | | | | ------------------ | | | | | | 43| 1.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 1.58k| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 1.58k] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 1.58k| } ------------------ 908| | 909| 1.58k| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 1.58k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 910| | 911| | SET_IF_NOT_NULL(valp, ISC_U8TO32_BE(cp)); ------------------ | | 100| 1.58k| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 1.58k, False: 0] | | ------------------ | | 101| 1.58k| *(obj) = (val); \ | | 102| 1.58k| } ------------------ 912| 1.58k| return ISC_R_SUCCESS; 913| 1.58k|} message.c:isc_buffer_setactive: 771| 4.75k|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 4.75k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 4.75k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.50k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.75k, False: 0] | | | | | Branch (42:11): [True: 4.75k, False: 0] | | | | ------------------ | | | | 43| 4.75k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 4.75k| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 4.75k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.75k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.75k, False: 0] | | | | ------------------ | | | | 43| 4.75k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 4.75k| b->active = b->current + n; 776| 4.75k|} name.c:isc_buffer_clear: 694| 716|isc_buffer_clear(isc_buffer_t *restrict b) { 695| 716| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 716|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.43k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 716, False: 0] | | | | | Branch (42:11): [True: 716, False: 0] | | | | ------------------ | | | | 43| 716| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| | 697| 716| b->used = 0; 698| 716| b->current = 0; 699| 716| b->active = 0; 700| 716|} name.c:isc_buffer_availableregion: 634| 4|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 635| 4| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 636| 4| REQUIRE(r != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 637| | 638| 4| r->base = isc_buffer_used(b); ------------------ | | 149| 4| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 639| 4| r->length = isc_buffer_availablelength(b); ------------------ | | 161| 4|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 640| 4|} name.c:isc_buffer_add: 652| 5.76k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 5.76k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 5.76k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 11.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.76k, False: 0] | | | | | Branch (42:11): [True: 5.76k, False: 0] | | | | ------------------ | | | | 43| 5.76k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 5.76k| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 5.76k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.76k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.76k, False: 0] | | | | ------------------ | | | | 43| 5.76k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 5.76k| b->used += n; 657| 5.76k|} name.c:isc_buffer_reserve: 1110| 70|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1111| 70| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 194| 70|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 140| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 70, False: 0] | | | | | Branch (42:11): [True: 70, False: 0] | | | | ------------------ | | | | 43| 70| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1112| | 1113| 70| size_t len; 1114| | 1115| 70| len = dbuf->length; 1116| 70| if ((len - dbuf->used) >= size) { ------------------ | Branch (1116:6): [True: 70, False: 0] ------------------ 1117| 70| return ISC_R_SUCCESS; 1118| 70| } 1119| | 1120| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1120:6): [True: 0, False: 0] ------------------ 1121| 0| return ISC_R_NOSPACE; 1122| 0| } 1123| | 1124| | /* Round to nearest buffer size increment */ 1125| 0| len = size + dbuf->used; 1126| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 292| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1127| | 1128| | /* Cap at UINT_MAX */ 1129| 0| if (len > UINT_MAX) { ------------------ | Branch (1129:6): [True: 0, False: 0] ------------------ 1130| 0| len = UINT_MAX; 1131| 0| } 1132| | 1133| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1133:6): [True: 0, False: 0] ------------------ 1134| 0| return ISC_R_NOMEMORY; 1135| 0| } 1136| | 1137| 0| if (!dbuf->dynamic) { ------------------ | Branch (1137:6): [True: 0, False: 0] ------------------ 1138| 0| void *old_base = dbuf->base; 1139| 0| dbuf->base = isc_mem_get(dbuf->mctx, len); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1140| 0| if (old_base != NULL) { ------------------ | Branch (1140:7): [True: 0, False: 0] ------------------ 1141| 0| memmove(dbuf->base, old_base, dbuf->used); 1142| 0| } 1143| 0| dbuf->dynamic = true; 1144| 0| } else { 1145| 0| dbuf->base = isc_mem_creget(dbuf->mctx, dbuf->base, ------------------ | | 135| 0| isc__mem_reget((c), (p), ISC_CHECKED_MUL((o), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 136| 0| ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 137| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1146| 0| dbuf->length, len, sizeof(char)); 1147| 0| } 1148| 0| dbuf->length = (unsigned int)len; 1149| | 1150| 0| return ISC_R_SUCCESS; 1151| 0|} name.c:isc_buffer_putuint8: 869| 70|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 70| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 70| { \ | | 858| 70| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 70|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 140| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 70, False: 0] | | | | | | | Branch (42:11): [True: 70, False: 0] | | | | | | ------------------ | | | | | | 43| 70| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 70| \ | | 860| 70| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 70] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 70| \ | | 865| 70| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 70|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 70| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 70, False: 0] | | | | | | ------------------ | | | | | | 43| 70| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 70| } ------------------ 871| | 872| 70| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 70| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 70| b->used += sizeof(val); 874| 70| cp[0] = val; 875| 70|} name.c:isc_buffer_forward: 806| 5.21k|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 5.21k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 5.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.21k, False: 0] | | | | | Branch (42:11): [True: 5.21k, False: 0] | | | | ------------------ | | | | 43| 5.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 5.21k| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 5.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.21k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.21k, False: 0] | | | | ------------------ | | | | 43| 5.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 5.21k| b->current += n; 811| 5.21k|} name.c:isc_buffer_init: 524| 4| const unsigned int length) { 525| 4| REQUIRE(b != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 4| *b = (isc_buffer_t){ 528| 4| .base = base, 529| 4| .length = length, 530| 4| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4| { \ | | | | 27| 4| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4| } | | ------------------ ------------------ 531| 4| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 4|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 4| }; 533| 4|} rcode.c:isc_buffer_availableregion: 634| 10|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 635| 10| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 636| 10| REQUIRE(r != NULL); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 637| | 638| 10| r->base = isc_buffer_used(b); ------------------ | | 149| 10| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 639| 10| r->length = isc_buffer_availablelength(b); ------------------ | | 161| 10|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 640| 10|} rcode.c:isc_buffer_add: 652| 10|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 10| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 10| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 10| b->used += n; 657| 10|} rdata.c:isc_buffer_activeregion: 748| 2.83k|isc_buffer_activeregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 749| 2.83k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2.83k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.66k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.83k, False: 0] | | | | | Branch (42:11): [True: 2.83k, False: 0] | | | | ------------------ | | | | 43| 2.83k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 750| 2.83k| REQUIRE(r != NULL); ------------------ | | 194| 2.83k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.83k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.83k, False: 0] | | | | ------------------ | | | | 43| 2.83k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 751| | 752| 2.83k| if (b->current < b->active) { ------------------ | Branch (752:6): [True: 2.81k, False: 15] ------------------ 753| 2.81k| r->base = isc_buffer_current(b); ------------------ | | 145| 2.81k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 754| 2.81k| r->length = isc_buffer_activelength(b); ------------------ | | 160| 2.81k|#define isc_buffer_activelength(b) ((b)->active - (b)->current) /* c-b */ ------------------ 755| 2.81k| } else { 756| | r->base = NULL; 757| 15| r->length = 0; 758| 15| } 759| 2.83k|} rdata.c:isc_buffer_forward: 806| 5.15k|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 5.15k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 5.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.3k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.15k, False: 0] | | | | | Branch (42:11): [True: 5.15k, False: 0] | | | | ------------------ | | | | 43| 5.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 5.15k| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 5.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.15k, False: 0] | | | | ------------------ | | | | 43| 5.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 5.15k| b->current += n; 811| 5.15k|} rdata.c:isc_buffer_availableregion: 634| 5.26k|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 635| 5.26k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 5.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.26k, False: 0] | | | | | Branch (42:11): [True: 5.26k, False: 0] | | | | ------------------ | | | | 43| 5.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 636| 5.26k| REQUIRE(r != NULL); ------------------ | | 194| 5.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.26k, False: 0] | | | | ------------------ | | | | 43| 5.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 637| | 638| 5.26k| r->base = isc_buffer_used(b); ------------------ | | 149| 5.26k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 639| 5.26k| r->length = isc_buffer_availablelength(b); ------------------ | | 161| 5.26k|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 640| 5.26k|} rdata.c:isc_buffer_add: 652| 4.89k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 4.89k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 4.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.79k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.89k, False: 0] | | | | | Branch (42:11): [True: 4.89k, False: 0] | | | | ------------------ | | | | 43| 4.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 4.89k| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 4.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.89k, False: 0] | | | | ------------------ | | | | 43| 4.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 4.89k| b->used += n; 657| 4.89k|} rdata.c:isc_buffer_setactive: 771| 6|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 6| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 6| b->active = b->current + n; 776| 6|} rdata.c:isc_buffer_putuint16: 897| 2|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 898| 2| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 2| { \ | | 858| 2| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 2, False: 0] | | | | | | | Branch (42:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 2| \ | | 860| 2| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 2] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 2| \ | | 865| 2| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 2| } ------------------ 899| | 900| 2| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 901| 2| b->used += sizeof(val); 902| 2| ISC_U16TO8_BE(cp, val); ------------------ | | 221| 2| (p)[0] = (uint8_t)((v) >> 8); \ | | 222| 2| (p)[1] = (uint8_t)((v)); ------------------ 903| 2|} rdata.c:isc_buffer_putuint32: 925| 10|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 926| 10| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 10| { \ | | 858| 10| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 20| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 10, False: 0] | | | | | | | Branch (42:11): [True: 10, False: 0] | | | | | | ------------------ | | | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 10| \ | | 860| 10| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 10] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 10| \ | | 865| 10| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 10| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 10, False: 0] | | | | | | ------------------ | | | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 10| } ------------------ 927| | 928| 10| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 10| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 929| 10| b->used += sizeof(val); 930| | 931| 10| ISC_U32TO8_BE(cp, val); ------------------ | | 227| 10| (p)[0] = (uint8_t)((v) >> 24); \ | | 228| 10| (p)[1] = (uint8_t)((v) >> 16); \ | | 229| 10| (p)[2] = (uint8_t)((v) >> 8); \ | | 230| 10| (p)[3] = (uint8_t)((v)); ------------------ 932| 10|} rdata.c:isc_buffer_init: 524| 6| const unsigned int length) { 525| 6| REQUIRE(b != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 6| *b = (isc_buffer_t){ 528| 6| .base = base, 529| 6| .length = length, 530| 6| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 6|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 6| { \ | | | | 27| 6| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 6| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 6|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 6| } | | ------------------ ------------------ 531| 6| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 6|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 6| }; 533| 6|} tsig.c:isc_buffer_init: 524| 51| const unsigned int length) { 525| 51| REQUIRE(b != NULL); ------------------ | | 194| 51|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 51| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 51, False: 0] | | | | ------------------ | | | | 43| 51| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 51| *b = (isc_buffer_t){ 528| 51| .base = base, 529| 51| .length = length, 530| 51| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 51|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 51| { \ | | | | 27| 51| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 51|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 51| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 51|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 51| } | | ------------------ ------------------ 531| 51| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 51|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 51| }; 533| 51|} tsig.c:isc_buffer_add: 652| 2|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 2| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 2| b->used += n; 657| 2|} tsig.c:isc_buffer_putuint48: 954| 46|isc_buffer_putuint48(isc_buffer_t *restrict b, const uint64_t val) { 955| 46| ISC_BUFFER_PUT_RESERVE(b, val, 6); /* 48-bits */ ------------------ | | 857| 46| { \ | | 858| 46| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 92| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 46, False: 0] | | | | | | | Branch (42:11): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 46| \ | | 860| 46| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 46] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 46| \ | | 865| 46| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 46| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 46| } ------------------ 956| | 957| 46| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 46| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 958| 46| b->used += 6; 959| | 960| 46| ISC_U48TO8_BE(cp, val); ------------------ | | 237| 46| (p)[0] = (uint8_t)((v) >> 40); \ | | 238| 46| (p)[1] = (uint8_t)((v) >> 32); \ | | 239| 46| (p)[2] = (uint8_t)((v) >> 24); \ | | 240| 46| (p)[3] = (uint8_t)((v) >> 16); \ | | 241| 46| (p)[4] = (uint8_t)((v) >> 8); \ | | 242| 46| (p)[5] = (uint8_t)((v)); ------------------ 961| 46|} tsig.c:isc_buffer_putuint16: 897| 187|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 898| 187| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 187| { \ | | 858| 187| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 187|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 374| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 187, False: 0] | | | | | | | Branch (42:11): [True: 187, False: 0] | | | | | | ------------------ | | | | | | 43| 187| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 187| \ | | 860| 187| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 187] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 187| \ | | 865| 187| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 187|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 187| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 187, False: 0] | | | | | | ------------------ | | | | | | 43| 187| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 187| } ------------------ 899| | 900| 187| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 187| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 901| 187| b->used += sizeof(val); 902| 187| ISC_U16TO8_BE(cp, val); ------------------ | | 221| 187| (p)[0] = (uint8_t)((v) >> 8); \ | | 222| 187| (p)[1] = (uint8_t)((v)); ------------------ 903| 187|} tsig.c:isc_buffer_usedregion: 616| 187| isc_region_t *restrict r) { 617| 187| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 187|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 374| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 187, False: 0] | | | | | Branch (42:11): [True: 187, False: 0] | | | | ------------------ | | | | 43| 187| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 187| REQUIRE(r != NULL); ------------------ | | 194| 187|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 187| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 187, False: 0] | | | | ------------------ | | | | 43| 187| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 187| r->base = b->base; 621| 187| r->length = b->used; 622| 187|} tsig.c:isc_buffer_clear: 694| 46|isc_buffer_clear(isc_buffer_t *restrict b) { 695| 46| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 92| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 46, False: 0] | | | | | Branch (42:11): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| | 697| 46| b->used = 0; 698| 46| b->current = 0; 699| 46| b->active = 0; 700| 46|} tsig.c:isc_buffer_putuint32: 925| 46|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 926| 46| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 46| { \ | | 858| 46| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 92| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 46, False: 0] | | | | | | | Branch (42:11): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 46| \ | | 860| 46| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 46] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 46| \ | | 865| 46| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 46| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 46, False: 0] | | | | | | ------------------ | | | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 46| } ------------------ 927| | 928| 46| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 46| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 929| 46| b->used += sizeof(val); 930| | 931| 46| ISC_U32TO8_BE(cp, val); ------------------ | | 227| 46| (p)[0] = (uint8_t)((v) >> 24); \ | | 228| 46| (p)[1] = (uint8_t)((v) >> 16); \ | | 229| 46| (p)[2] = (uint8_t)((v) >> 8); \ | | 230| 46| (p)[3] = (uint8_t)((v)); ------------------ 932| 46|} zone.c:isc_buffer_putstr: 996| 8|isc_buffer_putstr(isc_buffer_t *restrict b, const char *restrict source) { 997| 8| unsigned int length; 998| 8| unsigned char *cp; 999| | 1000| 8| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1001| 8| REQUIRE(source != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1002| | 1003| 8| length = (unsigned int)strlen(source); 1004| 8| if (b->mctx) { ------------------ | Branch (1004:6): [True: 0, False: 8] ------------------ 1005| 0| isc_result_t result = isc_buffer_reserve(b, length); 1006| 0| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 1007| 0| } 1008| | 1009| 8| REQUIRE(isc_buffer_availablelength(b) >= length); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1010| | 1011| 8| cp = isc_buffer_used(b); ------------------ | | 149| 8| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1012| 8| memmove(cp, source, length); 1013| 8| b->used += length; 1014| 8|} zone.c:isc_buffer_init: 524| 4| const unsigned int length) { 525| 4| REQUIRE(b != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 4| *b = (isc_buffer_t){ 528| 4| .base = base, 529| 4| .length = length, 530| 4| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4| { \ | | | | 27| 4| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4| } | | ------------------ ------------------ 531| 4| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 4|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 4| }; 533| 4|} zoneproperties.c:isc_buffer_putmem: 965| 2| const unsigned int length) { 966| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 967| | 968| 2| if (b->mctx) { ------------------ | Branch (968:6): [True: 0, False: 2] ------------------ 969| 0| isc_result_t result = isc_buffer_reserve(b, length); 970| 0| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 194| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 971| 0| } 972| | 973| 2| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 974| | 975| 2| if (length > 0U) { ------------------ | Branch (975:6): [True: 2, False: 0] ------------------ 976| 2| memmove(isc_buffer_used(b), base, length); ------------------ | | 149| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 977| 2| b->used += length; 978| 2| } 979| 2|} zoneproperties.c:isc_buffer_putuint8: 869| 2|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 2| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 2| { \ | | 858| 2| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 2, False: 0] | | | | | | | Branch (42:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 2| \ | | 860| 2| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 2] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 2| \ | | 865| 2| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 2| } ------------------ 871| | 872| 2| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 2| b->used += sizeof(val); 874| 2| cp[0] = val; 875| 2|} zoneproperties.c:isc_buffer_init: 524| 12| const unsigned int length) { 525| 12| REQUIRE(b != NULL); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 12| *b = (isc_buffer_t){ 528| 12| .base = base, 529| 12| .length = length, 530| 12| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 12|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 12| { \ | | | | 27| 12| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 12|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 12| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 12|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 12| } | | ------------------ ------------------ 531| 12| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 12|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 12| }; 533| 12|} zoneproperties.c:isc_buffer_putstr: 996| 6|isc_buffer_putstr(isc_buffer_t *restrict b, const char *restrict source) { 997| 6| unsigned int length; 998| 6| unsigned char *cp; 999| | 1000| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1001| 6| REQUIRE(source != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1002| | 1003| 6| length = (unsigned int)strlen(source); 1004| 6| if (b->mctx) { ------------------ | Branch (1004:6): [True: 0, False: 6] ------------------ 1005| 0| isc_result_t result = isc_buffer_reserve(b, length); 1006| 0| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 1007| 0| } 1008| | 1009| 6| REQUIRE(isc_buffer_availablelength(b) >= length); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1010| | 1011| 6| cp = isc_buffer_used(b); ------------------ | | 149| 6| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1012| 6| memmove(cp, source, length); 1013| 6| b->used += length; 1014| 6|} dnssec.c:isc_buffer_init: 524| 96| const unsigned int length) { 525| 96| REQUIRE(b != NULL); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 96| *b = (isc_buffer_t){ 528| 96| .base = base, 529| 96| .length = length, 530| 96| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 96|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 96| { \ | | | | 27| 96| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 96|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 96| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 96|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 96| } | | ------------------ ------------------ 531| 96| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 96|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 96| }; 533| 96|} dnssec.c:isc_buffer_add: 652| 96|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 96| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 96, False: 0] | | | | | Branch (42:11): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 96| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 96| b->used += n; 657| 96|} dnssec.c:isc_buffer_usedregion: 616| 95| isc_region_t *restrict r) { 617| 95| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 95|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 190| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 95, False: 0] | | | | | Branch (42:11): [True: 95, False: 0] | | | | ------------------ | | | | 43| 95| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 95| REQUIRE(r != NULL); ------------------ | | 194| 95|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 95| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 95, False: 0] | | | | ------------------ | | | | 43| 95| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 95| r->base = b->base; 621| 95| r->length = b->used; 622| 95|} dst_api.c:isc_buffer_putuint8: 869| 4|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 4| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 4| { \ | | 858| 4| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 8| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 4, False: 0] | | | | | | | Branch (42:11): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 4| \ | | 860| 4| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 4] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 4| \ | | 865| 4| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 4| } ------------------ 871| | 872| 4| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 4| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 4| b->used += sizeof(val); 874| 4| cp[0] = val; 875| 4|} dst_api.c:isc_buffer_init: 524| 2| const unsigned int length) { 525| 2| REQUIRE(b != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 2| *b = (isc_buffer_t){ 528| 2| .base = base, 529| 2| .length = length, 530| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 531| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 2| }; 533| 2|} dst_api.c:isc_buffer_putuint16: 897| 2|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 898| 2| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 2| { \ | | 858| 2| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 2, False: 0] | | | | | | | Branch (42:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 2| \ | | 860| 2| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 2] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 0| } \ | | 864| 2| \ | | 865| 2| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 2| } ------------------ 899| | 900| 2| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 901| 2| b->used += sizeof(val); 902| 2| ISC_U16TO8_BE(cp, val); ------------------ | | 221| 2| (p)[0] = (uint8_t)((v) >> 8); \ | | 222| 2| (p)[1] = (uint8_t)((v)); ------------------ 903| 2|} dst_api.c:isc_buffer_remainingregion: 730| 96|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 731| 96| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 96, False: 0] | | | | | Branch (42:11): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 96| REQUIRE(r != NULL); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| | 734| 96| r->base = isc_buffer_current(b); ------------------ | | 145| 96| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 735| 96| r->length = isc_buffer_remaininglength(b); ------------------ | | 159| 96|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 736| 96|} dst_api.c:isc_buffer_getuint16: 888| 96|isc_buffer_getuint16(isc_buffer_t *restrict b) { 889| 96| uint16_t val = 0; 890| 96| isc_result_t result = isc_buffer_peekuint16(b, &val); 891| 96| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 96|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 96, False: 0] | | | | ------------------ | | | | 49| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 892| 96| b->current += sizeof(val); 893| 96| return val; 894| 96|} dst_api.c:isc_buffer_peekuint16: 878| 96|isc_buffer_peekuint16(const isc_buffer_t *restrict b, uint16_t *valp) { 879| 96| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 96| { \ | | 832| 96| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 192| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 96, False: 0] | | | | | | | Branch (42:11): [True: 96, False: 0] | | | | | | ------------------ | | | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 96| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 96] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 96| } ------------------ 880| | 881| 96| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 96| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 882| | 883| | SET_IF_NOT_NULL(valp, ISC_U8TO16_BE(cp)); ------------------ | | 100| 96| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 96, False: 0] | | ------------------ | | 101| 96| *(obj) = (val); \ | | 102| 96| } ------------------ 884| 96| return ISC_R_SUCCESS; 885| 96|} dst_api.c:isc_buffer_getuint8: 848| 192|isc_buffer_getuint8(isc_buffer_t *restrict b) { 849| 192| uint8_t val = 0; 850| 192| isc_result_t result = isc_buffer_peekuint8(b, &val); 851| 192| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 192|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 192, False: 0] | | | | ------------------ | | | | 49| 192| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 852| 192| b->current += sizeof(val); 853| 192| return val; 854| 192|} dst_api.c:isc_buffer_peekuint8: 839| 192|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 840| 192| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 192| { \ | | 832| 192| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 192|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 384| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 192, False: 0] | | | | | | | Branch (42:11): [True: 192, False: 0] | | | | | | ------------------ | | | | | | 43| 192| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 192| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 192] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 192| } ------------------ 841| | 842| 192| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 192| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 843| | SET_IF_NOT_NULL(valp, (uint8_t)(cp[0])); ------------------ | | 100| 192| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 192, False: 0] | | ------------------ | | 101| 192| *(obj) = (val); \ | | 102| 192| } ------------------ 844| 192| return ISC_R_SUCCESS; 845| 192|} dst_api.c:isc_buffer_usedregion: 616| 2| isc_region_t *restrict r) { 617| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 2| REQUIRE(r != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 2| r->base = b->base; 621| 2| r->length = b->used; 622| 2|} hmac_link.c:isc_buffer_init: 524| 46| const unsigned int length) { 525| 46| REQUIRE(b != NULL); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 46| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 46| *b = (isc_buffer_t){ 528| 46| .base = base, 529| 46| .length = length, 530| 46| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 46|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 46| { \ | | | | 27| 46| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 46|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 46| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 46|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 46| } | | ------------------ ------------------ 531| 46| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 46|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 46| }; 533| 46|} hmac_link.c:isc_buffer_remainingregion: 730| 2|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 731| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 2| REQUIRE(r != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| | 734| 2| r->base = isc_buffer_current(b); ------------------ | | 145| 2| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 735| 2| r->length = isc_buffer_remaininglength(b); ------------------ | | 159| 2|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 736| 2|} hmac_link.c:isc_buffer_forward: 806| 2|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 2| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 2| b->current += n; 811| 2|} hmac_link.c:isc_buffer_copyregion: 1192| 2| const isc_region_t *restrict r) { 1193| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1194| 2| REQUIRE(r != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1195| | 1196| 2| if (b->mctx) { ------------------ | Branch (1196:6): [True: 0, False: 2] ------------------ 1197| 0| RETERR(isc_buffer_reserve(b, r->length)); ------------------ | | 272| 0| { \ | | 273| 0| isc_result_t _r = (x); \ | | 274| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 0] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 0| } ------------------ 1198| 0| } 1199| | 1200| 2| if (r->length > isc_buffer_availablelength(b)) { ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1200:6): [True: 0, False: 2] ------------------ 1201| 0| return ISC_R_NOSPACE; 1202| 0| } 1203| | 1204| 2| if (r->length > 0U) { ------------------ | Branch (1204:6): [True: 2, False: 0] ------------------ 1205| 2| memmove(isc_buffer_used(b), r->base, r->length); ------------------ | | 149| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1206| 2| b->used += r->length; 1207| 2| } 1208| | 1209| 2| return ISC_R_SUCCESS; 1210| 2|} master.c:isc_buffer_init: 524| 10| const unsigned int length) { 525| 10| REQUIRE(b != NULL); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 10| *b = (isc_buffer_t){ 528| 10| .base = base, 529| 10| .length = length, 530| 10| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 10|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 10| { \ | | | | 27| 10| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 10|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 10| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 10|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 10| } | | ------------------ ------------------ 531| 10| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 10|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 10| }; 533| 10|} master.c:isc_buffer_add: 652| 6|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 6| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 6| b->used += n; 657| 6|} master.c:isc_buffer_setactive: 771| 6|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 6| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 6| b->active = b->current + n; 776| 6|} opensslrsa_link.c:isc_buffer_remainingregion: 730| 96|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 731| 96| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 96, False: 0] | | | | | Branch (42:11): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 96| REQUIRE(r != NULL); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| | 734| 96| r->base = isc_buffer_current(b); ------------------ | | 145| 96| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 735| 96| r->length = isc_buffer_remaininglength(b); ------------------ | | 159| 96|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 736| 96|} opensslrsa_link.c:isc_buffer_forward: 806| 96|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 96| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 96, False: 0] | | | | | Branch (42:11): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 96| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 96, False: 0] | | | | ------------------ | | | | 43| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 96| b->current += n; 811| 96|} ossl3.c:isc_buffer_add: 652| 46|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 46| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 92| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 46, False: 0] | | | | | Branch (42:11): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 46| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 46|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 46| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 46, False: 0] | | | | ------------------ | | | | 43| 46| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 46| b->used += n; 657| 46|} base64.c:isc_buffer_availableregion: 634| 174|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 635| 174| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 348| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 174, False: 0] | | | | | Branch (42:11): [True: 174, False: 0] | | | | ------------------ | | | | 43| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 636| 174| REQUIRE(r != NULL); ------------------ | | 194| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 174| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 174, False: 0] | | | | ------------------ | | | | 43| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 637| | 638| 174| r->base = isc_buffer_used(b); ------------------ | | 149| 174| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 639| 174| r->length = isc_buffer_availablelength(b); ------------------ | | 161| 174|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 640| 174|} base64.c:isc_buffer_add: 652| 174|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 174| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 348| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 174, False: 0] | | | | | Branch (42:11): [True: 174, False: 0] | | | | ------------------ | | | | 43| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 174| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 174| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 174, False: 0] | | | | ------------------ | | | | 43| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 174| b->used += n; 657| 174|} lex.c:isc_buffer_allocate: 1077| 2| const unsigned int length) { 1078| 2| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1079| | 1080| 2| isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1081| 2| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1082| | 1083| 2| isc_buffer_init(dbuf, bdata, length); 1084| 2| dbuf->extra = length; 1085| 2| isc_buffer_setmctx(dbuf, mctx); 1086| | 1087| 2| *dbufp = dbuf; 1088| 2|} lex.c:isc_buffer_init: 524| 2| const unsigned int length) { 525| 2| REQUIRE(b != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 2| *b = (isc_buffer_t){ 528| 2| .base = base, 529| 2| .length = length, 530| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 531| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 2| }; 533| 2|} lex.c:isc_buffer_setmctx: 1091| 2|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1092| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1093| | 1094| 2| b->mctx = mctx; 1095| 2|} lex.c:isc_buffer_free: 1154| 2|isc_buffer_free(isc_buffer_t **restrict dbufp) { 1155| 2| REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1156| 2| REQUIRE((*dbufp)->mctx != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1157| | 1158| 2| isc_buffer_t *dbuf = *dbufp; 1159| 2| isc_mem_t *mctx = dbuf->mctx; 1160| 2| unsigned int extra = dbuf->extra; 1161| | 1162| 2| *dbufp = NULL; /* destroy external reference */ 1163| | 1164| 2| isc_buffer_clearmctx(dbuf); 1165| | 1166| 2| isc_buffer_invalidate(dbuf); 1167| | isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 1168| 2|} lex.c:isc_buffer_clearmctx: 1098| 2|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1099| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1100| | 1101| 2| if (b->dynamic) { ------------------ | Branch (1101:6): [True: 0, False: 2] ------------------ 1102| 0| isc_mem_put(b->mctx, b->base, b->length); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 1103| 0| b->dynamic = false; 1104| 0| } 1105| | 1106| | b->mctx = NULL; 1107| 2|} lex.c:isc_buffer_invalidate: 577| 2|isc_buffer_invalidate(isc_buffer_t *restrict b) { 578| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 579| 2| REQUIRE(!ISC_LINK_LINKED(b, link)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 580| 2| REQUIRE(b->mctx == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 581| | 582| 2| *b = (isc_buffer_t){ 583| 2| .magic = 0, 584| 2| }; 585| 2|} lex.c:isc_buffer_compact: 1048| 74|isc_buffer_compact(isc_buffer_t *restrict b) { 1049| 74| unsigned int length; 1050| 74| void *src; 1051| | 1052| | /* 1053| | * Compact the used region by moving the remaining region so it occurs 1054| | * at the start of the buffer. The used region is shrunk by the size 1055| | * of the consumed region, and the consumed region is then made empty. 1056| | */ 1057| | 1058| 74| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 74|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 148| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 74, False: 0] | | | | | Branch (42:11): [True: 74, False: 0] | | | | ------------------ | | | | 43| 74| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1059| | 1060| 74| src = isc_buffer_current(b); ------------------ | | 145| 74| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1061| 74| length = isc_buffer_remaininglength(b); ------------------ | | 159| 74|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 1062| 74| if (length > 0U) { ------------------ | Branch (1062:6): [True: 66, False: 8] ------------------ 1063| 66| (void)memmove(b->base, src, (size_t)length); 1064| 66| } 1065| | 1066| 74| if (b->active > b->current) { ------------------ | Branch (1066:6): [True: 0, False: 74] ------------------ 1067| 0| b->active -= b->current; 1068| 74| } else { 1069| 74| b->active = 0; 1070| 74| } 1071| 74| b->current = 0; 1072| 74| b->used = length; 1073| 74|} lex.c:isc_buffer_reserve: 1110| 864|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1111| 864| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 194| 864|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.72k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 864, False: 0] | | | | | Branch (42:11): [True: 864, False: 0] | | | | ------------------ | | | | 43| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1112| | 1113| 864| size_t len; 1114| | 1115| 864| len = dbuf->length; 1116| 864| if ((len - dbuf->used) >= size) { ------------------ | Branch (1116:6): [True: 864, False: 0] ------------------ 1117| 864| return ISC_R_SUCCESS; 1118| 864| } 1119| | 1120| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1120:6): [True: 0, False: 0] ------------------ 1121| 0| return ISC_R_NOSPACE; 1122| 0| } 1123| | 1124| | /* Round to nearest buffer size increment */ 1125| 0| len = size + dbuf->used; 1126| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 292| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1127| | 1128| | /* Cap at UINT_MAX */ 1129| 0| if (len > UINT_MAX) { ------------------ | Branch (1129:6): [True: 0, False: 0] ------------------ 1130| 0| len = UINT_MAX; 1131| 0| } 1132| | 1133| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1133:6): [True: 0, False: 0] ------------------ 1134| 0| return ISC_R_NOMEMORY; 1135| 0| } 1136| | 1137| 0| if (!dbuf->dynamic) { ------------------ | Branch (1137:6): [True: 0, False: 0] ------------------ 1138| 0| void *old_base = dbuf->base; 1139| 0| dbuf->base = isc_mem_get(dbuf->mctx, len); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1140| 0| if (old_base != NULL) { ------------------ | Branch (1140:7): [True: 0, False: 0] ------------------ 1141| 0| memmove(dbuf->base, old_base, dbuf->used); 1142| 0| } 1143| 0| dbuf->dynamic = true; 1144| 0| } else { 1145| 0| dbuf->base = isc_mem_creget(dbuf->mctx, dbuf->base, ------------------ | | 135| 0| isc__mem_reget((c), (p), ISC_CHECKED_MUL((o), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 136| 0| ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 137| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1146| 0| dbuf->length, len, sizeof(char)); 1147| 0| } 1148| 0| dbuf->length = (unsigned int)len; 1149| | 1150| 0| return ISC_R_SUCCESS; 1151| 0|} lex.c:isc_buffer_putuint8: 869| 864|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 864| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 864| { \ | | 858| 864| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 864|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 1.72k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 864, False: 0] | | | | | | | Branch (42:11): [True: 864, False: 0] | | | | | | ------------------ | | | | | | 43| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 864| \ | | 860| 864| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 864, False: 0] | | ------------------ | | 861| 864| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 864| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 864|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 864| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 864, False: 0] | | | | | | ------------------ | | | | | | 49| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 864| } \ | | 864| 864| \ | | 865| 864| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 864|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 864| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 864, False: 0] | | | | | | ------------------ | | | | | | 43| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 864| } ------------------ 871| | 872| 864| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 864| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 864| b->used += sizeof(val); 874| 864| cp[0] = val; 875| 864|} lex.c:isc_buffer_getuint8: 848| 946|isc_buffer_getuint8(isc_buffer_t *restrict b) { 849| 946| uint8_t val = 0; 850| 946| isc_result_t result = isc_buffer_peekuint8(b, &val); 851| 946| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 946|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 946| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 946, False: 0] | | | | ------------------ | | | | 49| 946| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 852| 946| b->current += sizeof(val); 853| 946| return val; 854| 946|} lex.c:isc_buffer_peekuint8: 839| 946|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 840| 946| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 946| { \ | | 832| 946| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 946|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 1.89k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 946, False: 0] | | | | | | | Branch (42:11): [True: 946, False: 0] | | | | | | ------------------ | | | | | | 43| 946| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 946| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 946] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 946| } ------------------ 841| | 842| 946| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 946| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 843| | SET_IF_NOT_NULL(valp, (uint8_t)(cp[0])); ------------------ | | 100| 946| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 946, False: 0] | | ------------------ | | 101| 946| *(obj) = (val); \ | | 102| 946| } ------------------ 844| 946| return ISC_R_SUCCESS; 845| 946|} lex.c:isc_buffer_first: 790| 6|isc_buffer_first(isc_buffer_t *restrict b) { 791| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 792| | 793| 6| b->current = 0; 794| 6|} name.c:isc_hash32: 53| 623|isc_hash32(const void *data, const size_t length, const bool case_sensitive) { 54| 623| isc_hash32_t state; 55| 623| isc_hash32_init(&state); 56| 623| isc_hash32_hash(&state, data, length, case_sensitive); 57| 623| return isc_hash32_finalize(&state); 58| 623|} hashmap.c:isc_hash_bits32: 114| 623|isc_hash_bits32(uint32_t val, unsigned int bits) { 115| 623| ISC_REQUIRE(bits <= ISC_HASH_MAX_BITS); ------------------ | | 42| 623| ((void)((cond) || \ | | ------------------ | | | Branch (42:10): [True: 623, False: 0] | | ------------------ | | 43| 623| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | ------------------ | | | Branch (43:3): [True: 0, False: 0] | | ------------------ | | 44| 0| isc_assertiontype_require, #cond), \ | | 45| 0| 0))) ------------------ 116| | /* High bits are more random. */ 117| 623| return val * ISC_HASH_GOLDENRATIO_32 >> (32 - bits); ------------------ | | 111| 623|#define ISC_HASH_GOLDENRATIO_32 0x61C88647 ------------------ 118| 623|} isc_lib_initialize: 57| 2|isc_lib_initialize(void) { 58| 2| isc__lib_initialize(); 59| 2|} dns_tsigkeyring_attach: 222| 1.13k| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 1.13k| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 194| 1.13k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.13k, False: 0] | | | | | Branch (42:11): [True: 1.13k, False: 0] | | | | ------------------ | | | | 43| 1.13k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 1.13k| name##_ref(ptr); \ 225| 1.13k| *ptrp = ptr; \ 226| 1.13k| } \ dns_tsigkey_attach: 222| 289| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 289| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 194| 289|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 578| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 289, False: 0] | | | | | Branch (42:11): [True: 289, False: 0] | | | | ------------------ | | | | 43| 289| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 289| name##_ref(ptr); \ 225| 289| *ptrp = ptr; \ 226| 289| } \ dns_zone_attach: 222| 209| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 209| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 194| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 209, False: 0] | | | | | Branch (42:11): [True: 209, False: 0] | | | | ------------------ | | | | 43| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 209| name##_ref(ptr); \ 225| 209| *ptrp = ptr; \ 226| 209| } \ dns_db_attach: 222| 213| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 213| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 194| 213|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 426| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 213, False: 0] | | | | | Branch (42:11): [True: 213, False: 0] | | | | ------------------ | | | | 43| 213| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 213| name##_ref(ptr); \ 225| 213| *ptrp = ptr; \ 226| 213| } \ isc_loop_attach: 222| 4| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 4| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 4| name##_ref(ptr); \ 225| 4| *ptrp = ptr; \ 226| 4| } \ isc_mem_attach: 222| 5.35k| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 5.35k| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 194| 5.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.35k, False: 0] | | | | | Branch (42:11): [True: 5.35k, False: 0] | | | | ------------------ | | | | 43| 5.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 5.35k| name##_ref(ptr); \ 225| 5.35k| *ptrp = ptr; \ 226| 5.35k| } \ hash.c:isc_halfsiphash13_init: 633| 623|isc_halfsiphash13_init(isc_halfsiphash24_t *restrict state, const uint8_t *k) { 634| 623| REQUIRE(k != NULL); ------------------ | | 194| 623|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 623| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 623, False: 0] | | | | ------------------ | | | | 43| 623| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 635| | 636| 623| uint32_t k0 = ISC_U8TO32_LE(k); ------------------ | | 186| 623| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 187| 623| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 637| 623| uint32_t k1 = ISC_U8TO32_LE(k + 4); ------------------ | | 186| 623| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 187| 623| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 638| | 639| 623| *state = (isc_halfsiphash24_t){ 640| 623| .k0 = k0, 641| 623| .k1 = k1, 642| 623| .v0 = UINT32_C(0x00000000) ^ k0, 643| 623| .v1 = UINT32_C(0x00000000) ^ k1, 644| 623| .v2 = UINT32_C(0x6c796765) ^ k0, 645| | .v3 = UINT32_C(0x74656462) ^ k1, 646| 623| }; 647| 623|} hash.c:isc_halfsiphash13_hash: 662| 623| const size_t inlen, const bool case_sensitive) { 663| 623| REQUIRE(inlen == 0 || in != NULL); ------------------ | | 194| 623|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 623] | | | | | Branch (42:11): [True: 623, False: 0] | | | | ------------------ | | | | 43| 623| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 664| | 665| 623| if (in == NULL || inlen == 0) { ------------------ | Branch (665:6): [True: 0, False: 623] | Branch (665:20): [True: 0, False: 623] ------------------ 666| 0| return; 667| 0| } 668| | 669| 623| size_t len = inlen; 670| 623| const int right = state->inlen & 3; 671| | 672| 623| switch (right) { 673| 623| case 0: ------------------ | Branch (673:2): [True: 623, False: 0] ------------------ 674| 623| break; 675| 0| case 1: ------------------ | Branch (675:2): [True: 0, False: 623] ------------------ 676| 0| state->b |= U8TO32_ONE(case_sensitive, in[0]) << 8; ------------------ | | 77| 0| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 0] | | ------------------ ------------------ 677| 0| state->inlen++; 678| 0| ++in; 679| | 680| 0| if (--len == 0) { ------------------ | Branch (680:7): [True: 0, False: 0] ------------------ 681| 0| return; 682| 0| } 683| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 684| 0| case 2: ------------------ | Branch (684:2): [True: 0, False: 623] ------------------ 685| 0| state->b |= U8TO32_ONE(case_sensitive, in[0]) << 16; ------------------ | | 77| 0| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 0] | | ------------------ ------------------ 686| 0| state->inlen++; 687| 0| ++in; 688| | 689| 0| if (--len == 0) { ------------------ | Branch (689:7): [True: 0, False: 0] ------------------ 690| 0| return; 691| 0| } 692| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 693| 0| case 3: ------------------ | Branch (693:2): [True: 0, False: 623] ------------------ 694| 0| state->b |= U8TO32_ONE(case_sensitive, in[0]) << 24; ------------------ | | 77| 0| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 0] | | ------------------ ------------------ 695| 0| state->inlen++; 696| 0| ++in; 697| | 698| 0| isc_halfsiphash13_one(state, state->b); 699| 0| state->b = 0; /* consumed */ 700| | 701| 0| if (--len == 0) { ------------------ | Branch (701:7): [True: 0, False: 0] ------------------ 702| 0| return; 703| 0| } 704| 0| break; 705| 0| default: ------------------ | Branch (705:2): [True: 0, False: 623] ------------------ 706| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 707| 623| } 708| | 709| 623| const uint8_t *end = in + len - (len % sizeof(uint32_t)); 710| 623| const int left = len & 3; 711| | 712| 1.86k| for (; in != end; in += 4) { ------------------ | Branch (712:9): [True: 1.24k, False: 623] ------------------ 713| 1.24k| uint32_t m = case_sensitive ------------------ | Branch (713:16): [True: 0, False: 1.24k] ------------------ 714| 1.24k| ? ISC_U8TO32_LE(in) ------------------ | | 186| 0| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 187| 0| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 715| 1.24k| : isc_ascii_tolower4(ISC_U8TO32_LE(in)); ------------------ | | 186| 1.24k| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 187| 1.24k| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 716| | 717| 1.24k| isc_halfsiphash13_one(state, m); 718| 1.24k| } 719| | 720| 623| INSIST(state->b == 0); ------------------ | | 198| 623|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 623| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 623, False: 0] | | | | ------------------ | | | | 55| 623| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 721| 623| switch (left) { 722| 0| case 3: ------------------ | Branch (722:2): [True: 0, False: 623] ------------------ 723| 0| state->b |= U8TO32_ONE(case_sensitive, in[2]) << 16; ------------------ | | 77| 0| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 0] | | ------------------ ------------------ 724| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 725| 623| case 2: ------------------ | Branch (725:2): [True: 623, False: 0] ------------------ 726| 623| state->b |= U8TO32_ONE(case_sensitive, in[1]) << 8; ------------------ | | 77| 623| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 623] | | ------------------ ------------------ 727| 623| FALLTHROUGH; ------------------ | | 101| 623|#define FALLTHROUGH [[fallthrough]] ------------------ 728| 623| case 1: ------------------ | Branch (728:2): [True: 0, False: 623] ------------------ 729| 623| state->b |= U8TO32_ONE(case_sensitive, in[0]); ------------------ | | 77| 623| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 623] | | ------------------ ------------------ 730| 623| FALLTHROUGH; ------------------ | | 101| 623|#define FALLTHROUGH [[fallthrough]] ------------------ 731| 623| case 0: ------------------ | Branch (731:2): [True: 0, False: 623] ------------------ 732| 623| break; 733| 0| default: ------------------ | Branch (733:2): [True: 0, False: 623] ------------------ 734| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 735| 623| } 736| | 737| 623| state->inlen += len; 738| 623|} hash.c:isc_halfsiphash13_one: 650| 1.86k|isc_halfsiphash13_one(isc_halfsiphash13_t *restrict state, const uint32_t m) { 651| 1.86k| state->v3 ^= m; 652| | 653| 3.73k| for (size_t i = 0; i < cROUNDS_13; ++i) { ------------------ | | 47| 3.73k|#define cROUNDS_13 1 ------------------ | Branch (653:21): [True: 1.86k, False: 1.86k] ------------------ 654| 1.86k| HALFSIPROUND(state->v0, state->v1, state->v2, state->v3); ------------------ | | 74| 1.86k|#define HALFSIPROUND FULL_ROUND32 | | ------------------ | | | | 71| 1.86k| HALF_ROUND32(v0, v1, v2, v3, 5, 8); \ | | | | ------------------ | | | | | | 64| 1.86k| a += b; \ | | | | | | 65| 1.86k| c += d; \ | | | | | | 66| 1.86k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.86k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.86k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | | | 72| 1.86k| HALF_ROUND32(v2, v1, v0, v3, 13, 7); | | | | ------------------ | | | | | | 64| 1.86k| a += b; \ | | | | | | 65| 1.86k| c += d; \ | | | | | | 66| 1.86k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.86k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.86k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 655| 1.86k| } 656| | 657| 1.86k| state->v0 ^= m; 658| 1.86k|} hash.c:isc_halfsiphash13_finalize: 741| 623|isc_halfsiphash13_finalize(isc_halfsiphash13_t *restrict state, uint8_t *out) { 742| 623| REQUIRE(out != NULL); ------------------ | | 194| 623|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 623| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 623, False: 0] | | | | ------------------ | | | | 43| 623| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 743| | 744| 623| uint32_t b = ((uint32_t)state->inlen) << 24 | state->b; 745| | 746| 623| isc_halfsiphash13_one(state, b); 747| | 748| 623| state->v2 ^= 0xff; 749| | 750| 2.49k| for (size_t i = 0; i < dROUNDS_13; ++i) { ------------------ | | 48| 2.49k|#define dROUNDS_13 3 ------------------ | Branch (750:21): [True: 1.86k, False: 623] ------------------ 751| 1.86k| HALFSIPROUND(state->v0, state->v1, state->v2, state->v3); ------------------ | | 74| 1.86k|#define HALFSIPROUND FULL_ROUND32 | | ------------------ | | | | 71| 1.86k| HALF_ROUND32(v0, v1, v2, v3, 5, 8); \ | | | | ------------------ | | | | | | 64| 1.86k| a += b; \ | | | | | | 65| 1.86k| c += d; \ | | | | | | 66| 1.86k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.86k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.86k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | | | 72| 1.86k| HALF_ROUND32(v2, v1, v0, v3, 13, 7); | | | | ------------------ | | | | | | 64| 1.86k| a += b; \ | | | | | | 65| 1.86k| c += d; \ | | | | | | 66| 1.86k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.86k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.86k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 132| 1.86k| _Generic((x), \ | | | | | | | | 133| 1.86k| uint8_t: isc_rotate_left8, \ | | | | | | | | 134| 1.86k| uint16_t: isc_rotate_left16, \ | | | | | | | | 135| 1.86k| uint32_t: isc_rotate_left32, \ | | | | | | | | 136| 1.86k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 752| 1.86k| } 753| | 754| 623| b = state->v1 ^ state->v3; 755| 623| ISC_U32TO8_LE(out, b); ------------------ | | 180| 623| (p)[0] = (uint8_t)((v)); \ | | 181| 623| (p)[1] = (uint8_t)((v) >> 8); \ | | 182| 623| (p)[2] = (uint8_t)((v) >> 16); \ | | 183| 623| (p)[3] = (uint8_t)((v) >> 24); ------------------ 756| 623|} qp.c:isc_tid: 39| 1.17k|isc_tid(void) { 40| 1.17k| return isc__tid_local; 41| 1.17k|} mem.c:isc_tid: 39| 6.53M|isc_tid(void) { 40| 6.53M| return isc__tid_local; 41| 6.53M|} isc__iterated_hash_initialize: 144| 2|isc__iterated_hash_initialize(void) { 145| 2| if (initialized) { ------------------ | Branch (145:6): [True: 0, False: 2] ------------------ 146| 0| return; 147| 0| } 148| | 149| 2| basectx = EVP_MD_CTX_new(); 150| 2| INSIST(basectx != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 151| 2| mdctx = EVP_MD_CTX_new(); 152| 2| INSIST(mdctx != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 153| | 154| 2| RUNTIME_CHECK(EVP_DigestInit_ex(basectx, isc__crypto_md[ISC_MD_SHA1], ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 155| 2| NULL) == 1); 156| | initialized = true; 157| 2|} mem.c:mallocx: 66| 3.26M|mallocx(size_t size, int flags) { 67| 3.26M| void *ptr = malloc(size); 68| 3.26M| INSIST(ptr != NULL); ------------------ | | 198| 3.26M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 3.26M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 3.26M, False: 0] | | | | ------------------ | | | | 55| 3.26M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 69| | 70| 3.26M| if ((flags & MALLOCX_ZERO) != 0) { ------------------ | | 32| 3.26M|#define MALLOCX_ZERO ((int)0x40) ------------------ | Branch (70:6): [True: 26, False: 3.26M] ------------------ 71| 26| memset(ptr, 0, size); 72| 26| } 73| | 74| 3.26M| return ptr; 75| 3.26M|} mem.c:sdallocx: 78| 3.26M|sdallocx(void *ptr, size_t size ISC_ATTR_UNUSED, int flags ISC_ATTR_UNUSED) { 79| 3.26M| free(ptr); 80| 3.26M|} mem.c:sallocx: 59| 82|sallocx(void *ptr, int flags ISC_ATTR_UNUSED) { 60| 82| return malloc_usable_size(ptr); 61| 82|} isc_lex_create: 84| 2|isc_lex_create(isc_mem_t *mctx, size_t max_token, isc_lex_t **lexp) { 85| 2| isc_lex_t *lex; 86| | 87| | /* 88| | * Create a lexer. 89| | */ 90| 2| REQUIRE(lexp != NULL && *lexp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 91| | 92| 2| if (max_token == 0U) { ------------------ | Branch (92:6): [True: 0, False: 2] ------------------ 93| 0| max_token = 1; 94| 0| } 95| | 96| 2| lex = isc_mem_get(mctx, sizeof(*lex)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 97| 2| lex->data = isc_mem_get(mctx, max_token + 1); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 98| 2| lex->mctx = mctx; 99| 2| lex->max_token = max_token; 100| 2| lex->comments = 0; 101| 2| lex->comment_ok = true; 102| 2| lex->last_was_eol = true; 103| 2| lex->brace_count = 0; 104| 2| lex->paren_count = 0; 105| 2| lex->saved_paren_count = 0; 106| 2| memset(lex->specials, 0, 256); 107| 2| ISC_LIST_INIT(lex->sources); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 108| 2| lex->magic = LEX_MAGIC; ------------------ | | 48| 2|#define LEX_MAGIC ISC_MAGIC('L', 'e', 'x', '!') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 109| | 110| 2| *lexp = lex; 111| 2|} isc_lex_destroy: 114| 2|isc_lex_destroy(isc_lex_t **lexp) { 115| 2| isc_lex_t *lex; 116| | 117| | /* 118| | * Destroy the lexer. 119| | */ 120| | 121| 2| REQUIRE(lexp != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 122| 2| lex = *lexp; 123| 2| *lexp = NULL; 124| 2| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 125| | 126| 4| while (!ISC_LIST_EMPTY(lex->sources)) { ------------------ | | 64| 4|#define ISC_LIST_EMPTY(list) ((list).head == NULL) ------------------ | Branch (126:9): [True: 2, False: 2] ------------------ 127| 2| RUNTIME_CHECK(isc_lex_close(lex) == ISC_R_SUCCESS); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 128| 2| } 129| 2| if (lex->data != NULL) { ------------------ | Branch (129:6): [True: 2, False: 0] ------------------ 130| 2| isc_mem_put(lex->mctx, lex->data, lex->max_token + 1); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 131| 2| } 132| 2| lex->magic = 0; 133| | isc_mem_put(lex->mctx, lex, sizeof(*lex)); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 134| 2|} isc_lex_setcomments: 148| 2|isc_lex_setcomments(isc_lex_t *lex, unsigned int comments) { 149| | /* 150| | * Set allowed lexer commenting styles. 151| | */ 152| | 153| 2| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 154| | 155| 2| lex->comments = comments; 156| 2|} isc_lex_setspecials: 170| 2|isc_lex_setspecials(isc_lex_t *lex, isc_lexspecials_t specials) { 171| | /* 172| | * The characters in 'specials' are returned as tokens. Along with 173| | * whitespace, they delimit strings and numbers. 174| | */ 175| | 176| 2| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 177| | 178| 2| memmove(lex->specials, specials, 256); 179| 2|} isc_lex_openfile: 202| 2|isc_lex_openfile(isc_lex_t *lex, const char *filename) { 203| 2| FILE *stream = NULL; 204| | 205| | /* 206| | * Open 'filename' and make it the current input source for 'lex'. 207| | */ 208| | 209| 2| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 210| | 211| 2| RETERR(isc_stdio_open(filename, "r", &stream)); ------------------ | | 272| 2| { \ | | 273| 2| isc_result_t _r = (x); \ | | 274| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 2] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 2| } ------------------ 212| | 213| 2| new_source(lex, true, true, stream, filename); 214| 2| return ISC_R_SUCCESS; 215| 2|} isc_lex_close: 249| 2|isc_lex_close(isc_lex_t *lex) { 250| 2| inputsource *source; 251| | 252| | /* 253| | * Close the most recently opened object (i.e. file or buffer). 254| | */ 255| | 256| 2| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 257| | 258| 2| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 259| 2| if (source == NULL) { ------------------ | Branch (259:6): [True: 0, False: 2] ------------------ 260| 0| return ISC_R_NOMORE; 261| 0| } 262| | 263| 2| ISC_LIST_UNLINK(lex->sources, source, link); ------------------ | | 137| 2| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 2| do { \ | | | | 133| 2| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 2| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 2| do { \ | | | | | | 110| 2| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 2| } else { \ | | | | | | 113| 2| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 2| (list).tail = (elt)->link.prev; \ | | | | | | 115| 2| } \ | | | | | | 116| 2| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 2| } else { \ | | | | | | 119| 2| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 2| (list).head = (elt)->link.next; \ | | | | | | 121| 2| } \ | | | | | | 122| 2| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 2| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 2| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 2| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 2| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 135| 2| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 2] | | | | ------------------ | | ------------------ ------------------ 264| 2| lex->last_was_eol = source->last_was_eol; 265| 2| if (source->is_file) { ------------------ | Branch (265:6): [True: 2, False: 0] ------------------ 266| 2| if (source->need_close) { ------------------ | Branch (266:7): [True: 2, False: 0] ------------------ 267| 2| (void)fclose((FILE *)(source->input)); 268| 2| } 269| 2| } 270| 2| isc_mem_free(lex->mctx, source->name); ------------------ | | 166| 2| do { \ | | 167| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 168| 2| (p) = NULL; \ | | 169| 2| } while (0) | | ------------------ | | | Branch (169:11): [Folded, False: 2] | | ------------------ ------------------ 271| 2| isc_buffer_free(&source->pushback); 272| 2| isc_mem_put(lex->mctx, source, sizeof(*source)); ------------------ | | 150| 2| do { \ | | 151| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 2| (p) = NULL; \ | | 153| 2| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 2] | | ------------------ ------------------ 273| | 274| 2| return ISC_R_SUCCESS; 275| 2|} isc_lex_gettoken: 330| 74|isc_lex_gettoken(isc_lex_t *lex, unsigned int options, isc_token_t *tokenp) { 331| 74| inputsource *source; 332| 74| int c; 333| 74| bool done = false; 334| 74| bool no_comments = false; 335| 74| bool escaped = false; 336| 74| lexstate state = lexstate_start; 337| 74| lexstate saved_state = lexstate_start; 338| 74| isc_buffer_t *buffer; 339| 74| FILE *stream; 340| 74| char *curr, *prev; 341| 74| size_t remaining; 342| 74| uint32_t as_ulong; 343| 74| unsigned int saved_options; 344| 74| isc_result_t result; 345| | 346| | /* 347| | * Get the next token. 348| | */ 349| | 350| 74| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 74|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 148| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 74, False: 0] | | | | | Branch (42:11): [True: 74, False: 0] | | | | ------------------ | | | | 43| 74| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 351| 74| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 74|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 352| 74| REQUIRE(tokenp != NULL); ------------------ | | 194| 74|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 74| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 74, False: 0] | | | | ------------------ | | | | 43| 74| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 353| | 354| 74| if (source == NULL) { ------------------ | Branch (354:6): [True: 0, False: 74] ------------------ 355| 0| if ((options & ISC_LEXOPT_NOMORE) != 0) { ------------------ | | 78| 0|#define ISC_LEXOPT_NOMORE 0x0040 /*%< Want "no more" token. */ ------------------ | Branch (355:7): [True: 0, False: 0] ------------------ 356| 0| tokenp->type = isc_tokentype_nomore; 357| 0| return ISC_R_SUCCESS; 358| 0| } 359| 0| return ISC_R_NOMORE; 360| 0| } 361| | 362| 74| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (362:6): [True: 0, False: 74] ------------------ 363| 0| return source->result; 364| 0| } 365| | 366| 74| lex->saved_paren_count = lex->paren_count; 367| 74| source->saved_line = source->line; 368| | 369| 74| if (isc_buffer_remaininglength(source->pushback) == 0 && source->at_eof) ------------------ | | 159| 74|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (369:6): [True: 8, False: 66] | Branch (369:59): [True: 0, False: 8] ------------------ 370| 0| { 371| 0| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && ------------------ | | 77| 0|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (371:7): [True: 0, False: 0] ------------------ 372| 0| lex->paren_count != 0) ------------------ | Branch (372:7): [True: 0, False: 0] ------------------ 373| 0| { 374| 0| lex->paren_count = 0; 375| 0| return ISC_R_UNBALANCED; 376| 0| } 377| 0| if ((options & ISC_LEXOPT_BTEXT) != 0 && lex->brace_count != 0) ------------------ | | 84| 0|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (377:7): [True: 0, False: 0] | Branch (377:44): [True: 0, False: 0] ------------------ 378| 0| { 379| 0| lex->brace_count = 0; 380| 0| return ISC_R_UNBALANCED; 381| 0| } 382| 0| if ((options & ISC_LEXOPT_EOF) != 0) { ------------------ | | 63| 0|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ | Branch (382:7): [True: 0, False: 0] ------------------ 383| 0| tokenp->type = isc_tokentype_eof; 384| 0| return ISC_R_SUCCESS; 385| 0| } 386| 0| return ISC_R_EOF; 387| 0| } 388| | 389| 74| isc_buffer_compact(source->pushback); 390| | 391| 74| saved_options = options; 392| 74| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && lex->paren_count > 0) { ------------------ | | 77| 74|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (392:6): [True: 74, False: 0] | Branch (392:50): [True: 0, False: 74] ------------------ 393| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 394| 0| } 395| | 396| 74| curr = lex->data; 397| 74| *curr = '\0'; 398| | 399| 74| prev = NULL; 400| 74| remaining = lex->max_token; 401| | 402| 74|#ifdef HAVE_FLOCKFILE 403| 74| if (source->is_file) { ------------------ | Branch (403:6): [True: 74, False: 0] ------------------ 404| 74| flockfile(source->input); 405| 74| } 406| 74|#endif /* ifdef HAVE_FLOCKFILE */ 407| | 408| 948| do { 409| 948| if (isc_buffer_remaininglength(source->pushback) == 0) { ------------------ | | 159| 948|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (409:7): [True: 866, False: 82] ------------------ 410| 866| if (source->is_file) { ------------------ | Branch (410:8): [True: 866, False: 0] ------------------ 411| 866| stream = source->input; 412| | 413| 866|#if defined(HAVE_FLOCKFILE) && defined(HAVE_GETC_UNLOCKED) 414| 866| c = getc_unlocked(stream); 415| |#else /* if defined(HAVE_FLOCKFILE) && defined(HAVE_GETC_UNLOCKED) */ 416| | c = getc(stream); 417| |#endif /* if defined(HAVE_FLOCKFILE) && defined(HAVE_GETC_UNLOCKED) */ 418| 866| if (c == EOF) { ------------------ | Branch (418:9): [True: 2, False: 864] ------------------ 419| 2| if (ferror(stream)) { ------------------ | Branch (419:10): [True: 0, False: 2] ------------------ 420| 0| source->result = 421| 0| isc__errno2result( ------------------ | | 25| 0|#define isc__errno2result(x) isc___errno2result(x, true, __FILE__, __LINE__) ------------------ 422| 0| errno); 423| 0| result = source->result; 424| 0| goto done; 425| 0| } 426| 2| source->at_eof = true; 427| 2| } 428| 866| } else { 429| 0| buffer = source->input; 430| | 431| 0| if (buffer->current == buffer->used) { ------------------ | Branch (431:9): [True: 0, False: 0] ------------------ 432| 0| c = EOF; 433| 0| source->at_eof = true; 434| 0| } else { 435| 0| c = *((unsigned char *)buffer->base + 436| 0| buffer->current); 437| 0| buffer->current++; 438| 0| } 439| 0| } 440| 866| if (c != EOF) { ------------------ | Branch (440:8): [True: 864, False: 2] ------------------ 441| 864| source->result = pushandgrow(lex, source, c); 442| 864| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (442:9): [True: 0, False: 864] ------------------ 443| 0| result = source->result; 444| 0| goto done; 445| 0| } 446| 864| } 447| 866| } 448| | 449| 948| if (!source->at_eof) { ------------------ | Branch (449:7): [True: 946, False: 2] ------------------ 450| 946| if (state == lexstate_start) { ------------------ | Branch (450:8): [True: 132, False: 814] ------------------ 451| | /* Token has not started yet. */ 452| 132| source->ignored = isc_buffer_consumedlength( ------------------ | | 158| 132|#define isc_buffer_consumedlength(b) ((b)->current) /* b-a */ ------------------ 453| 132| source->pushback); 454| 132| } 455| 946| c = isc_buffer_getuint8(source->pushback); 456| 946| } else { 457| 2| c = EOF; 458| 2| } 459| | 460| 948| if (c == '\n') { ------------------ | Branch (460:7): [True: 14, False: 934] ------------------ 461| 14| source->line++; 462| 14| } 463| | 464| 948| if (lex->comment_ok && !no_comments) { ------------------ | Branch (464:7): [True: 948, False: 0] | Branch (464:26): [True: 948, False: 0] ------------------ 465| 948| if (!escaped && c == ';' && ------------------ | Branch (465:8): [True: 948, False: 0] | Branch (465:20): [True: 0, False: 948] ------------------ 466| 0| ((lex->comments & ISC_LEXCOMMENT_DNSMASTERFILE) != ------------------ | | 97| 0|#define ISC_LEXCOMMENT_DNSMASTERFILE 0x08 ------------------ | Branch (466:8): [True: 0, False: 0] ------------------ 467| 0| 0)) 468| 0| { 469| 0| saved_state = state; 470| 0| state = lexstate_eatline; 471| 0| no_comments = true; 472| 0| continue; 473| 948| } else if (c == '/' && ------------------ | Branch (473:15): [True: 8, False: 940] ------------------ 474| 8| (lex->comments & ------------------ | Branch (474:8): [True: 0, False: 8] ------------------ 475| 8| (ISC_LEXCOMMENT_C | ------------------ | | 94| 8|#define ISC_LEXCOMMENT_C 0x01 ------------------ 476| 8| ISC_LEXCOMMENT_CPLUSPLUS)) != 0) ------------------ | | 95| 8|#define ISC_LEXCOMMENT_CPLUSPLUS 0x02 ------------------ 477| 0| { 478| 0| saved_state = state; 479| 0| state = lexstate_maybecomment; 480| 0| no_comments = true; 481| 0| continue; 482| 948| } else if (c == '#' && ((lex->comments & ------------------ | Branch (482:15): [True: 0, False: 948] | Branch (482:27): [True: 0, False: 0] ------------------ 483| 0| ISC_LEXCOMMENT_SHELL) != 0)) ------------------ | | 96| 0|#define ISC_LEXCOMMENT_SHELL 0x04 ------------------ 484| 0| { 485| 0| saved_state = state; 486| 0| state = lexstate_eatline; 487| 0| no_comments = true; 488| 0| continue; 489| 0| } 490| 948| } 491| | 492| 1.01k| no_read: 493| | /* INSIST(c == EOF || (c >= 0 && c <= 255)); */ 494| 1.01k| switch (state) { 495| 134| case lexstate_start: ------------------ | Branch (495:3): [True: 134, False: 880] ------------------ 496| 134| if (c == EOF) { ------------------ | Branch (496:8): [True: 2, False: 132] ------------------ 497| 2| lex->last_was_eol = false; 498| 2| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && ------------------ | | 77| 2|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (498:9): [True: 2, False: 0] ------------------ 499| 2| lex->paren_count != 0) ------------------ | Branch (499:9): [True: 0, False: 2] ------------------ 500| 0| { 501| 0| lex->paren_count = 0; 502| 0| result = ISC_R_UNBALANCED; 503| 0| goto done; 504| 0| } 505| 2| if ((options & ISC_LEXOPT_BTEXT) != 0 && ------------------ | | 84| 2|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (505:9): [True: 0, False: 2] ------------------ 506| 0| lex->brace_count != 0) ------------------ | Branch (506:9): [True: 0, False: 0] ------------------ 507| 0| { 508| 0| lex->brace_count = 0; 509| 0| result = ISC_R_UNBALANCED; 510| 0| goto done; 511| 0| } 512| 2| if ((options & ISC_LEXOPT_EOF) == 0) { ------------------ | | 63| 2|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ | Branch (512:9): [True: 0, False: 2] ------------------ 513| 0| result = ISC_R_EOF; 514| 0| goto done; 515| 0| } 516| 2| tokenp->type = isc_tokentype_eof; 517| 2| done = true; 518| 132| } else if (c == ' ' || c == '\t') { ------------------ | Branch (518:15): [True: 60, False: 72] | Branch (518:27): [True: 0, False: 72] ------------------ 519| 60| if (lex->last_was_eol && ------------------ | Branch (519:9): [True: 0, False: 60] ------------------ 520| 0| (options & ISC_LEXOPT_INITIALWS) != 0) ------------------ | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ ------------------ | Branch (520:9): [True: 0, False: 0] ------------------ 521| 0| { 522| 0| lex->last_was_eol = false; 523| 0| tokenp->type = isc_tokentype_initialws; 524| 0| tokenp->value.as_char = c; 525| 0| done = true; 526| 0| } 527| 72| } else if (c == '\n') { ------------------ | Branch (527:15): [True: 6, False: 66] ------------------ 528| 6| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 6|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (528:9): [True: 6, False: 0] ------------------ 529| 6| tokenp->type = isc_tokentype_eol; 530| 6| done = true; 531| 6| } 532| 6| lex->last_was_eol = true; 533| 66| } else if (c == '\r') { ------------------ | Branch (533:15): [True: 0, False: 66] ------------------ 534| 0| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (534:9): [True: 0, False: 0] ------------------ 535| 0| state = lexstate_crlf; 536| 0| } 537| 66| } else if (c == '"' && ------------------ | Branch (537:15): [True: 0, False: 66] ------------------ 538| 0| (options & ISC_LEXOPT_QSTRING) != 0) ------------------ | | 66| 0|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ | Branch (538:8): [True: 0, False: 0] ------------------ 539| 0| { 540| 0| lex->last_was_eol = false; 541| 0| no_comments = true; 542| 0| state = lexstate_qstring; 543| 66| } else if (lex->specials[c]) { ------------------ | Branch (543:15): [True: 0, False: 66] ------------------ 544| 0| lex->last_was_eol = false; 545| 0| if ((c == '(' || c == ')') && ------------------ | Branch (545:10): [True: 0, False: 0] | Branch (545:22): [True: 0, False: 0] ------------------ 546| 0| (options & ISC_LEXOPT_DNSMULTILINE) != 0) ------------------ | | 77| 0|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (546:9): [True: 0, False: 0] ------------------ 547| 0| { 548| 0| if (c == '(') { ------------------ | Branch (548:10): [True: 0, False: 0] ------------------ 549| 0| if (lex->paren_count == 0) { ------------------ | Branch (549:11): [True: 0, False: 0] ------------------ 550| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 551| 0| } 552| 0| lex->paren_count++; 553| 0| } else { 554| 0| if (lex->paren_count == 0) { ------------------ | Branch (554:11): [True: 0, False: 0] ------------------ 555| 0| result = 556| 0| ISC_R_UNBALANCED; 557| 0| goto done; 558| 0| } 559| 0| lex->paren_count--; 560| 0| if (lex->paren_count == 0) { ------------------ | Branch (560:11): [True: 0, False: 0] ------------------ 561| 0| options = saved_options; 562| 0| } 563| 0| } 564| 0| continue; 565| 0| } else if (c == '{' && ------------------ | Branch (565:16): [True: 0, False: 0] ------------------ 566| 0| (options & ISC_LEXOPT_BTEXT) != 0) ------------------ | | 84| 0|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (566:9): [True: 0, False: 0] ------------------ 567| 0| { 568| 0| if (lex->brace_count != 0) { ------------------ | Branch (568:10): [True: 0, False: 0] ------------------ 569| 0| result = ISC_R_UNBALANCED; 570| 0| goto done; 571| 0| } 572| 0| lex->brace_count++; 573| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 574| 0| state = lexstate_btext; 575| 0| no_comments = true; 576| 0| continue; 577| 0| } 578| 0| tokenp->type = isc_tokentype_special; 579| 0| tokenp->value.as_char = c; 580| 0| done = true; 581| 66| } else if (isdigit((unsigned char)c) && ------------------ | Branch (581:15): [True: 24, False: 42] ------------------ 582| 24| (options & ISC_LEXOPT_NUMBER) != 0) ------------------ | | 65| 24|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ | Branch (582:8): [True: 2, False: 22] ------------------ 583| 2| { 584| 2| lex->last_was_eol = false; 585| 2| if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (585:9): [True: 0, False: 2] ------------------ 586| 0| (c == '8' || c == '9')) ------------------ | Branch (586:10): [True: 0, False: 0] | Branch (586:22): [True: 0, False: 0] ------------------ 587| 0| { 588| 0| state = lexstate_string; 589| 2| } else { 590| 2| state = lexstate_number; 591| 2| } 592| 2| goto no_read; 593| 64| } else { 594| 64| lex->last_was_eol = false; 595| 64| state = lexstate_string; 596| 64| goto no_read; 597| 64| } 598| 68| break; 599| 68| case lexstate_crlf: ------------------ | Branch (599:3): [True: 0, False: 1.01k] ------------------ 600| 0| if (c != '\n') { ------------------ | Branch (600:8): [True: 0, False: 0] ------------------ 601| 0| pushback(source, c); 602| 0| } 603| 0| tokenp->type = isc_tokentype_eol; 604| 0| done = true; 605| 0| lex->last_was_eol = true; 606| 0| break; 607| 4| case lexstate_number: ------------------ | Branch (607:3): [True: 4, False: 1.01k] ------------------ 608| 4| if (c == EOF || !isdigit((unsigned char)c)) { ------------------ | Branch (608:8): [True: 0, False: 4] | Branch (608:20): [True: 2, False: 2] ------------------ 609| 2| if (c == ' ' || c == '\t' || c == '\r' || ------------------ | Branch (609:9): [True: 2, False: 0] | Branch (609:21): [True: 0, False: 0] | Branch (609:34): [True: 0, False: 0] ------------------ 610| 0| c == '\n' || c == EOF || lex->specials[c]) ------------------ | Branch (610:9): [True: 0, False: 0] | Branch (610:22): [True: 0, False: 0] | Branch (610:34): [True: 0, False: 0] ------------------ 611| 2| { 612| 2| int base; 613| 2| if ((options & ISC_LEXOPT_OCTAL) != 0) { ------------------ | | 83| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (613:10): [True: 0, False: 2] ------------------ 614| 0| base = 8; 615| 2| } else if ((options & ------------------ | Branch (615:17): [True: 0, False: 2] ------------------ 616| 2| ISC_LEXOPT_CNUMBER) != 0) ------------------ | | 80| 2|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ 617| 0| { 618| 0| base = 0; 619| 2| } else { 620| 2| base = 10; 621| 2| } 622| 2| pushback(source, c); 623| | 624| 2| result = isc_parse_uint32( 625| 2| &as_ulong, lex->data, base); 626| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (626:10): [True: 2, False: 0] ------------------ 627| 2| tokenp->type = 628| 2| isc_tokentype_number; 629| 2| tokenp->value.as_ulong = 630| 2| as_ulong; 631| 2| } else if (result == ISC_R_BADNUMBER) { ------------------ | Branch (631:17): [True: 0, False: 0] ------------------ 632| 0| isc_tokenvalue_t *v; 633| | 634| 0| tokenp->type = 635| 0| isc_tokentype_string; 636| 0| v = &(tokenp->value); 637| 0| v->as_textregion.base = 638| 0| lex->data; 639| 0| v->as_textregion.length = 640| 0| (unsigned int)(lex->max_token - 641| 0| remaining); 642| 0| } else { 643| 0| goto done; 644| 0| } 645| 2| done = true; 646| 2| continue; 647| 2| } else if ((options & ISC_LEXOPT_CNUMBER) == ------------------ | | 80| 0|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ | Branch (647:16): [True: 0, False: 0] ------------------ 648| 0| 0 || 649| 0| ((c != 'x' && c != 'X') || ------------------ | Branch (649:11): [True: 0, False: 0] | Branch (649:23): [True: 0, False: 0] ------------------ 650| 0| (curr != &lex->data[1]) || ------------------ | Branch (650:10): [True: 0, False: 0] ------------------ 651| 0| (lex->data[0] != '0'))) ------------------ | Branch (651:10): [True: 0, False: 0] ------------------ 652| 0| { 653| | /* Above test supports hex numbers */ 654| 0| state = lexstate_string; 655| 0| } 656| 2| } else if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (656:15): [True: 0, False: 2] ------------------ 657| 0| (c == '8' || c == '9')) ------------------ | Branch (657:9): [True: 0, False: 0] | Branch (657:21): [True: 0, False: 0] ------------------ 658| 0| { 659| 0| state = lexstate_string; 660| 0| } 661| 2| if (remaining == 0U) { ------------------ | Branch (661:8): [True: 0, False: 2] ------------------ 662| 0| grow_data(lex, &remaining, &curr, &prev); 663| 0| } 664| 2| INSIST(remaining > 0U); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 665| 2| *curr++ = c; 666| 2| *curr = '\0'; 667| 2| remaining--; 668| 2| break; 669| 876| case lexstate_string: ------------------ | Branch (669:3): [True: 876, False: 138] ------------------ 670| 876| if (!escaped && c == '=' && ------------------ | Branch (670:8): [True: 876, False: 0] | Branch (670:20): [True: 2, False: 874] ------------------ 671| 2| (options & ISC_LEXOPT_VPAIR) != 0) ------------------ | | 85| 2|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ | Branch (671:8): [True: 0, False: 2] ------------------ 672| 0| { 673| 0| if (remaining == 0U) { ------------------ | Branch (673:9): [True: 0, False: 0] ------------------ 674| 0| grow_data(lex, &remaining, &curr, 675| 0| &prev); 676| 0| } 677| 0| INSIST(remaining > 0U); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 678| 0| *curr++ = c; 679| 0| *curr = '\0'; 680| 0| remaining--; 681| 0| state = lexstate_vpairstart; 682| 0| break; 683| 0| } 684| 876| FALLTHROUGH; ------------------ | | 101| 876|#define FALLTHROUGH [[fallthrough]] ------------------ 685| 876| case lexstate_vpairstart: ------------------ | Branch (685:3): [True: 0, False: 1.01k] ------------------ 686| 876| if (state == lexstate_vpairstart) { ------------------ | Branch (686:8): [True: 0, False: 876] ------------------ 687| 0| if (c == '"' && ------------------ | Branch (687:9): [True: 0, False: 0] ------------------ 688| 0| (options & ISC_LEXOPT_QVPAIR) != 0) ------------------ | | 86| 0|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ | Branch (688:9): [True: 0, False: 0] ------------------ 689| 0| { 690| 0| no_comments = true; 691| 0| state = lexstate_qvpair; 692| 0| break; 693| 0| } 694| 0| state = lexstate_vpair; 695| 0| } 696| 876| FALLTHROUGH; ------------------ | | 101| 876|#define FALLTHROUGH [[fallthrough]] ------------------ 697| 876| case lexstate_vpair: ------------------ | Branch (697:3): [True: 0, False: 1.01k] ------------------ 698| | /* 699| | * EOF needs to be checked before lex->specials[c] 700| | * as lex->specials[EOF] is not a good idea. 701| | */ 702| 876| if (c == '\r' || c == '\n' || c == EOF || ------------------ | Branch (702:8): [True: 0, False: 876] | Branch (702:21): [True: 8, False: 868] | Branch (702:34): [True: 0, False: 868] ------------------ 703| 868| (!escaped && ------------------ | Branch (703:9): [True: 868, False: 0] ------------------ 704| 868| (c == ' ' || c == '\t' || lex->specials[c]))) ------------------ | Branch (704:10): [True: 56, False: 812] | Branch (704:22): [True: 0, False: 812] | Branch (704:35): [True: 0, False: 812] ------------------ 705| 64| { 706| 64| pushback(source, c); 707| 64| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (707:9): [True: 0, False: 64] ------------------ 708| 0| result = source->result; 709| 0| goto done; 710| 0| } 711| 64| if (escaped && c == EOF) { ------------------ | Branch (711:9): [True: 0, False: 64] | Branch (711:20): [True: 0, False: 0] ------------------ 712| 0| result = ISC_R_UNEXPECTEDEND; 713| 0| goto done; 714| 0| } 715| 64| tokenp->type = (state == lexstate_string) ------------------ | Branch (715:20): [True: 64, False: 0] ------------------ 716| 64| ? isc_tokentype_string 717| 64| : isc_tokentype_vpair; 718| 64| tokenp->value.as_textregion.base = lex->data; 719| 64| tokenp->value.as_textregion.length = 720| 64| (unsigned int)(lex->max_token - 721| 64| remaining); 722| 64| done = true; 723| 64| continue; 724| 64| } 725| 812| if ((options & ISC_LEXOPT_ESCAPE) != 0) { ------------------ | | 81| 812|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ | Branch (725:8): [True: 812, False: 0] ------------------ 726| 812| escaped = (!escaped && c == '\\') ? true ------------------ | Branch (726:16): [True: 812, False: 0] | Branch (726:28): [True: 0, False: 812] ------------------ 727| 812| : false; 728| 812| } 729| 812| if (remaining == 0U) { ------------------ | Branch (729:8): [True: 0, False: 812] ------------------ 730| 0| grow_data(lex, &remaining, &curr, &prev); 731| 0| } 732| 812| INSIST(remaining > 0U); ------------------ | | 198| 812|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 812| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 812, False: 0] | | | | ------------------ | | | | 55| 812| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 733| 812| *curr++ = c; 734| 812| *curr = '\0'; 735| 812| remaining--; 736| 812| break; 737| 0| case lexstate_maybecomment: ------------------ | Branch (737:3): [True: 0, False: 1.01k] ------------------ 738| 0| if (c == '*' && (lex->comments & ISC_LEXCOMMENT_C) != 0) ------------------ | | 94| 0|#define ISC_LEXCOMMENT_C 0x01 ------------------ | Branch (738:8): [True: 0, False: 0] | Branch (738:20): [True: 0, False: 0] ------------------ 739| 0| { 740| 0| state = lexstate_ccomment; 741| 0| continue; 742| 0| } else if (c == '/' && (lex->comments & ------------------ | Branch (742:15): [True: 0, False: 0] | Branch (742:27): [True: 0, False: 0] ------------------ 743| 0| ISC_LEXCOMMENT_CPLUSPLUS) != 0) ------------------ | | 95| 0|#define ISC_LEXCOMMENT_CPLUSPLUS 0x02 ------------------ 744| 0| { 745| 0| state = lexstate_eatline; 746| 0| continue; 747| 0| } 748| 0| pushback(source, c); 749| 0| c = '/'; 750| 0| no_comments = false; 751| 0| state = saved_state; 752| 0| goto no_read; 753| 0| case lexstate_ccomment: ------------------ | Branch (753:3): [True: 0, False: 1.01k] ------------------ 754| 0| if (c == EOF) { ------------------ | Branch (754:8): [True: 0, False: 0] ------------------ 755| 0| result = ISC_R_UNEXPECTEDEND; 756| 0| goto done; 757| 0| } 758| 0| if (c == '*') { ------------------ | Branch (758:8): [True: 0, False: 0] ------------------ 759| 0| state = lexstate_ccommentend; 760| 0| } 761| 0| break; 762| 0| case lexstate_ccommentend: ------------------ | Branch (762:3): [True: 0, False: 1.01k] ------------------ 763| 0| if (c == EOF) { ------------------ | Branch (763:8): [True: 0, False: 0] ------------------ 764| 0| result = ISC_R_UNEXPECTEDEND; 765| 0| goto done; 766| 0| } 767| 0| if (c == '/') { ------------------ | Branch (767:8): [True: 0, False: 0] ------------------ 768| | /* 769| | * C-style comments become a single space. 770| | * We do this to ensure that a comment will 771| | * act as a delimiter for strings and 772| | * numbers. 773| | */ 774| 0| c = ' '; 775| 0| no_comments = false; 776| 0| state = saved_state; 777| 0| goto no_read; 778| 0| } else if (c != '*') { ------------------ | Branch (778:15): [True: 0, False: 0] ------------------ 779| 0| state = lexstate_ccomment; 780| 0| } 781| 0| break; 782| 0| case lexstate_eatline: ------------------ | Branch (782:3): [True: 0, False: 1.01k] ------------------ 783| 0| if ((c == '\n') || (c == EOF)) { ------------------ | Branch (783:8): [True: 0, False: 0] | Branch (783:23): [True: 0, False: 0] ------------------ 784| 0| no_comments = false; 785| 0| state = saved_state; 786| 0| goto no_read; 787| 0| } 788| 0| break; 789| 0| case lexstate_qstring: ------------------ | Branch (789:3): [True: 0, False: 1.01k] ------------------ 790| 0| case lexstate_qvpair: ------------------ | Branch (790:3): [True: 0, False: 1.01k] ------------------ 791| 0| if (c == EOF) { ------------------ | Branch (791:8): [True: 0, False: 0] ------------------ 792| 0| result = ISC_R_UNEXPECTEDEND; 793| 0| goto done; 794| 0| } 795| 0| if (c == '"') { ------------------ | Branch (795:8): [True: 0, False: 0] ------------------ 796| 0| if (escaped) { ------------------ | Branch (796:9): [True: 0, False: 0] ------------------ 797| 0| escaped = false; 798| | /* 799| | * Overwrite the preceding backslash. 800| | */ 801| 0| INSIST(prev != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 802| 0| *prev = '"'; 803| 0| } else { 804| 0| tokenp->type = 805| 0| (state == lexstate_qstring) ------------------ | Branch (805:7): [True: 0, False: 0] ------------------ 806| 0| ? isc_tokentype_qstring 807| 0| : isc_tokentype_qvpair; 808| 0| tokenp->value.as_textregion.base = 809| 0| lex->data; 810| 0| tokenp->value.as_textregion.length = 811| 0| (unsigned int)(lex->max_token - 812| 0| remaining); 813| 0| no_comments = false; 814| 0| done = true; 815| 0| } 816| 0| } else { 817| 0| if (c == '\n' && !escaped && ------------------ | Branch (817:9): [True: 0, False: 0] | Branch (817:22): [True: 0, False: 0] ------------------ 818| 0| (options & ISC_LEXOPT_QSTRINGMULTILINE) == ------------------ | | 82| 0|#define ISC_LEXOPT_QSTRINGMULTILINE 0x0200 /*%< Allow multiline "" strings */ ------------------ | Branch (818:9): [True: 0, False: 0] ------------------ 819| 0| 0) 820| 0| { 821| 0| pushback(source, c); 822| 0| result = ISC_R_UNBALANCEDQUOTES; 823| 0| goto done; 824| 0| } 825| 0| if (c == '\\' && !escaped) { ------------------ | Branch (825:9): [True: 0, False: 0] | Branch (825:22): [True: 0, False: 0] ------------------ 826| 0| escaped = true; 827| 0| } else { 828| 0| escaped = false; 829| 0| } 830| 0| if (remaining == 0U) { ------------------ | Branch (830:9): [True: 0, False: 0] ------------------ 831| 0| grow_data(lex, &remaining, &curr, 832| 0| &prev); 833| 0| } 834| 0| INSIST(remaining > 0U); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 835| 0| prev = curr; 836| 0| *curr++ = c; 837| 0| *curr = '\0'; 838| 0| remaining--; 839| 0| } 840| 0| break; 841| 0| case lexstate_btext: ------------------ | Branch (841:3): [True: 0, False: 1.01k] ------------------ 842| 0| if (c == EOF) { ------------------ | Branch (842:8): [True: 0, False: 0] ------------------ 843| 0| result = ISC_R_UNEXPECTEDEND; 844| 0| goto done; 845| 0| } 846| 0| if (c == '{') { ------------------ | Branch (846:8): [True: 0, False: 0] ------------------ 847| 0| if (escaped) { ------------------ | Branch (847:9): [True: 0, False: 0] ------------------ 848| 0| escaped = false; 849| 0| } else { 850| 0| lex->brace_count++; 851| 0| } 852| 0| } else if (c == '}') { ------------------ | Branch (852:15): [True: 0, False: 0] ------------------ 853| 0| if (escaped) { ------------------ | Branch (853:9): [True: 0, False: 0] ------------------ 854| 0| escaped = false; 855| 0| } else { 856| 0| INSIST(lex->brace_count > 0); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 857| 0| lex->brace_count--; 858| 0| } 859| | 860| 0| if (lex->brace_count == 0) { ------------------ | Branch (860:9): [True: 0, False: 0] ------------------ 861| 0| tokenp->type = isc_tokentype_btext; 862| 0| tokenp->value.as_textregion.base = 863| 0| lex->data; 864| 0| tokenp->value.as_textregion.length = 865| 0| (unsigned int)(lex->max_token - 866| 0| remaining); 867| 0| no_comments = false; 868| 0| done = true; 869| 0| break; 870| 0| } 871| 0| } 872| | 873| 0| if (c == '\\' && !escaped) { ------------------ | Branch (873:8): [True: 0, False: 0] | Branch (873:21): [True: 0, False: 0] ------------------ 874| 0| escaped = true; 875| 0| } else { 876| 0| escaped = false; 877| 0| } 878| | 879| 0| if (remaining == 0U) { ------------------ | Branch (879:8): [True: 0, False: 0] ------------------ 880| 0| grow_data(lex, &remaining, &curr, &prev); 881| 0| } 882| 0| INSIST(remaining > 0U); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 883| 0| prev = curr; 884| 0| *curr++ = c; 885| 0| *curr = '\0'; 886| 0| remaining--; 887| 0| break; 888| 0| default: ------------------ | Branch (888:3): [True: 0, False: 1.01k] ------------------ 889| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 890| 1.01k| } 891| 1.01k| } while (!done); ------------------ | Branch (891:11): [True: 874, False: 74] ------------------ 892| | 893| 74| result = ISC_R_SUCCESS; 894| 74|done: 895| 74|#ifdef HAVE_FLOCKFILE 896| 74| if (source->is_file) { ------------------ | Branch (896:6): [True: 74, False: 0] ------------------ 897| 74| funlockfile(source->input); 898| 74| } 899| 74|#endif /* ifdef HAVE_FLOCKFILE */ 900| 74| return result; 901| 74|} isc_lex_getmastertoken: 905| 42| isc_tokentype_t expect, bool eol) { 906| 42| unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 62| 42|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 63| 42|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ 907| 42| ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 77| 42|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 81| 42|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 908| 42| isc_result_t result; 909| | 910| 42| if (expect == isc_tokentype_vpair) { ------------------ | Branch (910:6): [True: 0, False: 42] ------------------ 911| 0| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 0|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 912| 42| } else if (expect == isc_tokentype_qvpair) { ------------------ | Branch (912:13): [True: 0, False: 42] ------------------ 913| 0| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 0|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 914| 0| options |= ISC_LEXOPT_QVPAIR; ------------------ | | 86| 0|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ 915| 42| } else if (expect == isc_tokentype_qstring) { ------------------ | Branch (915:13): [True: 6, False: 36] ------------------ 916| 6| options |= ISC_LEXOPT_QSTRING; ------------------ | | 66| 6|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ 917| 36| } else if (expect == isc_tokentype_number) { ------------------ | Branch (917:13): [True: 2, False: 34] ------------------ 918| 2| options |= ISC_LEXOPT_NUMBER; ------------------ | | 65| 2|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ 919| 2| } 920| 42| result = isc_lex_gettoken(lex, options, token); 921| 42| if (result == ISC_R_RANGE) { ------------------ | Branch (921:6): [True: 0, False: 42] ------------------ 922| 0| isc_lex_ungettoken(lex, token); 923| 0| } 924| 42| if (result != ISC_R_SUCCESS) { ------------------ | Branch (924:6): [True: 0, False: 42] ------------------ 925| 0| return result; 926| 0| } 927| | 928| 42| if (eol && ((token->type == isc_tokentype_eol) || ------------------ | Branch (928:6): [True: 20, False: 22] | Branch (928:14): [True: 0, False: 20] ------------------ 929| 20| (token->type == isc_tokentype_eof))) ------------------ | Branch (929:7): [True: 0, False: 20] ------------------ 930| 0| { 931| 0| return ISC_R_SUCCESS; 932| 0| } 933| 42| if (token->type == isc_tokentype_string && ------------------ | Branch (933:6): [True: 40, False: 2] ------------------ 934| 40| (expect == isc_tokentype_qstring || expect == isc_tokentype_qvpair)) ------------------ | Branch (934:7): [True: 6, False: 34] | Branch (934:42): [True: 0, False: 34] ------------------ 935| 6| { 936| 6| return ISC_R_SUCCESS; 937| 6| } 938| 36| if (token->type == isc_tokentype_vpair && ------------------ | Branch (938:6): [True: 0, False: 36] ------------------ 939| 0| expect == isc_tokentype_qvpair) ------------------ | Branch (939:6): [True: 0, False: 0] ------------------ 940| 0| { 941| 0| return ISC_R_SUCCESS; 942| 0| } 943| 36| if (token->type != expect) { ------------------ | Branch (943:6): [True: 0, False: 36] ------------------ 944| 0| isc_lex_ungettoken(lex, token); 945| 0| if (token->type == isc_tokentype_eol || ------------------ | Branch (945:7): [True: 0, False: 0] ------------------ 946| 0| token->type == isc_tokentype_eof) ------------------ | Branch (946:7): [True: 0, False: 0] ------------------ 947| 0| { 948| 0| return ISC_R_UNEXPECTEDEND; 949| 0| } 950| 0| if (expect == isc_tokentype_number) { ------------------ | Branch (950:7): [True: 0, False: 0] ------------------ 951| 0| return ISC_R_BADNUMBER; 952| 0| } 953| 0| return ISC_R_UNEXPECTEDTOKEN; 954| 0| } 955| 36| return ISC_R_SUCCESS; 956| 36|} isc_lex_ungettoken: 991| 6|isc_lex_ungettoken(isc_lex_t *lex, isc_token_t *tokenp) { 992| 6| inputsource *source; 993| | /* 994| | * Unget the current token. 995| | */ 996| | 997| 6| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 998| 6| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 999| 6| REQUIRE(source != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1000| 6| REQUIRE(tokenp != NULL); ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1001| 6| REQUIRE(isc_buffer_consumedlength(source->pushback) != 0 || ------------------ | | 194| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1002| 6| tokenp->type == isc_tokentype_eof); 1003| | 1004| 6| UNUSED(tokenp); ------------------ | | 65| 6|#define UNUSED(x) (void)(x) ------------------ 1005| | 1006| 6| isc_buffer_first(source->pushback); 1007| 6| lex->paren_count = lex->saved_paren_count; 1008| 6| source->line = source->saved_line; 1009| | source->at_eof = false; 1010| 6|} isc_lex_getsourcename: 1033| 8|isc_lex_getsourcename(isc_lex_t *lex) { 1034| 8| inputsource *source; 1035| | 1036| 8| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1037| 8| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 8|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1038| | 1039| 8| if (source == NULL) { ------------------ | Branch (1039:6): [True: 0, False: 8] ------------------ 1040| 0| return NULL; 1041| 0| } 1042| | 1043| 8| return source->name; 1044| 8|} isc_lex_getsourceline: 1047| 22|isc_lex_getsourceline(isc_lex_t *lex) { 1048| 22| inputsource *source; 1049| | 1050| 22| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 22|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 44| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 22, False: 0] | | | | | Branch (42:11): [True: 22, False: 0] | | | | ------------------ | | | | 43| 22| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1051| 22| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 22|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1052| | 1053| 22| if (source == NULL) { ------------------ | Branch (1053:6): [True: 0, False: 22] ------------------ 1054| 0| return 0; 1055| 0| } 1056| | 1057| 22| return source->line; 1058| 22|} lex.c:new_source: 183| 2| const char *name) { 184| 2| inputsource *source; 185| | 186| 2| source = isc_mem_get(lex->mctx, sizeof(*source)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 187| 2| *source = (inputsource){ 188| 2| .is_file = is_file, 189| 2| .need_close = need_close, 190| 2| .last_was_eol = lex->last_was_eol, 191| 2| .input = input, 192| 2| .name = isc_mem_strdup(lex->mctx, name), ------------------ | | 144| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 193| 2| .line = 1, 194| 2| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2| } | | ------------------ ------------------ 195| 2| }; 196| 2| isc_buffer_allocate(lex->mctx, &source->pushback, 197| 2| (unsigned int)lex->max_token); 198| | ISC_LIST_PREPEND(lex->sources, source, link); ------------------ | | 79| 2| do { \ | | 80| 2| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 2| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 2| do { \ | | | | 68| 2| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 0, False: 2] | | | | ------------------ | | | | 69| 0| (list).head->link.prev = (elt); \ | | | | 70| 2| } else { \ | | | | 71| 2| (list).tail = (elt); \ | | | | 72| 2| } \ | | | | 73| 2| (elt)->link.prev = NULL; \ | | | | 74| 2| (elt)->link.next = (list).head; \ | | | | 75| 2| (list).head = (elt); \ | | | | 76| 2| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 2] | | | | ------------------ | | ------------------ | | 82| 2| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 2] | | ------------------ ------------------ 199| 2|} lex.c:pushandgrow: 309| 864|pushandgrow(isc_lex_t *lex, inputsource *source, int c) { 310| 864| if (isc_buffer_availablelength(source->pushback) == 0) { ------------------ | | 161| 864|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (310:6): [True: 0, False: 864] ------------------ 311| 0| isc_buffer_t *tbuf = NULL; 312| 0| unsigned int oldlen; 313| 0| isc_region_t used; 314| 0| isc_result_t result; 315| | 316| 0| oldlen = isc_buffer_length(source->pushback); ------------------ | | 150| 0|#define isc_buffer_length(b) ((b)->length) /*e*/ ------------------ 317| 0| isc_buffer_allocate(lex->mctx, &tbuf, oldlen * 2); 318| 0| isc_buffer_usedregion(source->pushback, &used); 319| 0| result = isc_buffer_copyregion(tbuf, &used); 320| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 321| 0| tbuf->current = source->pushback->current; 322| 0| isc_buffer_free(&source->pushback); 323| 0| source->pushback = tbuf; 324| 0| } 325| 864| isc_buffer_putuint8(source->pushback, (uint8_t)c); 326| 864| return ISC_R_SUCCESS; 327| 864|} lex.c:pushback: 296| 66|pushback(inputsource *source, int c) { 297| 66| REQUIRE(source->pushback->current > 0); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 66| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 298| 66| if (c == EOF) { ------------------ | Branch (298:6): [True: 0, False: 66] ------------------ 299| 0| source->at_eof = false; 300| 0| return; 301| 0| } 302| 66| source->pushback->current--; 303| 66| if (c == '\n') { ------------------ | Branch (303:6): [True: 8, False: 58] ------------------ 304| 8| source->line--; 305| 8| } 306| 66|} isc__lib_initialize: 46| 4|isc__lib_initialize(void) { 47| 4| if (isc_refcount_increment0(&isc__lib_references) > 0) { ------------------ | | 68| 4| ({ \ | | 69| 4| uint_fast32_t __v; \ | | 70| 4| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 4| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 71| 4| INSIST(__v < UINT32_MAX); \ | | ------------------ | | | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 4| __v; \ | | 73| 4| }) ------------------ | Branch (47:6): [True: 2, False: 2] ------------------ 48| 2| return; 49| 2| } 50| | 51| 4| rcu_register_thread(); 52| 2| isc__os_initialize(); 53| 2| isc__mutex_initialize(); 54| 2| isc__mem_initialize(); 55| 2| isc__log_initialize(); 56| 2| isc__crypto_initialize(); 57| 2| isc__uv_initialize(); 58| 2| isc__xml_initialize(); 59| 2| isc__hash_initialize(); 60| 2| isc__iterated_hash_initialize(); 61| 2| (void)isc_os_ncpus(); 62| 2|} isc_logconfig_create: 328| 2|isc_logconfig_create(isc_logconfig_t **lcfgp) { 329| 2| REQUIRE(lcfgp != NULL && *lcfgp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 330| 2| REQUIRE(VALID_CONTEXT(isc__lctx)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 331| | 332| 2| int level = ISC_LOG_INFO; ------------------ | | 42| 2|#define ISC_LOG_INFO (-1) ------------------ 333| | 334| 2| isc_logconfig_t *lcfg = isc_mem_get(isc__lctx->mctx, sizeof(*lcfg)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 335| | 336| 2| *lcfg = (isc_logconfig_t){ 337| 2| .magic = LCFG_MAGIC, ------------------ | | 43| 2|#define LCFG_MAGIC ISC_MAGIC('L', 'c', 'f', 'g') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 338| 2| .lctx = isc__lctx, 339| 2| .channels = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 340| 2| .highest_level = level, 341| 2| }; 342| | 343| | /* 344| | * Create the default channels: 345| | * default_syslog, default_stderr, default_debug and null. 346| | */ 347| 2| isc_log_createchannel(lcfg, "default_syslog", ISC_LOG_TOSYSLOG, level, ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ 348| 2| ISC_LOGDESTINATION_SYSLOG(LOG_DAEMON), 0); ------------------ | | 287| 2| (&(isc_logdestination_t){ .facility = (f) }) ------------------ 349| | 350| 2| isc_log_createchannel(lcfg, "default_stderr", ISC_LOG_TOFILEDESC, level, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 351| 2| ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 352| | 353| | /* 354| | * Set the default category's channel to default_stderr, 355| | * which is at the head of the channels list because it was 356| | * just created. 357| | */ 358| 2| default_channel.channel = ISC_LIST_HEAD(lcfg->channels); ------------------ | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 359| | 360| 2| isc_log_createchannel(lcfg, "default_debug", ISC_LOG_TOFILEDESC, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 361| 2| ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ 362| 2| ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 363| | 364| 2| isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ 365| 2| NULL, 0); 366| | 367| 2| *lcfgp = lcfg; 368| 2|} isc_log_createchannel: 473| 8| unsigned int flags) { 474| 8| isc_logchannel_t *channel; 475| 8| isc_mem_t *mctx; 476| 8| unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 69| 8|#define ISC_LOG_PRINTALL 0x0003F ------------------ unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 71| 8|#define ISC_LOG_DEBUGONLY 0x01000 ------------------ 477| 8| ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 70| 8|#define ISC_LOG_BUFFERED 0x00040 ------------------ ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 73| 8|#define ISC_LOG_ISO8601 0x10000 /* if PRINTTIME, use ISO8601 */ ------------------ 478| 8| ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 74| 8|#define ISC_LOG_UTC 0x20000 /* if PRINTTIME, use UTC */ ------------------ ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 75| 8|#define ISC_LOG_TZINFO 0x40000 /* if PRINTTIME, output TZ info */ ------------------ 479| | 480| 8| REQUIRE(VALID_CONFIG(lcfg)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 481| 8| REQUIRE(name != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 482| 8| REQUIRE(type == ISC_LOG_TOSYSLOG || type == ISC_LOG_TOFILE || ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 6] | | | | | Branch (42:11): [True: 0, False: 6] | | | | | Branch (42:11): [True: 4, False: 2] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 483| 8| type == ISC_LOG_TOFILEDESC || type == ISC_LOG_TONULL); 484| 8| REQUIRE(destination != NULL || type == ISC_LOG_TONULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 2] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 485| 8| REQUIRE(level >= ISC_LOG_CRITICAL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 486| 8| REQUIRE((flags & ~permitted) == 0); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 487| 8| REQUIRE(!(flags & ISC_LOG_UTC) || !(flags & ISC_LOG_TZINFO)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 488| | 489| | /* FIXME: find duplicate names? */ 490| | 491| 8| mctx = lcfg->lctx->mctx; 492| | 493| 8| channel = isc_mem_get(mctx, sizeof(*channel)); ------------------ | | 128| 8|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 494| | 495| 8| channel->name = isc_mem_strdup(mctx, name); ------------------ | | 144| 8|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 496| | 497| 8| channel->type = type; 498| 8| channel->level = level; 499| 8| channel->flags = flags; 500| 8| ISC_LINK_INIT(channel, link); ------------------ | | 57| 8|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 8| do { \ | | | | 54| 8| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 8| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 8| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 501| | 502| 8| switch (type) { 503| 2| case ISC_LOG_TOSYSLOG: ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ | Branch (503:2): [True: 2, False: 6] ------------------ 504| 2| FACILITY(channel) = destination->facility; ------------------ | | 314| 2|#define FACILITY(channel) (channel->destination.facility) ------------------ 505| 2| break; 506| | 507| 0| case ISC_LOG_TOFILE: ------------------ | | 55| 0|#define ISC_LOG_TOFILE 3 ------------------ | Branch (507:2): [True: 0, False: 8] ------------------ 508| | /* 509| | * The file name is copied because greatest_version wants 510| | * to scribble on it, so it needs to be definitely in 511| | * writable memory. 512| | */ 513| 0| FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 315| 0|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 514| 0| destination->file.name); 515| 0| FILE_STREAM(channel) = NULL; ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 516| 0| FILE_VERSIONS(channel) = destination->file.versions; ------------------ | | 317| 0|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ 517| 0| FILE_SUFFIX(channel) = destination->file.suffix; ------------------ | | 318| 0|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 518| 0| FILE_MAXSIZE(channel) = destination->file.maximum_size; ------------------ | | 319| 0|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 519| 0| FILE_MAXREACHED(channel) = false; ------------------ | | 320| 0|#define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached) ------------------ 520| 0| break; 521| | 522| 4| case ISC_LOG_TOFILEDESC: ------------------ | | 56| 4|#define ISC_LOG_TOFILEDESC 4 ------------------ | Branch (522:2): [True: 4, False: 4] ------------------ 523| 4| FILE_NAME(channel) = NULL; ------------------ | | 315| 4|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ 524| 4| FILE_STREAM(channel) = destination->file.stream; ------------------ | | 316| 4|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 525| 4| FILE_MAXSIZE(channel) = 0; ------------------ | | 319| 4|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 526| 4| FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 317| 4|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 87| 4|#define ISC_LOG_ROLLNEVER (-2) ------------------ 527| 4| FILE_SUFFIX(channel) = isc_log_rollsuffix_increment; ------------------ | | 318| 4|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 528| 4| break; 529| | 530| 2| case ISC_LOG_TONULL: ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ | Branch (530:2): [True: 2, False: 6] ------------------ 531| | /* Nothing. */ 532| 2| break; 533| | 534| 0| default: ------------------ | Branch (534:2): [True: 0, False: 8] ------------------ 535| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 536| 8| } 537| | 538| 8| ISC_LIST_PREPEND(lcfg->channels, channel, link); ------------------ | | 79| 8| do { \ | | 80| 8| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 8| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 8| do { \ | | | | 68| 8| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 6, False: 2] | | | | ------------------ | | | | 69| 6| (list).head->link.prev = (elt); \ | | | | 70| 6| } else { \ | | | | 71| 2| (list).tail = (elt); \ | | | | 72| 2| } \ | | | | 73| 8| (elt)->link.prev = NULL; \ | | | | 74| 8| (elt)->link.next = (list).head; \ | | | | 75| 8| (list).head = (elt); \ | | | | 76| 8| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 8] | | | | ------------------ | | ------------------ | | 82| 8| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 8] | | ------------------ ------------------ 539| | 540| | /* 541| | * If default_stderr was redefined, make the default category 542| | * point to the new default_stderr. 543| | */ 544| 8| if (strcmp(name, "default_stderr") == 0) { ------------------ | Branch (544:6): [True: 2, False: 6] ------------------ 545| 2| default_channel.channel = channel; 546| 2| } 547| 8|} isc_log_write: 612| 2| const char *format, ...) { 613| 2| va_list args; 614| | 615| | /* 616| | * Contract checking is done in isc_log_doit(). 617| | */ 618| | 619| 2| va_start(args, format); 620| 2| isc_log_doit(category, module, level, format, args); 621| | va_end(args); 622| 2|} isc_log_wouldlog: 1197| 905|isc_log_wouldlog(int level) { 1198| | /* 1199| | * Try to avoid locking the mutex for messages which can't 1200| | * possibly be logged to any channels -- primarily debugging 1201| | * messages that the debug level is not high enough to print. 1202| | * 1203| | * If the level is (mathematically) less than or equal to the 1204| | * highest_level, or if there is a dynamic channel and the level is 1205| | * less than or equal to the debug level, the main loop must be 1206| | * entered to see if the message should really be output. 1207| | */ 1208| 905| if (isc__lctx == NULL) { ------------------ | Branch (1208:6): [True: 0, False: 905] ------------------ 1209| 0| return false; 1210| 0| } 1211| 905| if (forcelog) { ------------------ | Branch (1211:6): [True: 0, False: 905] ------------------ 1212| 0| return true; 1213| 0| } 1214| | 1215| 905| int highest_level = atomic_load_acquire(&isc__lctx->highest_level); ------------------ | | 50| 905|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 1216| 905| if (level <= highest_level) { ------------------ | Branch (1216:6): [True: 4, False: 901] ------------------ 1217| 4| return true; 1218| 4| } 1219| 901| if (atomic_load_acquire(&isc__lctx->dynamic)) { ------------------ | | 50| 901|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (50:32): [True: 0, False: 901] | | ------------------ ------------------ 1220| 0| int debug_level = atomic_load_acquire(&isc__lctx->debug_level); ------------------ | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 1221| 0| if (level <= debug_level) { ------------------ | Branch (1221:7): [True: 0, False: 0] ------------------ 1222| 0| return true; 1223| 0| } 1224| 0| } 1225| | 1226| 901| return false; 1227| 901|} isc__log_initialize: 1532| 2|isc__log_initialize(void) { 1533| 2| REQUIRE(isc__lctx == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1534| | 1535| 2| isc_mem_t *mctx = NULL; 1536| | 1537| 2| isc_mem_create("log", &mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 1538| 2| isc_mem_setdebugging(mctx, 0); 1539| | 1540| 2| isc__lctx = isc_mem_get(mctx, sizeof(*isc__lctx)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1541| 2| *isc__lctx = (isc_log_t){ 1542| 2| .magic = LCTX_MAGIC, ------------------ | | 40| 2|#define LCTX_MAGIC ISC_MAGIC('L', 'c', 't', 'x') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1543| 2| .mctx = mctx, /* implicit attach */ 1544| 2| }; 1545| | 1546| 2| isc_mutex_init(&isc__lctx->lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 1547| | 1548| | /* Create default logging configuration */ 1549| 2| isc_logconfig_t *lcfg = NULL; 1550| 2| isc_logconfig_create(&lcfg); 1551| | 1552| 2| atomic_init(&isc__lctx->highest_level, lcfg->highest_level); 1553| 2| atomic_init(&isc__lctx->dynamic, lcfg->dynamic); 1554| | 1555| 2| isc__lctx->logconfig = lcfg; 1556| 2|} log.c:isc_log_doit: 1231| 2| const char *format, va_list args) { 1232| 2| int syslog_level; 1233| 2| const char *time_string; 1234| 2| char local_time[64] = { 0 }; 1235| 2| char iso8601z_string[64] = { 0 }; 1236| 2| char iso8601l_string[64] = { 0 }; 1237| 2| char iso8601tz_string[64] = { 0 }; 1238| 2| char level_string[24] = { 0 }; 1239| 2| struct stat statbuf; 1240| 2| bool matched = false; 1241| 2| bool printtime, iso8601, utc, tzinfo, printtag, printcolon; 1242| 2| bool printcategory, printmodule, printlevel, buffered; 1243| 2| isc_logchannel_t *channel; 1244| 2| isc_logchannellist_t *category_channels; 1245| 2| int_fast32_t dlevel; 1246| 2| isc_result_t result; 1247| | 1248| 2| REQUIRE(isc__lctx == NULL || VALID_CONTEXT(isc__lctx)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 0, False: 2] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1249| 2| REQUIRE(category > ISC_LOGCATEGORY_DEFAULT && ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1250| 2| category < ISC_LOGCATEGORY_MAX); 1251| 2| REQUIRE(module > ISC_LOGMODULE_DEFAULT && module < ISC_LOGMODULE_MAX); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1252| 2| REQUIRE(level != ISC_LOG_DYNAMIC); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1253| 2| REQUIRE(format != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1254| | 1255| 2| if (!isc_log_wouldlog(level)) { ------------------ | Branch (1255:6): [True: 0, False: 2] ------------------ 1256| 0| return; 1257| 0| } 1258| | 1259| 2| rcu_read_lock(); 1260| 2| LOCK(&isc__lctx->lock); ------------------ | | 26| 2| { \ | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 2| __FILE__, __LINE__)); \ | | 29| 2| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 2| { \ | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 2| } | | | | ------------------ | | ------------------ | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 2| __FILE__, __LINE__)); \ | | 32| 2| } ------------------ 1261| | 1262| 2| isc__lctx->buffer[0] = '\0'; 1263| | 1264| 2| isc_logconfig_t *lcfg = rcu_dereference(isc__lctx->logconfig); 1265| 2| if (lcfg == NULL) { ------------------ | Branch (1265:6): [True: 0, False: 2] ------------------ 1266| 0| goto unlock; 1267| 0| } 1268| | 1269| 2| category_channels = ISC_LIST_HEAD(lcfg->channellists[category]); ------------------ | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1270| | 1271| 4| do { 1272| | /* 1273| | * If the channel list end was reached and a match was 1274| | * made, everything is finished. 1275| | */ 1276| 4| if (category_channels == NULL && matched) { ------------------ | Branch (1276:7): [True: 4, False: 0] | Branch (1276:36): [True: 2, False: 2] ------------------ 1277| 2| break; 1278| 2| } 1279| | 1280| 2| if (category_channels == NULL && !matched && ------------------ | Branch (1280:7): [True: 2, False: 0] | Branch (1280:36): [True: 2, False: 0] ------------------ 1281| 2| category_channels != ISC_LIST_HEAD(lcfg->channellists[0])) ------------------ | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) ------------------ | Branch (1281:7): [True: 0, False: 2] ------------------ 1282| 0| { 1283| | /* 1284| | * No category/module pair was explicitly 1285| | * configured. Try the category named "default". 1286| | */ 1287| 0| category_channels = 1288| 0| ISC_LIST_HEAD(lcfg->channellists[0]); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1289| 0| } 1290| | 1291| 2| if (category_channels == NULL && !matched) { ------------------ | Branch (1291:7): [True: 2, False: 0] | Branch (1291:36): [True: 2, False: 0] ------------------ 1292| | /* 1293| | * No matching module was explicitly configured 1294| | * for the category named "default". Use the 1295| | * internal default channel. 1296| | */ 1297| 2| category_channels = &default_channel; 1298| 2| } 1299| | 1300| 2| if (category_channels->module != ISC_LOGMODULE_DEFAULT && ------------------ | Branch (1300:7): [True: 0, False: 2] ------------------ 1301| 0| category_channels->module != module) ------------------ | Branch (1301:7): [True: 0, False: 0] ------------------ 1302| 0| { 1303| 0| category_channels = ISC_LIST_NEXT(category_channels, ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 1304| 0| link); 1305| 0| continue; 1306| 0| } 1307| | 1308| 2| matched = true; 1309| | 1310| 2| channel = category_channels->channel; 1311| 2| category_channels = ISC_LIST_NEXT(category_channels, link); ------------------ | | 140| 2|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 1312| | 1313| 2| if (!forcelog) { ------------------ | Branch (1313:7): [True: 2, False: 0] ------------------ 1314| 2| dlevel = atomic_load_acquire(&isc__lctx->debug_level); ------------------ | | 50| 2|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 1315| 2| if (((channel->flags & ISC_LOG_DEBUGONLY) != 0) && ------------------ | | 71| 2|#define ISC_LOG_DEBUGONLY 0x01000 ------------------ | Branch (1315:8): [True: 0, False: 2] ------------------ 1316| 0| dlevel == 0) ------------------ | Branch (1316:8): [True: 0, False: 0] ------------------ 1317| 0| { 1318| 0| continue; 1319| 0| } 1320| | 1321| 2| if (channel->level == ISC_LOG_DYNAMIC) { ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ | Branch (1321:8): [True: 0, False: 2] ------------------ 1322| 0| if (dlevel < level) { ------------------ | Branch (1322:9): [True: 0, False: 0] ------------------ 1323| 0| continue; 1324| 0| } 1325| 2| } else if (channel->level < level) { ------------------ | Branch (1325:15): [True: 0, False: 2] ------------------ 1326| 0| continue; 1327| 0| } 1328| 2| } 1329| | 1330| 2| if ((channel->flags & ISC_LOG_PRINTTIME) != 0 && ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ | Branch (1330:7): [True: 2, False: 0] ------------------ 1331| 2| local_time[0] == '\0') ------------------ | Branch (1331:7): [True: 2, False: 0] ------------------ 1332| 2| { 1333| 2| isc_time_t isctime; 1334| | 1335| 2| isctime = isc_time_now(); 1336| | 1337| 2| isc_time_formattimestamp(&isctime, local_time, 1338| 2| sizeof(local_time)); 1339| 2| isc_time_formatISO8601ms(&isctime, iso8601z_string, 1340| 2| sizeof(iso8601z_string)); 1341| 2| isc_time_formatISO8601Lms(&isctime, iso8601l_string, 1342| 2| sizeof(iso8601l_string)); 1343| 2| isc_time_formatISO8601TZms(&isctime, iso8601tz_string, 1344| 2| sizeof(iso8601tz_string)); 1345| 2| } 1346| | 1347| 2| if ((channel->flags & ISC_LOG_PRINTLEVEL) != 0 && ------------------ | | 64| 2|#define ISC_LOG_PRINTLEVEL 0x00002 ------------------ | Branch (1347:7): [True: 0, False: 2] ------------------ 1348| 0| level_string[0] == '\0') ------------------ | Branch (1348:7): [True: 0, False: 0] ------------------ 1349| 0| { 1350| 0| if (level < ISC_LOG_CRITICAL) { ------------------ | | 46| 0|#define ISC_LOG_CRITICAL (-5) ------------------ | Branch (1350:8): [True: 0, False: 0] ------------------ 1351| 0| snprintf(level_string, sizeof(level_string), 1352| 0| "level %d: ", level); 1353| 0| } else if (level > ISC_LOG_DYNAMIC) { ------------------ | | 41| 0|#define ISC_LOG_DYNAMIC 0 ------------------ | Branch (1353:15): [True: 0, False: 0] ------------------ 1354| 0| snprintf(level_string, sizeof(level_string), 1355| 0| "%s %d: ", log_level_strings[0], 1356| 0| level); 1357| 0| } else { 1358| 0| snprintf(level_string, sizeof(level_string), 1359| 0| "%s: ", log_level_strings[-level]); 1360| 0| } 1361| 0| } 1362| | 1363| | /* 1364| | * Only format the message once. 1365| | */ 1366| 2| if (isc__lctx->buffer[0] == '\0') { ------------------ | Branch (1366:7): [True: 2, False: 0] ------------------ 1367| 2| (void)vsnprintf(isc__lctx->buffer, 1368| 2| sizeof(isc__lctx->buffer), format, 1369| 2| args); 1370| 2| } 1371| | 1372| 2| utc = ((channel->flags & ISC_LOG_UTC) != 0); ------------------ | | 74| 2|#define ISC_LOG_UTC 0x20000 /* if PRINTTIME, use UTC */ ------------------ 1373| 2| tzinfo = ((channel->flags & ISC_LOG_TZINFO) != 0); ------------------ | | 75| 2|#define ISC_LOG_TZINFO 0x40000 /* if PRINTTIME, output TZ info */ ------------------ 1374| 2| iso8601 = ((channel->flags & ISC_LOG_ISO8601) != 0); ------------------ | | 73| 2|#define ISC_LOG_ISO8601 0x10000 /* if PRINTTIME, use ISO8601 */ ------------------ 1375| 2| printtime = ((channel->flags & ISC_LOG_PRINTTIME) != 0); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 1376| 2| printtag = ((channel->flags & ------------------ | Branch (1376:15): [True: 0, False: 2] ------------------ 1377| 2| (ISC_LOG_PRINTTAG | ISC_LOG_PRINTPREFIX)) != 0 && ------------------ | | 67| 2|#define ISC_LOG_PRINTTAG 0x00010 /* tag and ":" */ ------------------ (ISC_LOG_PRINTTAG | ISC_LOG_PRINTPREFIX)) != 0 && ------------------ | | 68| 2|#define ISC_LOG_PRINTPREFIX 0x00020 /* tag only, no colon */ ------------------ 1378| 0| lcfg->tag != NULL); ------------------ | Branch (1378:8): [True: 0, False: 0] ------------------ 1379| 2| printcolon = ((channel->flags & ISC_LOG_PRINTTAG) != 0 && ------------------ | | 67| 2|#define ISC_LOG_PRINTTAG 0x00010 /* tag and ":" */ ------------------ | Branch (1379:17): [True: 0, False: 2] ------------------ 1380| 0| lcfg->tag != NULL); ------------------ | Branch (1380:10): [True: 0, False: 0] ------------------ 1381| 2| printcategory = ((channel->flags & ISC_LOG_PRINTCATEGORY) != 0); ------------------ | | 65| 2|#define ISC_LOG_PRINTCATEGORY 0x00004 ------------------ 1382| 2| printmodule = ((channel->flags & ISC_LOG_PRINTMODULE) != 0); ------------------ | | 66| 2|#define ISC_LOG_PRINTMODULE 0x00008 ------------------ 1383| 2| printlevel = ((channel->flags & ISC_LOG_PRINTLEVEL) != 0); ------------------ | | 64| 2|#define ISC_LOG_PRINTLEVEL 0x00002 ------------------ 1384| 2| buffered = ((channel->flags & ISC_LOG_BUFFERED) != 0); ------------------ | | 70| 2|#define ISC_LOG_BUFFERED 0x00040 ------------------ 1385| | 1386| 2| if (printtime) { ------------------ | Branch (1386:7): [True: 2, False: 0] ------------------ 1387| 2| if (iso8601) { ------------------ | Branch (1387:8): [True: 0, False: 2] ------------------ 1388| 0| if (utc) { ------------------ | Branch (1388:9): [True: 0, False: 0] ------------------ 1389| 0| time_string = iso8601z_string; 1390| 0| } else if (tzinfo) { ------------------ | Branch (1390:16): [True: 0, False: 0] ------------------ 1391| 0| time_string = iso8601tz_string; 1392| 0| } else { 1393| 0| time_string = iso8601l_string; 1394| 0| } 1395| 2| } else { 1396| 2| time_string = local_time; 1397| 2| } 1398| 2| } else { 1399| 0| time_string = ""; 1400| 0| } 1401| | 1402| 2| switch (channel->type) { ------------------ | Branch (1402:11): [True: 2, False: 0] ------------------ 1403| 0| case ISC_LOG_TOFILE: ------------------ | | 55| 0|#define ISC_LOG_TOFILE 3 ------------------ | Branch (1403:3): [True: 0, False: 2] ------------------ 1404| 0| if (FILE_MAXREACHED(channel)) { ------------------ | | 320| 0|#define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached) | | ------------------ | | | Branch (320:34): [True: 0, False: 0] | | ------------------ ------------------ 1405| | /* 1406| | * If the file can be rolled, OR 1407| | * If the file no longer exists, OR 1408| | * If the file is less than the maximum 1409| | * size, (such as if it had been renamed 1410| | * and a new one touched, or it was 1411| | * truncated in place) 1412| | * ... then close it to trigger 1413| | * reopening. 1414| | */ 1415| 0| if (FILE_VERSIONS(channel) != ------------------ | | 317| 0|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ | Branch (1415:9): [True: 0, False: 0] ------------------ 1416| 0| ISC_LOG_ROLLNEVER || ------------------ | | 87| 0|#define ISC_LOG_ROLLNEVER (-2) ------------------ 1417| 0| (stat(FILE_NAME(channel), &statbuf) != 0 && ------------------ | | 315| 0|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ | Branch (1417:10): [True: 0, False: 0] ------------------ 1418| 0| errno == ENOENT) || ------------------ | Branch (1418:10): [True: 0, False: 0] ------------------ 1419| 0| statbuf.st_size < FILE_MAXSIZE(channel)) ------------------ | | 319| 0|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ | Branch (1419:9): [True: 0, False: 0] ------------------ 1420| 0| { 1421| 0| if (FILE_STREAM(channel) != NULL) { ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ | Branch (1421:10): [True: 0, False: 0] ------------------ 1422| 0| (void)fclose( 1423| 0| FILE_STREAM(channel)); ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 1424| 0| FILE_STREAM(channel) = NULL; ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 1425| 0| } 1426| 0| FILE_MAXREACHED(channel) = false; ------------------ | | 320| 0|#define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached) ------------------ 1427| 0| } else { 1428| | /* 1429| | * Eh, skip it. 1430| | */ 1431| 0| break; 1432| 0| } 1433| 0| } 1434| | 1435| 0| if (FILE_STREAM(channel) == NULL) { ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ | Branch (1435:8): [True: 0, False: 0] ------------------ 1436| 0| result = isc_log_open(channel); 1437| 0| if (result != ISC_R_SUCCESS && ------------------ | Branch (1437:9): [True: 0, False: 0] ------------------ 1438| 0| result != ISC_R_MAXSIZE && ------------------ | Branch (1438:9): [True: 0, False: 0] ------------------ 1439| 0| (channel->flags & ISC_LOG_OPENERR) == 0) ------------------ | | 72| 0|#define ISC_LOG_OPENERR 0x08000 /* internal */ ------------------ | Branch (1439:9): [True: 0, False: 0] ------------------ 1440| 0| { 1441| 0| syslog(LOG_ERR, 1442| 0| "isc_log_open '%s' " 1443| 0| "failed: %s", 1444| 0| FILE_NAME(channel), ------------------ | | 315| 0|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ 1445| 0| isc_result_totext(result)); 1446| 0| channel->flags |= ISC_LOG_OPENERR; ------------------ | | 72| 0|#define ISC_LOG_OPENERR 0x08000 /* internal */ ------------------ 1447| 0| } 1448| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1448:9): [True: 0, False: 0] ------------------ 1449| 0| break; 1450| 0| } 1451| 0| channel->flags &= ~ISC_LOG_OPENERR; ------------------ | | 72| 0|#define ISC_LOG_OPENERR 0x08000 /* internal */ ------------------ 1452| 0| } 1453| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 1454| | 1455| 2| case ISC_LOG_TOFILEDESC: ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ | Branch (1455:3): [True: 2, False: 0] ------------------ 1456| 2| fprintf(FILE_STREAM(channel), "%s%s%s%s%s%s%s%s%s%s\n", ------------------ | | 316| 2|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 1457| 2| printtime ? time_string : "", ------------------ | Branch (1457:5): [True: 2, False: 0] ------------------ 1458| 2| printtime ? " " : "", printtag ? lcfg->tag : "", ------------------ | Branch (1458:5): [True: 2, False: 0] | Branch (1458:27): [True: 0, False: 2] ------------------ 1459| 2| printcolon ? ": " : "", ------------------ | Branch (1459:5): [True: 0, False: 2] ------------------ 1460| 2| printcategory ? categories_description[category] ------------------ | Branch (1460:5): [True: 0, False: 2] ------------------ 1461| 2| : "", 1462| 2| printcategory ? ": " : "", ------------------ | Branch (1462:5): [True: 0, False: 2] ------------------ 1463| 2| printmodule ? modules_description[module] : "", ------------------ | Branch (1463:5): [True: 0, False: 2] ------------------ 1464| 2| printmodule ? ": " : "", ------------------ | Branch (1464:5): [True: 0, False: 2] ------------------ 1465| 2| printlevel ? level_string : "", ------------------ | Branch (1465:5): [True: 0, False: 2] ------------------ 1466| 2| isc__lctx->buffer); 1467| | 1468| 2| if (!buffered) { ------------------ | Branch (1468:8): [True: 2, False: 0] ------------------ 1469| 2| fflush(FILE_STREAM(channel)); ------------------ | | 316| 2|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 1470| 2| } 1471| | 1472| | /* 1473| | * If the file now exceeds its maximum size 1474| | * threshold, note it so that it will not be 1475| | * logged to any more. 1476| | */ 1477| 2| if (FILE_MAXSIZE(channel) > 0) { ------------------ | | 319| 2|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ | Branch (1477:8): [True: 0, False: 2] ------------------ 1478| 0| INSIST(channel->type == ISC_LOG_TOFILE); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1479| | 1480| | /* XXXDCL NT fstat/fileno */ 1481| | /* XXXDCL complain if fstat fails? */ 1482| 0| if (fstat(fileno(FILE_STREAM(channel)), ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ | Branch (1482:9): [True: 0, False: 0] ------------------ 1483| 0| &statbuf) >= 0 && 1484| 0| statbuf.st_size > FILE_MAXSIZE(channel)) ------------------ | | 319| 0|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ | Branch (1484:9): [True: 0, False: 0] ------------------ 1485| 0| { 1486| 0| FILE_MAXREACHED(channel) = true; ------------------ | | 320| 0|#define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached) ------------------ 1487| 0| } 1488| 0| } 1489| | 1490| 2| break; 1491| | 1492| 0| case ISC_LOG_TOSYSLOG: ------------------ | | 54| 0|#define ISC_LOG_TOSYSLOG 2 ------------------ | Branch (1492:3): [True: 0, False: 2] ------------------ 1493| 0| if (level > 0) { ------------------ | Branch (1493:8): [True: 0, False: 0] ------------------ 1494| 0| syslog_level = LOG_DEBUG; 1495| 0| } else if (level < ISC_LOG_CRITICAL) { ------------------ | | 46| 0|#define ISC_LOG_CRITICAL (-5) ------------------ | Branch (1495:15): [True: 0, False: 0] ------------------ 1496| 0| syslog_level = LOG_CRIT; 1497| 0| } else { 1498| 0| syslog_level = syslog_map[-level]; 1499| 0| } 1500| | 1501| 0| (void)syslog( 1502| 0| FACILITY(channel) | syslog_level, ------------------ | | 314| 0|#define FACILITY(channel) (channel->destination.facility) ------------------ 1503| 0| "%s%s%s%s%s%s%s%s%s%s", 1504| 0| printtime ? time_string : "", ------------------ | Branch (1504:5): [True: 0, False: 0] ------------------ 1505| 0| printtime ? " " : "", printtag ? lcfg->tag : "", ------------------ | Branch (1505:5): [True: 0, False: 0] | Branch (1505:27): [True: 0, False: 0] ------------------ 1506| 0| printcolon ? ": " : "", ------------------ | Branch (1506:5): [True: 0, False: 0] ------------------ 1507| 0| printcategory ? categories_description[category] ------------------ | Branch (1507:5): [True: 0, False: 0] ------------------ 1508| 0| : "", 1509| 0| printcategory ? ": " : "", ------------------ | Branch (1509:5): [True: 0, False: 0] ------------------ 1510| 0| printmodule ? modules_description[module] : "", ------------------ | Branch (1510:5): [True: 0, False: 0] ------------------ 1511| 0| printmodule ? ": " : "", ------------------ | Branch (1511:5): [True: 0, False: 0] ------------------ 1512| 0| printlevel ? level_string : "", ------------------ | Branch (1512:5): [True: 0, False: 0] ------------------ 1513| 0| isc__lctx->buffer); 1514| 0| break; 1515| | 1516| 0| case ISC_LOG_TONULL: ------------------ | | 53| 0|#define ISC_LOG_TONULL 1 ------------------ | Branch (1516:3): [True: 0, False: 2] ------------------ 1517| 0| break; 1518| 2| } 1519| 2| } while (1); ------------------ | Branch (1519:11): [True: 2, Folded] ------------------ 1520| | 1521| 2|unlock: 1522| 2| UNLOCK(&isc__lctx->lock); ------------------ | | 34| 2| { \ | | 35| 2| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 2| { \ | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 2| } | | | | ------------------ | | ------------------ | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 2| __FILE__, __LINE__)); \ | | 38| 2| } ------------------ 1523| | rcu_read_unlock(); 1524| 2|} isc_loopmgr_create: 370| 2|isc_loopmgr_create(isc_mem_t *mctx, uint32_t nloops) { 371| 2| REQUIRE(isc__loopmgr == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 372| 2| REQUIRE(nloops > 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 373| | 374| 2| isc_loopmgr_t *loopmgr = NULL; 375| | 376| 2| threadpool_initialize(nloops); 377| 2| isc__tid_initcount(nloops); 378| | 379| 2| loopmgr = isc_mem_get(mctx, sizeof(*loopmgr)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 380| 2| *loopmgr = (isc_loopmgr_t){ 381| 2| .nloops = nloops, 382| 2| .magic = LOOPMGR_MAGIC, ------------------ | | 81| 2|#define LOOPMGR_MAGIC ISC_MAGIC('L', 'o', 'o', 'M') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 383| 2| }; 384| | 385| 2| isc_mem_attach(mctx, &loopmgr->mctx); 386| | 387| | /* We need to double the number for loops and helpers */ 388| 2| isc_barrier_init(&loopmgr->pausing, loopmgr->nloops * 2); ------------------ | | 80| 2|#define isc_barrier_init(bp, count) isc__barrier_init(bp, count) | | ------------------ | | | | 29| 2| { \ | | | | 30| 2| int _ret = pthread_barrier_init(bp, NULL, count); \ | | | | 31| 2| PTHREADS_RUNTIME_CHECK(pthread_barrier_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 389| 2| isc_barrier_init(&loopmgr->resuming, loopmgr->nloops * 2); ------------------ | | 80| 2|#define isc_barrier_init(bp, count) isc__barrier_init(bp, count) | | ------------------ | | | | 29| 2| { \ | | | | 30| 2| int _ret = pthread_barrier_init(bp, NULL, count); \ | | | | 31| 2| PTHREADS_RUNTIME_CHECK(pthread_barrier_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 390| 2| isc_barrier_init(&loopmgr->starting, loopmgr->nloops * 2); ------------------ | | 80| 2|#define isc_barrier_init(bp, count) isc__barrier_init(bp, count) | | ------------------ | | | | 29| 2| { \ | | | | 30| 2| int _ret = pthread_barrier_init(bp, NULL, count); \ | | | | 31| 2| PTHREADS_RUNTIME_CHECK(pthread_barrier_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 391| 2| isc_barrier_init(&loopmgr->stopping, loopmgr->nloops * 2); ------------------ | | 80| 2|#define isc_barrier_init(bp, count) isc__barrier_init(bp, count) | | ------------------ | | | | 29| 2| { \ | | | | 30| 2| int _ret = pthread_barrier_init(bp, NULL, count); \ | | | | 31| 2| PTHREADS_RUNTIME_CHECK(pthread_barrier_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 392| | 393| 2| loopmgr->loops = isc_mem_cget(loopmgr->mctx, loopmgr->nloops, ------------------ | | 130| 2| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 2| ({ \ | | | | 33| 2| typeof(a) _c; \ | | | | 34| 2| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 2| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 131| 2| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 2|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 394| 2| sizeof(loopmgr->loops[0])); 395| 4| for (size_t i = 0; i < loopmgr->nloops; i++) { ------------------ | Branch (395:21): [True: 2, False: 2] ------------------ 396| 2| isc_loop_t *loop = &loopmgr->loops[i]; 397| 2| loop_init(loop, i, "loop"); 398| 2| } 399| | 400| 2| loopmgr->helpers = isc_mem_cget(loopmgr->mctx, loopmgr->nloops, ------------------ | | 130| 2| isc__mem_get((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 2| ({ \ | | | | 33| 2| typeof(a) _c; \ | | | | 34| 2| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 2| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 131| 2| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 2|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 401| 2| sizeof(loopmgr->helpers[0])); 402| 4| for (size_t i = 0; i < loopmgr->nloops; i++) { ------------------ | Branch (402:21): [True: 2, False: 2] ------------------ 403| 2| isc_loop_t *loop = &loopmgr->helpers[i]; 404| 2| loop_init(loop, i, "helper"); 405| 2| } 406| | 407| 2| isc__loopmgr = loopmgr; 408| | 409| 2| loopmgr->sigint = isc_signal_new(isc__loopmgr_signal, loopmgr, SIGINT); 410| 2| loopmgr->sigterm = isc_signal_new(isc__loopmgr_signal, loopmgr, 411| 2| SIGTERM); 412| | 413| 2| isc_signal_start(loopmgr->sigint); 414| 2| isc_signal_start(loopmgr->sigterm); 415| 2|} isc_loop_getmctx: 635| 4|isc_loop_getmctx(isc_loop_t *loop) { 636| 4| REQUIRE(VALID_LOOP(loop)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 637| | 638| 4| return loop->mctx; 639| 4|} isc_loop_main: 642| 4|isc_loop_main(void) { 643| 4| REQUIRE(VALID_LOOPMGR(isc__loopmgr)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 644| | 645| 4| return DEFAULT_LOOP(isc__loopmgr); ------------------ | | 145| 4|#define DEFAULT_LOOP(loopmgr) (&(loopmgr)->loops[0]) ------------------ 646| 4|} loop.c:threadpool_initialize: 347| 2|threadpool_initialize(uint32_t workers) { 348| 2| char buf[11]; 349| 2| int r = uv_os_getenv("UV_THREADPOOL_SIZE", buf, 350| 2| &(size_t){ sizeof(buf) }); 351| 2| if (r == UV_ENOENT) { ------------------ | Branch (351:6): [True: 1, False: 1] ------------------ 352| | snprintf(buf, sizeof(buf), "%" PRIu32, workers); 353| 1| uv_os_setenv("UV_THREADPOOL_SIZE", buf); 354| 1| } 355| 2|} loop.c:loop_init: 192| 4|loop_init(isc_loop_t *loop, isc_tid_t tid, const char *kind) { 193| 4| *loop = (isc_loop_t){ 194| 4| .tid = tid, 195| 4| .run_jobs = ISC_LIST_INITIALIZER, ------------------ | | 21| 4| { \ | | 22| 4| .head = NULL, \ | | 23| 4| .tail = NULL, \ | | 24| 4| } ------------------ 196| 4| }; 197| | 198| 4| __cds_wfcq_init(&loop->async_jobs.head, &loop->async_jobs.tail); 199| 4| __cds_wfcq_init(&loop->setup_jobs.head, &loop->setup_jobs.tail); 200| 4| __cds_wfcq_init(&loop->teardown_jobs.head, &loop->teardown_jobs.tail); 201| | 202| 4| int r = uv_loop_init(&loop->loop); 203| 4| UV_RUNTIME_CHECK(uv_loop_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 204| | 205| 4| r = uv_async_init(&loop->loop, &loop->pause_trigger, pauseresume_cb); 206| 4| UV_RUNTIME_CHECK(uv_async_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 207| 4| uv_handle_set_data(&loop->pause_trigger, loop); ------------------ | | 71| 4| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 208| | 209| 4| r = uv_async_init(&loop->loop, &loop->shutdown_trigger, shutdown_cb); 210| 4| UV_RUNTIME_CHECK(uv_async_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 211| 4| uv_handle_set_data(&loop->shutdown_trigger, loop); ------------------ | | 71| 4| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 212| | 213| 4| r = uv_async_init(&loop->loop, &loop->async_trigger, isc__async_cb); 214| 4| UV_RUNTIME_CHECK(uv_async_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 215| 4| uv_handle_set_data(&loop->async_trigger, loop); ------------------ | | 71| 4| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 216| | 217| 4| r = uv_idle_init(&loop->loop, &loop->run_trigger); 218| 4| UV_RUNTIME_CHECK(uv_idle_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 219| 4| uv_handle_set_data(&loop->run_trigger, loop); ------------------ | | 71| 4| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 220| | 221| 4| r = uv_async_init(&loop->loop, &loop->destroy_trigger, destroy_cb); 222| 4| UV_RUNTIME_CHECK(uv_async_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 223| 4| uv_handle_set_data(&loop->destroy_trigger, loop); ------------------ | | 71| 4| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 224| | 225| 4| r = uv_prepare_init(&loop->loop, &loop->quiescent); 226| 4| UV_RUNTIME_CHECK(uv_prepare_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 227| 4| uv_handle_set_data(&loop->quiescent, loop); ------------------ | | 71| 4| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 228| | 229| 4| isc_mem_create(kind, &loop->mctx); ------------------ | | 200| 4|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 230| | 231| 4| isc_refcount_init(&loop->references, 1); ------------------ | | 44| 4|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 232| | 233| 4| loop->magic = LOOP_MAGIC; ------------------ | | 38| 4|#define LOOP_MAGIC ISC_MAGIC('L', 'O', 'O', 'P') | | ------------------ | | | | 31| 4|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 234| 4|} isc_md_new: 27| 2|isc_md_new(void) { 28| 2| isc_md_t *md = EVP_MD_CTX_new(); 29| 2| RUNTIME_CHECK(md != NULL); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 30| 2| return md; 31| 2|} isc_md_free: 34| 2|isc_md_free(isc_md_t *md) { 35| 2| if (md == NULL) { ------------------ | Branch (35:6): [True: 0, False: 2] ------------------ 36| 0| return; 37| 0| } 38| | 39| 2| EVP_MD_CTX_free(md); 40| 2|} isc_md_init: 43| 2|isc_md_init(isc_md_t *md, isc_md_type_t type) { 44| 2| EVP_MD *evp; 45| | 46| 2| REQUIRE(md != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 47| 2| REQUIRE(type < ISC_MD_MAX); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 48| | 49| 2| evp = isc__crypto_md[type]; 50| 2| if (evp == NULL) { ------------------ | Branch (50:6): [True: 0, False: 2] ------------------ 51| 0| return ISC_R_NOTIMPLEMENTED; 52| 0| } 53| | 54| 2| if (EVP_DigestInit_ex(md, evp, NULL) != 1) { ------------------ | Branch (54:6): [True: 0, False: 2] ------------------ 55| 0| ERR_clear_error(); 56| 0| return ISC_R_CRYPTOFAILURE; 57| 0| } 58| | 59| 2| return ISC_R_SUCCESS; 60| 2|} isc_md_update: 75| 2|isc_md_update(isc_md_t *md, const unsigned char *buf, const size_t len) { 76| 2| REQUIRE(md != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 77| | 78| 2| if (buf == NULL || len == 0) { ------------------ | Branch (78:6): [True: 0, False: 2] | Branch (78:21): [True: 0, False: 2] ------------------ 79| 0| return ISC_R_SUCCESS; 80| 0| } 81| | 82| 2| if (EVP_DigestUpdate(md, buf, len) != 1) { ------------------ | Branch (82:6): [True: 0, False: 2] ------------------ 83| 0| ERR_clear_error(); 84| 0| return ISC_R_CRYPTOFAILURE; 85| 0| } 86| | 87| 2| return ISC_R_SUCCESS; 88| 2|} isc_md_final: 91| 2|isc_md_final(isc_md_t *md, unsigned char *digest, unsigned int *digestlen) { 92| 2| REQUIRE(md != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 93| 2| REQUIRE(digest != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 94| | 95| 2| if (EVP_DigestFinal_ex(md, digest, digestlen) != 1) { ------------------ | Branch (95:6): [True: 0, False: 2] ------------------ 96| 0| ERR_clear_error(); 97| 0| return ISC_R_CRYPTOFAILURE; 98| 0| } 99| | 100| 2| return ISC_R_SUCCESS; 101| 2|} isc_md: 136| 2| unsigned char *digest, unsigned int *digestlen) { 137| 2| isc_md_t *md; 138| 2| isc_result_t res; 139| | 140| 2| md = isc_md_new(); 141| | 142| 2| res = isc_md_init(md, type); 143| 2| if (res != ISC_R_SUCCESS) { ------------------ | Branch (143:6): [True: 0, False: 2] ------------------ 144| 0| goto end; 145| 0| } 146| | 147| 2| res = isc_md_update(md, buf, len); 148| 2| if (res != ISC_R_SUCCESS) { ------------------ | Branch (148:6): [True: 0, False: 2] ------------------ 149| 0| goto end; 150| 0| } 151| | 152| 2| res = isc_md_final(md, digest, digestlen); 153| 2| if (res != ISC_R_SUCCESS) { ------------------ | Branch (153:6): [True: 0, False: 2] ------------------ 154| 0| goto end; 155| 0| } 156| 2|end: 157| 2| isc_md_free(md); 158| | 159| 2| return res; 160| 2|} isc__mem_initialize: 505| 2|isc__mem_initialize(void) { 506| |/* 507| | * Check if the values copied from jemalloc still match 508| | */ 509| |#ifdef JEMALLOC_API_SUPPORTED 510| | RUNTIME_CHECK(ISC__MEM_ZERO == MALLOCX_ZERO); 511| | 512| | /* 513| | * ignore errors — volumetric-based purge in mem_put handles the rest 514| | * regardless 515| | */ 516| | 517| | (void)mallctl("background_thread", NULL, NULL, &(bool){ true }, 518| | sizeof(bool)); 519| | 520| | (void)mallctl("arenas.dirty_decay_ms", NULL, NULL, 521| | &default_dirty_decay_ms, sizeof(default_dirty_decay_ms)); 522| | 523| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".dirty_decay_ms", 524| | NULL, NULL, &default_dirty_decay_ms, 525| | sizeof(default_dirty_decay_ms)); 526| | 527| |#endif /* JEMALLOC_API_SUPPORTED */ 528| | 529| 2| isc_mutex_init(&contextslock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 530| 2| ISC_LIST_INIT(contexts); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 531| | 532| 2| if (debugging_enabled("ISC_MEM_DEBUGTRACE")) { ------------------ | Branch (532:6): [True: 0, False: 2] ------------------ 533| 0| mem_debugging |= ISC_MEM_DEBUGTRACE; ------------------ | | 39| 0|#define ISC_MEM_DEBUGTRACE 0x00000001U ------------------ 534| 0| } 535| | 536| 2| if (debugging_enabled("ISC_MEM_DEBUGRECORD")) { ------------------ | Branch (536:6): [True: 0, False: 2] ------------------ 537| 0| mem_debugging |= ISC_MEM_DEBUGRECORD; ------------------ | | 40| 0|#define ISC_MEM_DEBUGRECORD 0x00000002U ------------------ 538| 0| } 539| | 540| 2| if (debugging_enabled("ISC_MEM_DEBUGUSAGE")) { ------------------ | Branch (540:6): [True: 0, False: 2] ------------------ 541| 0| mem_debugging |= ISC_MEM_DEBUGUSAGE; ------------------ | | 41| 0|#define ISC_MEM_DEBUGUSAGE 0x00000004U ------------------ 542| 0| } 543| | 544| 2| isc_mem_create("default", &isc_g_mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 545| 2|} isc_mem_setdebugging: 567| 4|isc_mem_setdebugging(isc_mem_t *ctx, unsigned int debugging) { 568| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 569| 4| REQUIRE(isc_mem_inuse(ctx) == 0); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 570| | 571| 4| ctx->debugging = debugging; 572| 4|} isc__mem_putanddetach: 730| 5.27k| int flags FLARG) { 731| 5.27k| REQUIRE(ctxp != NULL && VALID_CONTEXT(*ctxp)); ------------------ | | 194| 5.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 21.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.27k, False: 0] | | | | | Branch (42:11): [True: 5.27k, False: 0] | | | | | Branch (42:11): [True: 5.27k, False: 0] | | | | ------------------ | | | | 43| 5.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 5.27k| REQUIRE(ptr != NULL); ------------------ | | 194| 5.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.27k, False: 0] | | | | ------------------ | | | | 43| 5.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| 5.27k| REQUIRE(size != 0); ------------------ | | 194| 5.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.27k, False: 0] | | | | ------------------ | | | | 43| 5.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 734| | 735| 5.27k| isc_mem_t *ctx = *ctxp; 736| 5.27k| *ctxp = NULL; 737| | 738| 5.27k| isc__mem_put(ctx, ptr, size, flags FLARG_PASS); 739| |#if ISC_MEM_TRACE 740| | isc_mem__detach(&ctx, func, file, line); 741| |#else 742| 5.27k| isc_mem_detach(&ctx); 743| 5.27k|#endif 744| 5.27k|} isc__mem_get: 747| 10.9k|isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) { 748| 10.9k| void *ptr = NULL; 749| | 750| 10.9k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 10.9k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 21.9k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10.9k, False: 0] | | | | | Branch (42:11): [True: 10.9k, False: 0] | | | | ------------------ | | | | 43| 10.9k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 751| | 752| 10.9k| ptr = mem_get(ctx, size, flags); 753| | 754| 10.9k| mem_getstats(ctx, size); 755| 10.9k| ADD_TRACE(ctx, ptr, size, func, file, line); 756| | 757| 10.9k| return ptr; 758| 10.9k|} isc__mem_put: 761| 10.8k|isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size, int flags FLARG) { 762| 10.8k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 10.8k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 21.6k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10.8k, False: 0] | | | | | Branch (42:11): [True: 10.8k, False: 0] | | | | ------------------ | | | | 43| 10.8k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 763| | 764| 10.8k| DELETE_TRACE(ctx, ptr, size, func, file, line); 765| | 766| 10.8k| mem_putstats(ctx, size); 767| 10.8k| mem_put(ctx, ptr, size, flags); 768| 10.8k|} isc__mem_allocate: 839| 68|isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) { 840| 68| void *ptr = NULL; 841| | 842| 68| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 68|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 136| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 68, False: 0] | | | | | Branch (42:11): [True: 68, False: 0] | | | | ------------------ | | | | 43| 68| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 843| | 844| 68| ptr = mem_get(ctx, size, flags); 845| | 846| | /* Recalculate the real allocated size */ 847| 68| size = sallocx(ptr, flags | ctx->jemalloc_flags); 848| | 849| 68| mem_getstats(ctx, size); 850| 68| ADD_TRACE(ctx, ptr, size, func, file, line); 851| | 852| 68| return ptr; 853| 68|} isc__mem_reallocate: 900| 16| int flags FLARG) { 901| 16| void *new_ptr = NULL; 902| | 903| 16| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 16, False: 0] | | | | | Branch (42:11): [True: 16, False: 0] | | | | ------------------ | | | | 43| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 904| | 905| 16| if (old_ptr == NULL) { ------------------ | Branch (905:6): [True: 16, False: 0] ------------------ 906| 16| new_ptr = isc__mem_allocate(ctx, new_size, flags FLARG_PASS); 907| 16| } else if (new_size == 0) { ------------------ | Branch (907:13): [True: 0, False: 0] ------------------ 908| 0| isc__mem_free(ctx, old_ptr, flags FLARG_PASS); 909| 0| } else { 910| 0| size_t size = sallocx(old_ptr, flags | ctx->jemalloc_flags); 911| | 912| 0| DELETE_TRACE(ctx, old_ptr, size, func, file, line); 913| 0| mem_putstats(ctx, size); 914| | 915| 0| new_ptr = mem_realloc(ctx, old_ptr, new_size, flags); 916| | 917| | /* Recalculate the real allocated size */ 918| 0| size = sallocx(new_ptr, flags | ctx->jemalloc_flags); 919| | 920| 0| mem_getstats(ctx, size); 921| 0| ADD_TRACE(ctx, new_ptr, size, func, file, line); 922| 0| } 923| | 924| 16| return new_ptr; 925| 16|} isc__mem_free: 928| 14|isc__mem_free(isc_mem_t *ctx, void *ptr, int flags FLARG) { 929| 14| size_t size = 0; 930| | 931| 14| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 14, False: 0] | | | | | Branch (42:11): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 932| 14| REQUIRE(ptr != NULL); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 933| | 934| 14| size = sallocx(ptr, flags | ctx->jemalloc_flags); 935| | 936| 14| DELETE_TRACE(ctx, ptr, size, func, file, line); 937| | 938| 14| mem_putstats(ctx, size); 939| 14| mem_put(ctx, ptr, size, flags); 940| 14|} isc__mem_strdup: 947| 40|isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) { 948| 40| size_t len; 949| 40| char *ns = NULL; 950| | 951| 40| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 194| 40|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 80| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 40, False: 0] | | | | | Branch (42:11): [True: 40, False: 0] | | | | ------------------ | | | | 43| 40| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 952| 40| REQUIRE(s != NULL); ------------------ | | 194| 40|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 40| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 40, False: 0] | | | | ------------------ | | | | 43| 40| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 953| | 954| 40| len = strlen(s) + 1; 955| | 956| 40| ns = isc__mem_allocate(mctx, len, 0 FLARG_PASS); 957| | 958| 40| strlcpy(ns, s, len); 959| | 960| 40| return ns; 961| 40|} isc_mem_setdestroycheck: 985| 2|isc_mem_setdestroycheck(isc_mem_t *ctx, bool flag) { 986| 2| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 987| | 988| 2| MCTXLOCK(ctx); ------------------ | | 66| 2|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ ------------------ 989| | 990| 2| ctx->checkfree = flag; 991| | 992| 2| MCTXUNLOCK(ctx); ------------------ | | 67| 2|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ ------------------ 993| 2|} isc_mem_inuse: 996| 4|isc_mem_inuse(isc_mem_t *ctx) { 997| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 998| | 999| 4| int_fast64_t inuse = 0; 1000| | 1001| 8| for (ssize_t i = -1; i < isc_tid_count(); i++) { ------------------ | Branch (1001:23): [True: 4, False: 4] ------------------ 1002| 4| inuse += atomic_load_relaxed(&ctx->stat[i].inuse); ------------------ | | 28| 4|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 1003| 4| } 1004| 4| INSIST(inuse >= 0); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1005| | 1006| 4| return (size_t)inuse; 1007| 4|} isc__mempool_create: 1072| 3.19k| const char *name, isc_mempool_t **restrict mpctxp FLARG) { 1073| 3.19k| isc_mempool_t *restrict mpctx = NULL; 1074| 3.19k| size_t size = element_size; 1075| | 1076| 3.19k| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1077| 3.19k| REQUIRE(size > 0U); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1078| 3.19k| REQUIRE(mpctxp != NULL && *mpctxp == NULL); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1079| 3.19k| REQUIRE(name != NULL); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1080| | 1081| | /* 1082| | * Mempools are stored as a linked list of element. 1083| | */ 1084| 3.19k| if (size < sizeof(element)) { ------------------ | Branch (1084:6): [True: 0, False: 3.19k] ------------------ 1085| 0| size = sizeof(element); 1086| 0| } 1087| | 1088| | /* 1089| | * Allocate space for this pool, initialize values, and if all 1090| | * works well, attach to the memory context. 1091| | */ 1092| 3.19k| mpctx = isc_mem_get(mctx, sizeof(isc_mempool_t)); ------------------ | | 128| 3.19k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1093| | 1094| 3.19k| *mpctx = (isc_mempool_t){ 1095| 3.19k| .size = size, 1096| 3.19k| .freemax = 1, 1097| 3.19k| .fillcount = 1, 1098| 3.19k| .name = strdup(name), 1099| 3.19k| }; 1100| | 1101| |#if ISC_MEM_TRACKLINES 1102| | if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) { 1103| | fprintf(stderr, 1104| | "create pool %p func %s file %s line %u mctx %p\n", 1105| | mpctx, func, file, line, mctx); 1106| | } 1107| |#endif /* ISC_MEM_TRACKLINES */ 1108| | 1109| 3.19k| isc_mem_attach(mctx, &mpctx->mctx); 1110| 3.19k| mpctx->magic = MEMPOOL_MAGIC; ------------------ | | 158| 3.19k|#define MEMPOOL_MAGIC ISC_MAGIC('M', 'E', 'M', 'p') | | ------------------ | | | | 31| 3.19k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1111| | 1112| 3.19k| *mpctxp = (isc_mempool_t *)mpctx; 1113| | 1114| 3.19k| MCTXLOCK(mctx); ------------------ | | 66| 3.19k|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 3.19k| { \ | | | | 27| 3.19k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 3.19k| __FILE__, __LINE__)); \ | | | | 29| 3.19k| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 3.19k|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 3.19k| { \ | | | | | | | | 86| 3.19k| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 3.19k| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 3.19k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 3.19k] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 3.19k| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 3.19k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 3.19k| __FILE__, __LINE__)); \ | | | | 32| 3.19k| } | | ------------------ ------------------ 1115| 3.19k| ISC_LIST_INITANDAPPEND(mctx->pools, mpctx, link); ------------------ | | 106| 3.19k| __ISC_LIST_APPENDUNSAFE(list, elt, link) | | ------------------ | | | | 88| 3.19k| do { \ | | | | 89| 3.19k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 1.59k, False: 1.59k] | | | | ------------------ | | | | 90| 1.59k| (list).tail->link.next = (elt); \ | | | | 91| 1.59k| } else { \ | | | | 92| 1.59k| (list).head = (elt); \ | | | | 93| 1.59k| } \ | | | | 94| 3.19k| (elt)->link.prev = (list).tail; \ | | | | 95| 3.19k| (elt)->link.next = NULL; \ | | | | 96| 3.19k| (list).tail = (elt); \ | | | | 97| 3.19k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 3.19k] | | | | ------------------ | | ------------------ ------------------ 1116| 3.19k| mctx->poolcnt++; 1117| 3.19k| MCTXUNLOCK(mctx); ------------------ | | 67| 3.19k|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 3.19k| { \ | | | | 35| 3.19k| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 3.19k|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 3.19k| { \ | | | | | | | | 92| 3.19k| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 3.19k| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 3.19k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 3.19k] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 3.19k| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 3.19k| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 3.19k| __FILE__, __LINE__)); \ | | | | 38| 3.19k| } | | ------------------ ------------------ 1118| 3.19k|} isc__mempool_destroy: 1121| 3.19k|isc__mempool_destroy(isc_mempool_t **restrict mpctxp FLARG) { 1122| 3.19k| isc_mempool_t *restrict mpctx = NULL; 1123| 3.19k| isc_mem_t *mctx = NULL; 1124| 3.19k| element *restrict item = NULL; 1125| | 1126| 3.19k| REQUIRE(mpctxp != NULL); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1127| 3.19k| REQUIRE(VALID_MEMPOOL(*mpctxp)); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1128| | 1129| 3.19k| mpctx = *mpctxp; 1130| 3.19k| *mpctxp = NULL; 1131| | 1132| 3.19k| mctx = mpctx->mctx; 1133| | 1134| |#if ISC_MEM_TRACKLINES 1135| | if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) { 1136| | fprintf(stderr, 1137| | "destroy pool %p func %s file %s line %u mctx %p\n", 1138| | mpctx, func, file, line, mctx); 1139| | } 1140| |#endif 1141| | 1142| 3.19k| if (mpctx->allocated > 0) { ------------------ | Branch (1142:6): [True: 0, False: 3.19k] ------------------ 1143| 0| UNEXPECTED_ERROR("mempool %s leaked memory", mpctx->name); ------------------ | | 213| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1144| 0| } 1145| 3.19k| REQUIRE(mpctx->allocated == 0); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1146| | 1147| | /* 1148| | * Return any items on the free list 1149| | */ 1150| 3.25M| while (mpctx->items != NULL) { ------------------ | Branch (1150:9): [True: 3.25M, False: 3.19k] ------------------ 1151| 3.25M| INSIST(mpctx->freecount > 0); ------------------ | | 198| 3.25M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 3.25M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 3.25M, False: 0] | | | | ------------------ | | | | 55| 3.25M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1152| 3.25M| mpctx->freecount--; 1153| | 1154| 3.25M| item = mpctx->items; 1155| 3.25M| mpctx->items = item->next; 1156| | 1157| 3.25M| mem_putstats(mctx, mpctx->size); 1158| 3.25M| mem_put(mctx, item, mpctx->size, 0); 1159| 3.25M| } 1160| | 1161| | /* 1162| | * Remove our linked list entry from the memory context. 1163| | */ 1164| 3.19k| MCTXLOCK(mctx); ------------------ | | 66| 3.19k|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 3.19k| { \ | | | | 27| 3.19k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 3.19k| __FILE__, __LINE__)); \ | | | | 29| 3.19k| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 3.19k|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 3.19k| { \ | | | | | | | | 86| 3.19k| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 3.19k| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 3.19k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 3.19k] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 3.19k| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 3.19k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 3.19k| __FILE__, __LINE__)); \ | | | | 32| 3.19k| } | | ------------------ ------------------ 1165| 3.19k| ISC_LIST_UNLINK(mctx->pools, mpctx, link); ------------------ | | 137| 3.19k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 3.19k| do { \ | | | | 133| 3.19k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 3.19k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 3.19k| do { \ | | | | | | 110| 3.19k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 3.19k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 3.19k| } else { \ | | | | | | 113| 3.19k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 3.19k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 3.19k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 3.19k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 3.19k| } \ | | | | | | 116| 3.19k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 1.59k, False: 1.59k] | | | | | | ------------------ | | | | | | 117| 1.59k| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.59k| } else { \ | | | | | | 119| 1.59k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.59k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.59k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.59k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.59k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.59k| } \ | | | | | | 122| 3.19k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 3.19k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 3.19k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 3.19k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 3.19k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 3.19k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 3.19k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 3.19k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 3.19k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 3.19k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 3.19k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 3.19k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 3.19k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 3.19k] | | | | ------------------ | | ------------------ ------------------ 1166| 3.19k| mctx->poolcnt--; 1167| 3.19k| MCTXUNLOCK(mctx); ------------------ | | 67| 3.19k|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 3.19k| { \ | | | | 35| 3.19k| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 3.19k|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 3.19k| { \ | | | | | | | | 92| 3.19k| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 3.19k| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 3.19k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 3.19k] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 3.19k| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 3.19k| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 3.19k| __FILE__, __LINE__)); \ | | | | 38| 3.19k| } | | ------------------ ------------------ 1168| | 1169| 3.19k| free(mpctx->name); 1170| | 1171| 3.19k| mpctx->magic = 0; 1172| | 1173| | isc_mem_putanddetach(&mpctx->mctx, mpctx, sizeof(isc_mempool_t)); ------------------ | | 161| 3.19k| do { \ | | 162| 3.19k| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 163| 3.19k| (p) = NULL; \ | | 164| 3.19k| } while (0) | | ------------------ | | | Branch (164:11): [Folded, False: 3.19k] | | ------------------ ------------------ 1174| 3.19k|} isc__mempool_get: 1177| 6.09k|isc__mempool_get(isc_mempool_t *restrict mpctx FLARG) { 1178| 6.09k| element *restrict item = NULL; 1179| | 1180| 6.09k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 194| 6.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6.09k, False: 0] | | | | | Branch (42:11): [True: 6.09k, False: 0] | | | | ------------------ | | | | 43| 6.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1181| | 1182| 6.09k| mpctx->allocated++; 1183| | 1184| 6.09k| if (mpctx->items == NULL) { ------------------ | Branch (1184:6): [True: 3.17k, False: 2.91k] ------------------ 1185| 3.17k| isc_mem_t *mctx = mpctx->mctx; 1186| 3.17k|#if !__SANITIZE_ADDRESS__ 1187| 3.17k| const size_t fillcount = mpctx->fillcount; 1188| |#else 1189| | const size_t fillcount = 1; 1190| |#endif 1191| | /* 1192| | * We need to dip into the well. Fill up our free list. 1193| | */ 1194| 3.25M| for (size_t i = 0; i < fillcount; i++) { ------------------ | Branch (1194:22): [True: 3.25M, False: 3.17k] ------------------ 1195| 3.25M| item = mem_get(mctx, mpctx->size, 0); 1196| 3.25M| mem_getstats(mctx, mpctx->size); 1197| 3.25M| item->next = mpctx->items; 1198| 3.25M| mpctx->items = item; 1199| 3.25M| mpctx->freecount++; 1200| 3.25M| } 1201| 3.17k| } 1202| | 1203| 6.09k| INSIST(mpctx->items != NULL); ------------------ | | 198| 6.09k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6.09k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6.09k, False: 0] | | | | ------------------ | | | | 55| 6.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1204| 6.09k| item = mpctx->items; 1205| | 1206| 6.09k| mpctx->items = item->next; 1207| | 1208| 6.09k| INSIST(mpctx->freecount > 0); ------------------ | | 198| 6.09k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6.09k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6.09k, False: 0] | | | | ------------------ | | | | 55| 6.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1209| 6.09k| mpctx->freecount--; 1210| 6.09k| mpctx->gets++; 1211| | 1212| 6.09k| ADD_TRACE(mpctx->mctx, item, mpctx->size, func, file, line); 1213| | 1214| 6.09k| return item; 1215| 6.09k|} isc__mempool_put: 1219| 6.09k|isc__mempool_put(isc_mempool_t *restrict mpctx, void *mem FLARG) { 1220| 6.09k| element *restrict item = NULL; 1221| | 1222| 6.09k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 194| 6.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6.09k, False: 0] | | | | | Branch (42:11): [True: 6.09k, False: 0] | | | | ------------------ | | | | 43| 6.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1223| 6.09k| REQUIRE(mem != NULL); ------------------ | | 194| 6.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.09k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6.09k, False: 0] | | | | ------------------ | | | | 43| 6.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1224| | 1225| 6.09k| isc_mem_t *mctx = mpctx->mctx; 1226| 6.09k| const size_t freecount = mpctx->freecount; 1227| 6.09k|#if !__SANITIZE_ADDRESS__ 1228| 6.09k| const size_t freemax = mpctx->freemax; 1229| |#else 1230| | const size_t freemax = 0; 1231| |#endif 1232| | 1233| 6.09k| INSIST(mpctx->allocated > 0); ------------------ | | 198| 6.09k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6.09k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6.09k, False: 0] | | | | ------------------ | | | | 55| 6.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1234| 6.09k| mpctx->allocated--; 1235| | 1236| 6.09k| DELETE_TRACE(mctx, mem, mpctx->size, func, file, line); 1237| | 1238| | /* 1239| | * If our free list is full, return this to the mctx directly. 1240| | */ 1241| 6.09k| if (freecount >= freemax) { ------------------ | Branch (1241:6): [True: 0, False: 6.09k] ------------------ 1242| 0| mem_putstats(mctx, mpctx->size); 1243| 0| mem_put(mctx, mem, mpctx->size, 0); 1244| 0| return; 1245| 0| } 1246| | 1247| | /* 1248| | * Otherwise, attach it to our free list and bump the counter. 1249| | */ 1250| 6.09k| item = (element *)mem; 1251| 6.09k| item->next = mpctx->items; 1252| 6.09k| mpctx->items = item; 1253| 6.09k| mpctx->freecount++; 1254| 6.09k|} isc_mempool_setfreemax: 1262| 3.19k| const unsigned int limit) { 1263| 3.19k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1264| 3.19k| mpctx->freemax = limit; 1265| 3.19k|} isc_mempool_getallocated: 1282| 3.19k|isc_mempool_getallocated(isc_mempool_t *restrict mpctx) { 1283| 3.19k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1284| | 1285| 3.19k| return mpctx->allocated; 1286| 3.19k|} isc_mempool_setfillcount: 1290| 3.19k| unsigned int const limit) { 1291| 3.19k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | | Branch (42:11): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1292| 3.19k| REQUIRE(limit > 0); ------------------ | | 194| 3.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.19k, False: 0] | | | | ------------------ | | | | 43| 3.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1293| | 1294| 3.19k| mpctx->fillcount = limit; 1295| 3.19k|} isc__mem_create: 1557| 14|isc__mem_create(const char *name, isc_mem_t **mctxp FLARG) { 1558| 14| mem_create(name, mctxp, mem_debugging, 0); 1559| |#if ISC_MEM_TRACKLINES 1560| | if ((mem_debugging & ISC_MEM_DEBUGTRACE) != 0) { 1561| | fprintf(stderr, "create mctx %p func %s file %s line %u\n", 1562| | *mctxp, func, file, line); 1563| | } 1564| |#endif /* ISC_MEM_TRACKLINES */ 1565| 14|} mem.c:debugging_enabled: 488| 6|debugging_enabled(const char *name) { 489| 6| char env_buf[256]; 490| 6| size_t env_size = sizeof(env_buf); 491| | 492| 6| int r = uv_os_getenv(name, env_buf, &env_size); 493| 6| switch (r) { 494| 0| case 0: ------------------ | Branch (494:2): [True: 0, False: 6] ------------------ 495| 0| return true; 496| 6| case UV_ENOENT: ------------------ | Branch (496:2): [True: 6, False: 0] ------------------ 497| 6| return false; 498| 0| default: ------------------ | Branch (498:2): [True: 0, False: 6] ------------------ 499| 0| UV_RUNTIME_CHECK(uv_os_getenv, r); ------------------ | | 50| 0| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 0] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 500| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 501| 6| } 502| 6|} mem.c:mem_get: 395| 3.26M|mem_get(isc_mem_t *ctx, size_t size, int flags) { 396| 3.26M| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 387| 3.26M| if (s == 0) { \ | | ------------------ | | | Branch (387:6): [True: 4, False: 3.26M] | | ------------------ | | 388| 4| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 83| 4|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 389| 4| } ------------------ 397| | 398| 3.26M| void *ptr = mallocx(size, flags | ctx->jemalloc_flags); 399| 3.26M| CHECK_OOM(ptr, size); ------------------ | | 241| 3.26M|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (241:37): [True: 3.26M, False: 0] | | | Branch (241:54): [True: 0, False: 0] | | ------------------ ------------------ 400| | 401| 3.26M| return ptr; 402| 3.26M|} mem.c:mem_getstats: 471| 3.26M|mem_getstats(isc_mem_t *ctx, size_t size) { 472| | atomic_fetch_add_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 30| 3.26M| atomic_fetch_add_explicit((o), (v), memory_order_relaxed) ------------------ 473| 3.26M|} mem.c:mem_putstats: 479| 3.26M|mem_putstats(isc_mem_t *ctx, size_t size) { 480| | atomic_fetch_sub_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 32| 3.26M| atomic_fetch_sub_explicit((o), (v), memory_order_relaxed) ------------------ 481| 3.26M|} mem.c:mem_put: 442| 3.26M|mem_put(isc_mem_t *ctx, void *mem, size_t size, int flags) { 443| 3.26M| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 387| 3.26M| if (s == 0) { \ | | ------------------ | | | Branch (387:6): [True: 0, False: 3.26M] | | ------------------ | | 388| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 83| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 389| 0| } ------------------ 444| | 445| 3.26M| sdallocx(mem, size, flags | ctx->jemalloc_flags); 446| | 447| 3.26M| freed_bytes += size; 448| | 449| 3.26M| if (freed_bytes >= purge_threshold) { ------------------ | Branch (449:6): [True: 49, False: 3.26M] ------------------ 450| 49| freed_bytes = 0; 451| 49| mem_purge(); 452| 49| } 453| 3.26M|} mem.c:mem_purge: 413| 49|mem_purge(void) { 414| 49| isc_stdtime_t now = isc_stdtime_now(); 415| 49| isc_stdtime_t last = atomic_load_relaxed(&last_purge); ------------------ | | 28| 49|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 416| | 417| 49| if (now > last && ------------------ | Branch (417:6): [True: 2, False: 47] ------------------ 418| 49| atomic_compare_exchange_strong_acq_rel(&last_purge, &last, now)) ------------------ | | 71| 49| atomic_compare_exchange_strong_explicit( \ | | ------------------ | | | Branch (71:2): [True: 2, False: 0] | | ------------------ | | 72| 2| (o), (e), (d), memory_order_acq_rel, memory_order_acquire) ------------------ 419| 2| { 420| |#if defined(JEMALLOC_API_SUPPORTED) 421| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".decay", 422| | NULL, NULL, NULL, 0); 423| |#elif defined(__GLIBC__) 424| | (void)malloc_trim(0); 425| 2|#endif 426| 2| } 427| 49|} mem.c:mem_create: 602| 14| unsigned int jemalloc_flags) { 603| 14| isc_mem_t *ctx = NULL; 604| | 605| 14| REQUIRE(ctxp != NULL && *ctxp == NULL); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 14, False: 0] | | | | | Branch (42:11): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 606| 14| REQUIRE(name != NULL); ------------------ | | 194| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 14, False: 0] | | | | ------------------ | | | | 43| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 607| | 608| 14| ctx = mallocx(sizeof(*ctx), jemalloc_flags); 609| 14| CHECK_OOM(ctx, sizeof(*ctx)); ------------------ | | 241| 14|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (241:37): [True: 14, False: 0] | | | Branch (241:54): [True: 0, False: 0] | | ------------------ ------------------ 610| | 611| 14| *ctx = (isc_mem_t){ 612| 14| .magic = MEM_MAGIC, ------------------ | | 118| 14|#define MEM_MAGIC ISC_MAGIC('M', 'e', 'm', 'C') | | ------------------ | | | | 31| 14|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 613| 14| .debugging = debugging, 614| 14| .jemalloc_flags = jemalloc_flags, 615| 14| .checkfree = true, 616| 14| .name = strdup(name), 617| 14| }; 618| | 619| 14| isc_mutex_init(&ctx->lock); ------------------ | | 68| 14|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 14| { \ | | | | 80| 14| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 14| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 14| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 14] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 14| } | | ------------------ ------------------ 620| 14| isc_refcount_init(&ctx->references, 1); ------------------ | | 44| 14|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 621| | 622| 7.19k| for (size_t i = 0; i < ARRAY_SIZE(ctx->stat_s); i++) { ------------------ | | 94| 7.19k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (622:21): [True: 7.18k, False: 14] ------------------ 623| 7.18k| atomic_init(&ctx->stat_s[i].inuse, 0); 624| 7.18k| } 625| | 626| | /* Reserve the [-1] index for ISC_TID_UNKNOWN */ 627| 14| ctx->stat = &ctx->stat_s[1]; 628| | 629| 14| atomic_init(&ctx->hi_water, 0); 630| 14| atomic_init(&ctx->lo_water, 0); 631| | 632| 14| ISC_LIST_INIT(ctx->pools); ------------------ | | 43| 14| do { \ | | 44| 14| (list).head = NULL; \ | | 45| 14| (list).tail = NULL; \ | | 46| 14| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 14] | | ------------------ ------------------ 633| | 634| |#if ISC_MEM_TRACKLINES 635| | if ((ctx->debugging & ISC_MEM_DEBUGRECORD) != 0) { 636| | unsigned int i; 637| | size_t debuglist_size = ISC_CHECKED_MUL(DEBUG_TABLE_COUNT, 638| | sizeof(debuglist_t)); 639| | 640| | ctx->debuglist = mallocx(debuglist_size, jemalloc_flags); 641| | CHECK_OOM(ctx->debuglist, debuglist_size); 642| | 643| | for (i = 0; i < DEBUG_TABLE_COUNT; i++) { 644| | ISC_LIST_INIT(ctx->debuglist[i]); 645| | } 646| | } 647| |#endif /* if ISC_MEM_TRACKLINES */ 648| | 649| 14| LOCK(&contextslock); ------------------ | | 26| 14| { \ | | 27| 14| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 14| __FILE__, __LINE__)); \ | | 29| 14| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 14|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 14| { \ | | | | | | 86| 14| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 14| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 14| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 14] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 14| } | | | | ------------------ | | ------------------ | | 30| 14| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 14| __FILE__, __LINE__)); \ | | 32| 14| } ------------------ 650| 14| ISC_LIST_INITANDAPPEND(contexts, ctx, link); ------------------ | | 106| 14| __ISC_LIST_APPENDUNSAFE(list, elt, link) | | ------------------ | | | | 88| 14| do { \ | | | | 89| 14| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 12, False: 2] | | | | ------------------ | | | | 90| 12| (list).tail->link.next = (elt); \ | | | | 91| 12| } else { \ | | | | 92| 2| (list).head = (elt); \ | | | | 93| 2| } \ | | | | 94| 14| (elt)->link.prev = (list).tail; \ | | | | 95| 14| (elt)->link.next = NULL; \ | | | | 96| 14| (list).tail = (elt); \ | | | | 97| 14| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 14] | | | | ------------------ | | ------------------ ------------------ 651| 14| UNLOCK(&contextslock); ------------------ | | 34| 14| { \ | | 35| 14| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 14|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 14| { \ | | | | | | 92| 14| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 14| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 14| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 14] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 14| } | | | | ------------------ | | ------------------ | | 36| 14| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 14| __FILE__, __LINE__)); \ | | 38| 14| } ------------------ 652| | 653| 14| *ctxp = ctx; 654| 14|} isc__mutex_initialize: 33| 2|isc__mutex_initialize(void) { 34| 2| RUNTIME_CHECK(pthread_mutexattr_init(&isc__mutex_init_attr) == 0); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 35| |#if ISC_MUTEX_ERROR_CHECK 36| | RUNTIME_CHECK(pthread_mutexattr_settype(&isc__mutex_init_attr, 37| | PTHREAD_MUTEX_ERRORCHECK) == 0); 38| |#elif HAVE_PTHREAD_MUTEX_ADAPTIVE_NP 39| 2| RUNTIME_CHECK(pthread_mutexattr_settype(&isc__mutex_init_attr, ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 40| 2| PTHREAD_MUTEX_ADAPTIVE_NP) == 41| 2| 0); 42| 2|#endif 43| 2|} isc_os_ncpus: 199| 2|isc_os_ncpus(void) { 200| 2| return isc__os_ncpus; 201| 2|} isc__os_initialize: 222| 2|isc__os_initialize(void) { 223| 2| umask_initialize(); 224| 2| ncpus_initialize(); 225| 2| kernel_initialize(); 226| 2|#if defined(_SC_LEVEL1_DCACHE_LINESIZE) 227| 2| long s = sysconf(_SC_LEVEL1_DCACHE_LINESIZE); 228| 2| if (s > 0 && (unsigned long)s > isc__os_cacheline) { ------------------ | Branch (228:6): [True: 2, False: 0] | Branch (228:15): [True: 0, False: 2] ------------------ 229| 0| isc__os_cacheline = s; 230| 0| } 231| 2|#endif 232| | 233| 2| pthread_attr_init(&isc__thread_attr); 234| | 235| 2| size_t stacksize = isc_thread_getstacksize(); 236| 2| if (stacksize != 0 && stacksize < THREAD_MINSTACKSIZE) { ------------------ | | 29| 2|#define THREAD_MINSTACKSIZE (1U * 1024 * 1024) ------------------ | Branch (236:6): [True: 2, False: 0] | Branch (236:24): [True: 0, False: 2] ------------------ 237| 0| isc_thread_setstacksize(THREAD_MINSTACKSIZE); ------------------ | | 29| 0|#define THREAD_MINSTACKSIZE (1U * 1024 * 1024) ------------------ 238| 0| } 239| 2|} os.c:umask_initialize: 180| 2|umask_initialize(void) { 181| 2| isc__os_umask = umask(0); 182| 2| (void)umask(isc__os_umask); 183| 2|} os.c:ncpus_initialize: 42| 2|ncpus_initialize(void) { 43| 2| isc__os_ncpus = uv_available_parallelism(); 44| 2|} os.c:kernel_initialize: 186| 2|kernel_initialize(void) { 187| 2| struct utsname buffer; 188| | 189| 2| if (uname(&buffer) == -1) { ------------------ | Branch (189:6): [True: 0, False: 2] ------------------ 190| 0| return; 191| 0| } 192| | 193| 2| (void)sscanf(buffer.release, "%d.%d.%d", &kernel_major, &kernel_minor, 194| 2| &kernel_patch); 195| 2| (void)strlcpy(kernel_name, buffer.sysname, sizeof(kernel_name)); 196| 2|} isc_ossl_wrap_rsa_key_bits_leq: 631| 19|isc_ossl_wrap_rsa_key_bits_leq(EVP_PKEY *pkey, size_t limit) { 632| 19| BIGNUM *e = NULL; 633| 19| if (EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &e) == 1) { ------------------ | Branch (633:6): [True: 19, False: 0] ------------------ 634| 19| int bits = BN_num_bits(e); 635| 19| BN_free(e); 636| | 637| 19| return bits > 0 && (size_t)bits <= limit; ------------------ | Branch (637:10): [True: 19, False: 0] | Branch (637:22): [True: 19, False: 0] ------------------ 638| 19| } 639| 0| return false; 640| 19|} isc_ossl_wrap_load_rsa_public_from_components: 702| 108| EVP_PKEY **pkeyp) { 703| 108| OSSL_PARAM_BLD *bld = NULL; 704| 108| EVP_PKEY_CTX *pctx = NULL; 705| 108| OSSL_PARAM *params = NULL; 706| 108| isc_result_t result; 707| | 708| 108| result = ISC_R_SUCCESS; 709| | 710| 108| REQUIRE(pkeyp != NULL && *pkeyp == NULL); ------------------ | | 194| 108|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 216| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 108, False: 0] | | | | | Branch (42:11): [True: 108, False: 0] | | | | ------------------ | | | | 43| 108| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 711| 108| REQUIRE(c != NULL && c->n != NULL && c->e != NULL); ------------------ | | 194| 108|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 432| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 108, False: 0] | | | | | Branch (42:11): [True: 108, False: 0] | | | | | Branch (42:11): [True: 108, False: 0] | | | | ------------------ | | | | 43| 108| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 712| | 713| 108| bld = OSSL_PARAM_BLD_new(); 714| 108| if (bld == NULL) { ------------------ | Branch (714:6): [True: 0, False: 108] ------------------ 715| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_new")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 716| 0| } 717| | 718| 108| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, c->n) != 1) { ------------------ | Branch (718:6): [True: 0, False: 108] ------------------ 719| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_push_BN")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 720| 0| } 721| | 722| 108| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, c->e) != 1) { ------------------ | Branch (722:6): [True: 0, False: 108] ------------------ 723| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_push_BN")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 724| 0| } 725| | 726| 108| params = OSSL_PARAM_BLD_to_param(bld); 727| 108| if (params == NULL) { ------------------ | Branch (727:6): [True: 0, False: 108] ------------------ 728| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_to_param")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 729| 0| } 730| | 731| 108| pctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); 732| 108| if (pctx == NULL) { ------------------ | Branch (732:6): [True: 0, False: 108] ------------------ 733| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_CTX_new_from_name")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 734| 0| } 735| | 736| 108| if (EVP_PKEY_fromdata_init(pctx) != 1) { ------------------ | Branch (736:6): [True: 0, False: 108] ------------------ 737| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_fromdata_init")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 738| 0| } 739| | 740| 108| if (EVP_PKEY_fromdata(pctx, pkeyp, EVP_PKEY_PUBLIC_KEY, params) != 1) { ------------------ | Branch (740:6): [True: 0, False: 108] ------------------ 741| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_fromdata")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 742| 0| } 743| | 744| 108| result = ISC_R_SUCCESS; 745| | 746| 108|cleanup: 747| 108| EVP_PKEY_CTX_free(pctx); 748| 108| OSSL_PARAM_free(params); 749| 108| OSSL_PARAM_BLD_free(bld); 750| 108| return result; 751| 108|} isc_ossl_wrap_rsa_components_cleanup: 23| 108|isc_ossl_wrap_rsa_components_cleanup(isc_ossl_wrap_rsa_components_t *c) { 24| 108| REQUIRE(c != NULL); ------------------ | | 194| 108|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 108| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 108, False: 0] | | | | ------------------ | | | | 43| 108| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 25| | 26| 108| if (!c->needs_cleanup) { ------------------ | Branch (26:6): [True: 0, False: 108] ------------------ 27| 0| return; 28| 0| } 29| | 30| | /* 31| | * NOTE: BN_free() frees the components of the BIGNUM, and if it was 32| | * created by BN_new(), also the structure itself. BN_clear_free() 33| | * additionally overwrites the data before the memory is returned to the 34| | * system. If a is NULL, nothing is done. 35| | */ 36| 108| BN_free(c->e); 37| 108| BN_free(c->n); 38| 108| BN_clear_free(c->d); 39| 108| BN_clear_free(c->p); 40| 108| BN_clear_free(c->q); 41| 108| BN_clear_free(c->dmp1); 42| 108| BN_clear_free(c->dmq1); 43| 108| BN_clear_free(c->iqmp); 44| | 45| | c->needs_cleanup = false; 46| 108|} isc_ossl_wrap_toresult: 49| 18|isc_ossl_wrap_toresult(isc_result_t fallback) { 50| 18| isc_result_t result = fallback; 51| 18| unsigned long err = ERR_peek_error(); 52| |#ifdef ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED 53| | int lib = ERR_GET_LIB(err); 54| |#endif /* ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED */ 55| 18| int reason = ERR_GET_REASON(err); 56| | 57| 18| switch (reason) { 58| | /* 59| | * ERR_* errors are globally unique; others 60| | * are unique per sublibrary 61| | */ 62| 0| case ERR_R_MALLOC_FAILURE: ------------------ | Branch (62:2): [True: 0, False: 18] ------------------ 63| 0| result = ISC_R_NOMEMORY; 64| 0| break; 65| 18| default: ------------------ | Branch (65:2): [True: 18, False: 0] ------------------ 66| |#ifdef ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED 67| | if (lib == ERR_R_ECDSA_LIB && 68| | reason == ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED) 69| | { 70| | result = ISC_R_NOENTROPY; 71| | break; 72| | } 73| |#endif /* ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED */ 74| 18| break; 75| 18| } 76| | 77| 18| return result; 78| 18|} isc__ossl_wrap_logged_toresult: 84| 18| int line) { 85| 18| isc_result_t result = isc_ossl_wrap_toresult(fallback); 86| | 87| | /* 88| | * This is an exception - normally, we don't allow this, but the 89| | * compatibility shims in dst_openssl.h needs a call that just 90| | * translates the error code and don't do any logging. 91| | */ 92| 18| if (category == ISC_LOGCATEGORY_INVALID) { ------------------ | Branch (92:6): [True: 18, False: 0] ------------------ 93| 18| goto done; 94| 18| } 95| | 96| 0| isc_log_write(category, module, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 97| 0| "%s (%s:%d) failed (%s)", funcname, file, line, 98| 0| isc_result_totext(result)); 99| | 100| 0| if (result == ISC_R_NOMEMORY) { ------------------ | Branch (100:6): [True: 0, False: 0] ------------------ 101| 0| goto done; 102| 0| } 103| | 104| 0| for (;;) { 105| 0| const char *func, *data; 106| 0| int flags; 107| 0| unsigned long err = ERR_get_error_all(&file, &line, &func, 108| 0| &data, &flags); 109| 0| if (err == 0U) { ------------------ | Branch (109:7): [True: 0, False: 0] ------------------ 110| 0| break; 111| 0| } 112| | 113| 0| char buf[256]; 114| 0| ERR_error_string_n(err, buf, sizeof(buf)); 115| | 116| 0| isc_log_write(category, module, ISC_LOG_INFO, "%s:%s:%d:%s", ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 117| 0| buf, file, line, 118| 0| ((flags & ERR_TXT_STRING) != 0) ? data : ""); ------------------ | Branch (118:10): [True: 0, False: 0] ------------------ 119| 0| } 120| | 121| 18|done: 122| 18| ERR_clear_error(); 123| 18| return result; 124| 0|} isc_parse_uint32: 26| 22|isc_parse_uint32(uint32_t *uip, const char *string, int base) { 27| 22| unsigned long n; 28| 22| uint32_t r; 29| 22| char *e; 30| 22| if (!isalnum((unsigned char)(string[0]))) { ------------------ | Branch (30:6): [True: 0, False: 22] ------------------ 31| 0| return ISC_R_BADNUMBER; 32| 0| } 33| 22| errno = 0; 34| 22| n = strtoul(string, &e, base); 35| 22| if (*e != '\0') { ------------------ | Branch (35:6): [True: 0, False: 22] ------------------ 36| 0| return ISC_R_BADNUMBER; 37| 0| } 38| | /* 39| | * Where long is 64 bits we need to convert to 32 bits then test for 40| | * equality. This is a no-op on 32 bit machines and a good compiler 41| | * will optimise it away. 42| | */ 43| 22| r = (uint32_t)n; 44| 22| if ((n == ULONG_MAX && errno == ERANGE) || (n != (unsigned long)r)) { ------------------ | Branch (44:7): [True: 0, False: 22] | Branch (44:25): [True: 0, False: 0] | Branch (44:45): [True: 0, False: 22] ------------------ 45| 0| return ISC_R_RANGE; 46| 0| } 47| 22| *uip = r; 48| 22| return ISC_R_SUCCESS; 49| 22|} isc_radix_create: 135| 4|isc_radix_create(isc_mem_t *mctx, isc_radix_tree_t **target, int maxbits) { 136| 4| REQUIRE(target != NULL && *target == NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 137| 4| RUNTIME_CHECK(maxbits <= RADIX_MAXBITS); ------------------ | | 241| 4| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 4, False: 0] | | ------------------ ------------------ 138| | 139| 4| isc_radix_tree_t *radix = isc_mem_get(mctx, sizeof(isc_radix_tree_t)); ------------------ | | 128| 4|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 140| 4| *radix = (isc_radix_tree_t){ 141| 4| .maxbits = maxbits, 142| 4| .magic = RADIX_TREE_MAGIC, ------------------ | | 103| 4|#define RADIX_TREE_MAGIC ISC_MAGIC('R', 'd', 'x', 'T') | | ------------------ | | | | 31| 4|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 143| 4| }; 144| 4| isc_mem_attach(mctx, &radix->mctx); 145| 4| *target = radix; 146| 4|} isc_random32: 50| 6|isc_random32(void) { 51| 6|#if FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 52| | /* 53| | * A fixed stream of numbers helps with problem reproduction when 54| | * fuzzing. The first result needs to be non-zero as expected by 55| | * random_test.c (it starts with ISC_RANDOM_BUFSIZE, see above). 56| | */ 57| 6| return (uint32_t)(isc__random_pos++); 58| 0|#endif /* if FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */ 59| | 60| 0| if (isc__random_pos == ISC_RANDOM_BUFSIZE) { ------------------ | | 44| 0|#define ISC_RANDOM_BUFSIZE (ISC_OS_CACHELINE_SIZE / sizeof(uint32_t)) | | ------------------ | | | | 26| 0|#define ISC_OS_CACHELINE_SIZE 64 | | ------------------ ------------------ | Branch (60:6): [True: 0, False: 0] ------------------ 61| 0| isc_random_buf(isc__random_pool, sizeof(isc__random_pool)); 62| 0| isc__random_pos = 0; 63| 0| } 64| | 65| 0| return isc__random_pool[isc__random_pos++]; 66| 6|} isc_random_uniform: 81| 6|isc_random_uniform(uint32_t limit) { 82| | /* 83| | * Daniel Lemire's nearly-divisionless unbiased bounded random numbers. 84| | * 85| | * https://lemire.me/blog/?p=17551 86| | * 87| | * The raw random number generator `next()` returns a 32-bit value. 88| | * We do a 64-bit multiply `next() * limit` and treat the product as a 89| | * 32.32 fixed-point value less than the limit. Our result will be the 90| | * integer part (upper 32 bits), and we will use the fraction part 91| | * (lower 32 bits) to determine whether or not we need to resample. 92| | */ 93| 6| uint64_t num = (uint64_t)isc_random32() * (uint64_t)limit; 94| | /* 95| | * In the fast path, we avoid doing a division in most cases by 96| | * comparing the fraction part of `num` with the limit, which is 97| | * a slight over-estimate for the exact resample threshold. 98| | */ 99| 6| if ((uint32_t)(num) < limit) { ------------------ | Branch (99:6): [True: 0, False: 6] ------------------ 100| | /* 101| | * We are in the slow path where we re-do the approximate test 102| | * more accurately. The exact threshold for the resample loop 103| | * is the remainder after dividing the raw RNG limit `1 << 32` 104| | * by the caller's limit. We use a trick to calculate it 105| | * within 32 bits: 106| | * 107| | * (1 << 32) % limit 108| | * == ((1 << 32) - limit) % limit 109| | * == (uint32_t)(-limit) % limit 110| | * 111| | * This division is safe: we know that `limit` is strictly 112| | * greater than zero because of the slow-path test above. 113| | */ 114| 0| uint32_t residue = (uint32_t)(-limit) % limit; 115| | /* 116| | * Unless we get one of `N = (1 << 32) - residue` valid 117| | * values, we reject the sample. This `N` is a multiple of 118| | * `limit`, so our results will be unbiased; and `N` is the 119| | * largest multiple that fits in 32 bits, so rejections are as 120| | * rare as possible. 121| | * 122| | * There are `limit` possible values for the integer part of 123| | * our fixed-point number. Each one corresponds to `N/limit` 124| | * or `N/limit + 1` possible fraction parts. For our result to 125| | * be unbiased, every possible integer part must have the same 126| | * number of possible valid fraction parts. So, when we get 127| | * the superfluous value in the `N/limit + 1` cases, we need 128| | * to reject and resample. 129| | * 130| | * Because of the multiplication, the possible values in the 131| | * fraction part are equally spaced by `limit`, with varying 132| | * gaps at each end of the fraction's 32-bit range. We will 133| | * choose a range of size `N` (a multiple of `limit`) into 134| | * which valid fraction values must fall, with the rest of the 135| | * 32-bit range covered by the `residue`. Lemire's paper says 136| | * that exactly `N/limit` possible values spaced apart by 137| | * `limit` will fit into our size `N` valid range, regardless 138| | * of the size of the end gaps, the phase alignment of the 139| | * values, or the position of the range. 140| | * 141| | * So, when a fraction value falls in the `residue` outside 142| | * our valid range, it is superfluous, and we resample. 143| | */ 144| 0| while ((uint32_t)(num) < residue) { ------------------ | Branch (144:10): [True: 0, False: 0] ------------------ 145| 0| num = (uint64_t)isc_random32() * (uint64_t)limit; 146| 0| } 147| 0| } 148| | /* 149| | * Return the integer part (upper 32 bits). 150| | */ 151| 6| return (uint32_t)(num >> 32); 152| 6|} isc_rwlock_rdlock: 138| 1.57k|isc_rwlock_rdlock(isc_rwlock_t *rwl) { 139| 1.57k| uint32_t cnt = 0; 140| 1.57k| bool barrier_raised = false; 141| | 142| 1.57k| LIBISC_RWLOCK_RDLOCK_REQ(rwl); 143| | 144| 1.57k| while (true) { ------------------ | Branch (144:9): [True: 1.57k, Folded] ------------------ 145| 1.57k| read_indicator_arrive(rwl); 146| 1.57k| if (!writers_lock_islocked(rwl)) { ------------------ | Branch (146:7): [True: 1.57k, False: 0] ------------------ 147| | /* Acquired lock in read-only mode */ 148| 1.57k| break; 149| 1.57k| } 150| | 151| | /* Writer has acquired the lock, must reset to 0 and wait */ 152| 0| read_indicator_depart(rwl); 153| | 154| 0| while (writers_lock_islocked(rwl)) { ------------------ | Branch (154:10): [True: 0, False: 0] ------------------ 155| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 156| 0| if (ran_out_of_patience(cnt++) && !barrier_raised) { ------------------ | | 135| 0|#define ran_out_of_patience(cnt) (cnt >= RWLOCK_MAX_READER_PATIENCE) | | ------------------ | | | | 77| 0|#define RWLOCK_MAX_READER_PATIENCE 500 | | ------------------ | | | Branch (135:34): [True: 0, False: 0] | | ------------------ ------------------ | Branch (156:38): [True: 0, False: 0] ------------------ 157| 0| writers_barrier_raise(rwl); 158| 0| barrier_raised = true; 159| 0| } 160| 0| } 161| 0| } 162| 1.57k| if (barrier_raised) { ------------------ | Branch (162:6): [True: 0, False: 1.57k] ------------------ 163| 0| writers_barrier_lower(rwl); 164| 0| } 165| | 166| 1.57k| LIBISC_RWLOCK_RDLOCK_ACQ(rwl); 167| 1.57k|} isc_rwlock_rdunlock: 186| 1.57k|isc_rwlock_rdunlock(isc_rwlock_t *rwl) { 187| 1.57k| read_indicator_depart(rwl); 188| 1.57k| LIBISC_RWLOCK_RDUNLOCK(rwl); 189| 1.57k|} isc_rwlock_wrlock: 233| 20|isc_rwlock_wrlock(isc_rwlock_t *rwl) { 234| 20| LIBISC_RWLOCK_WRLOCK_REQ(rwl); 235| | 236| | /* Write Barriers has been raised, wait */ 237| 20| while (writers_barrier_israised(rwl)) { ------------------ | Branch (237:9): [True: 0, False: 20] ------------------ 238| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 239| 0| } 240| | 241| | /* Try to acquire the write-lock */ 242| 20| while (!writers_lock_acquire(rwl)) { ------------------ | Branch (242:9): [True: 0, False: 20] ------------------ 243| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 244| 0| } 245| | 246| 20| read_indicator_wait_until_empty(rwl); 247| | 248| 20| LIBISC_RWLOCK_WRLOCK_ACQ(rwl); 249| 20|} isc_rwlock_wrunlock: 252| 20|isc_rwlock_wrunlock(isc_rwlock_t *rwl) { 253| 20| writers_lock_release(rwl); 254| 20| LIBISC_RWLOCK_WRUNLOCK(rwl); 255| 20|} isc_rwlock_init: 293| 2.06k|isc_rwlock_init(isc_rwlock_t *rwl) { 294| 2.06k| REQUIRE(rwl != NULL); ------------------ | | 194| 2.06k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.06k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.06k, False: 0] | | | | ------------------ | | | | 43| 2.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 295| | 296| 2.06k| atomic_init(&rwl->writers_lock, ISC_RWLOCK_UNLOCKED); ------------------ | | 69| 2.06k|#define ISC_RWLOCK_UNLOCKED false ------------------ 297| 2.06k| atomic_init(&rwl->writers_barrier, 0); 298| 2.06k| atomic_init(&rwl->readers_ingress, 0); 299| | atomic_init(&rwl->readers_egress, 0); 300| 2.06k| LIBISC_RWLOCK_INIT(rwl); 301| 2.06k|} rwlock.c:read_indicator_arrive: 86| 1.57k|read_indicator_arrive(isc_rwlock_t *rwl) { 87| | (void)atomic_fetch_add_release(&rwl->readers_ingress, 1); ------------------ | | 52| 1.57k| atomic_fetch_add_explicit((o), (v), memory_order_release) ------------------ 88| 1.57k|} rwlock.c:writers_lock_islocked: 117| 1.57k|writers_lock_islocked(isc_rwlock_t *rwl) { 118| 1.57k| return atomic_load_acquire(&rwl->writers_lock) == ISC_RWLOCK_LOCKED; ------------------ | | 50| 1.57k|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ return atomic_load_acquire(&rwl->writers_lock) == ISC_RWLOCK_LOCKED; ------------------ | | 70| 1.57k|#define ISC_RWLOCK_LOCKED true ------------------ 119| 1.57k|} rwlock.c:read_indicator_depart: 91| 1.57k|read_indicator_depart(isc_rwlock_t *rwl) { 92| | (void)atomic_fetch_add_release(&rwl->readers_egress, 1); ------------------ | | 52| 1.57k| atomic_fetch_add_explicit((o), (v), memory_order_release) ------------------ 93| 1.57k|} rwlock.c:writers_barrier_israised: 112| 20|writers_barrier_israised(isc_rwlock_t *rwl) { 113| | return atomic_load_acquire(&rwl->writers_barrier) > 0; ------------------ | | 50| 20|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 114| 20|} rwlock.c:writers_lock_acquire: 122| 20|writers_lock_acquire(isc_rwlock_t *rwl) { 123| | return atomic_compare_exchange_weak_acq_rel( ------------------ | | 68| 20| atomic_compare_exchange_weak_explicit( \ | | 69| 20| (o), (e), (d), memory_order_acq_rel, memory_order_acquire) ------------------ 124| 20| &rwl->writers_lock, &(bool){ ISC_RWLOCK_UNLOCKED }, 125| 20| ISC_RWLOCK_LOCKED); 126| 20|} rwlock.c:read_indicator_isempty: 96| 20|read_indicator_isempty(isc_rwlock_t *rwl) { 97| 20| return atomic_load_acquire(&rwl->readers_egress) == ------------------ | | 50| 20|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 98| | atomic_load_acquire(&rwl->readers_ingress); ------------------ | | 50| 20|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 99| 20|} rwlock.c:writers_lock_release: 129| 20|writers_lock_release(isc_rwlock_t *rwl) { 130| 20| REQUIRE(atomic_compare_exchange_strong_acq_rel( ------------------ | | 194| 20|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 20, False: 0] | | | | ------------------ | | | | 43| 20| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 131| 20| &rwl->writers_lock, &(bool){ ISC_RWLOCK_LOCKED }, 132| 20| ISC_RWLOCK_UNLOCKED)); 133| 20|} rwlock.c:read_indicator_wait_until_empty: 222| 20|read_indicator_wait_until_empty(isc_rwlock_t *rwl) { 223| | /* Write-lock was acquired, now wait for running Readers to finish */ 224| 20| while (true) { ------------------ | Branch (224:9): [True: 20, Folded] ------------------ 225| 20| if (read_indicator_isempty(rwl)) { ------------------ | Branch (225:7): [True: 20, False: 0] ------------------ 226| 20| break; 227| 20| } 228| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 229| 0| } 230| 20|} isc_safe_memequal: 19| 46|isc_safe_memequal(const void *s1, const void *s2, size_t len) { 20| 46| return !CRYPTO_memcmp(s1, s2, len); 21| 46|} isc_safe_memwipe: 24| 96|isc_safe_memwipe(void *ptr, size_t len) { 25| 96| OPENSSL_cleanse(ptr, len); 26| 96|} isc_serial_lt: 22| 160|isc_serial_lt(uint32_t a, uint32_t b) { 23| | /* 24| | * Undefined => false 25| | */ 26| 160| if (a == (b ^ 0x80000000U)) { ------------------ | Branch (26:6): [True: 3, False: 157] ------------------ 27| 3| return false; 28| 3| } 29| 157| return ((int32_t)(a - b) < 0) ? true : false; ------------------ | Branch (29:9): [True: 67, False: 90] ------------------ 30| 160|} isc_signal_new: 23| 4|isc_signal_new(isc_signal_cb cb, void *cbarg, int signum) { 24| 4| int r; 25| 4| isc_loop_t *loop = isc_loop_main(); 26| 4| isc_signal_t *signal = isc_mem_get(isc_loop_getmctx(loop), ------------------ | | 128| 4|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 27| 4| sizeof(*signal)); 28| | 29| 4| *signal = (isc_signal_t){ 30| 4| .magic = SIGNAL_MAGIC, ------------------ | | 116| 4|#define SIGNAL_MAGIC ISC_MAGIC('S', 'I', 'G', ' ') | | ------------------ | | | | 31| 4|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 31| 4| .cb = cb, 32| 4| .cbarg = cbarg, 33| 4| .signum = signum, 34| 4| }; 35| | 36| 4| isc_loop_attach(loop, &signal->loop); 37| | 38| 4| r = uv_signal_init(&loop->loop, &signal->signal); 39| 4| UV_RUNTIME_CHECK(uv_signal_init, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 40| | 41| 4| uv_handle_set_data((uv_handle_t *)&signal->signal, signal); ------------------ | | 71| 4| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 42| | 43| 4| return signal; 44| 4|} isc_signal_start: 91| 4|isc_signal_start(isc_signal_t *signal) { 92| 4| int r; 93| | 94| 4| REQUIRE(VALID_SIGNAL(signal)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 95| 4| r = uv_signal_start(&signal->signal, isc__signal_cb, signal->signum); 96| 4| UV_RUNTIME_CHECK(uv_signal_start, r); ------------------ | | 50| 4| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 4] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 97| 4|} isc_sockaddr_any: 239| 8|isc_sockaddr_any(isc_sockaddr_t *sockaddr) { 240| 8| memset(sockaddr, 0, sizeof(*sockaddr)); 241| 8| sockaddr->type.sin.sin_family = AF_INET; 242| 8| sockaddr->type.sin.sin_addr.s_addr = INADDR_ANY; 243| 8| sockaddr->type.sin.sin_port = 0; 244| 8| sockaddr->length = sizeof(sockaddr->type.sin); 245| 8| ISC_LINK_INIT(sockaddr, link); ------------------ | | 57| 8|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 8| do { \ | | | | 54| 8| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 8| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 8| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 246| 8|} isc_sockaddr_any6: 249| 8|isc_sockaddr_any6(isc_sockaddr_t *sockaddr) { 250| 8| memset(sockaddr, 0, sizeof(*sockaddr)); 251| 8| sockaddr->type.sin6.sin6_family = AF_INET6; 252| 8| sockaddr->type.sin6.sin6_addr = in6addr_any; 253| 8| sockaddr->type.sin6.sin6_port = 0; 254| 8| sockaddr->length = sizeof(sockaddr->type.sin6); 255| 8| ISC_LINK_INIT(sockaddr, link); ------------------ | | 57| 8|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 8| do { \ | | | | 54| 8| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 8| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 8| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 256| 8|} isc_stats_attach: 49| 2|isc_stats_attach(isc_stats_t *stats, isc_stats_t **statsp) { 50| 2| REQUIRE(ISC_STATS_VALID(stats)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 51| 2| REQUIRE(statsp != NULL && *statsp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 52| | 53| | isc_refcount_increment(&stats->references); ------------------ | | 81| 2| ({ \ | | 82| 2| uint_fast32_t __v; \ | | 83| 2| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 2| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 2| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:11): [True: 2, False: 0] | | | | | | | Branch (54:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 2| __v; \ | | 86| 2| }) ------------------ 54| 2| *statsp = stats; 55| 2|} isc_stats_create: 82| 2|isc_stats_create(isc_mem_t *mctx, isc_stats_t **statsp, int ncounters) { 83| 2| REQUIRE(statsp != NULL && *statsp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 84| | 85| 2| isc_stats_t *stats = isc_mem_get(mctx, sizeof(*stats)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 86| 2| size_t counters_alloc_size = sizeof(isc_atomic_statscounter_t) * 87| 2| ncounters; 88| 2| stats->counters = isc_mem_get(mctx, counters_alloc_size); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 89| 2| isc_refcount_init(&stats->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 90| 10| for (int i = 0; i < ncounters; i++) { ------------------ | Branch (90:18): [True: 8, False: 2] ------------------ 91| 8| atomic_init(&stats->counters[i], 0); 92| 8| } 93| 2| stats->mctx = NULL; 94| 2| isc_mem_attach(mctx, &stats->mctx); 95| 2| stats->ncounters = ncounters; 96| 2| stats->magic = ISC_STATS_MAGIC; ------------------ | | 27| 2|#define ISC_STATS_MAGIC ISC_MAGIC('S', 't', 'a', 't') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 97| 2| *statsp = stats; 98| 2|} isc_stdio_open: 24| 6|isc_stdio_open(const char *filename, const char *mode, FILE **fp) { 25| 6| FILE *f; 26| | 27| 6| f = fopen(filename, mode); 28| 6| if (f == NULL) { ------------------ | Branch (28:6): [True: 4, False: 2] ------------------ 29| 4| return isc__errno2result(errno); ------------------ | | 25| 4|#define isc__errno2result(x) isc___errno2result(x, true, __FILE__, __LINE__) ------------------ 30| 4| } 31| 2| *fp = f; 32| 2| return ISC_R_SUCCESS; 33| 6|} isc_stdtime_now: 37| 672|isc_stdtime_now(void) { 38| 672| struct timespec ts; 39| | 40| 672| if (clock_gettime(CLOCKSOURCE, &ts) == -1) { ------------------ | | 29| 672|#define CLOCKSOURCE CLOCK_REALTIME_COARSE ------------------ | Branch (40:6): [True: 0, False: 672] ------------------ 41| 0| FATAL_SYSERROR(errno, "clock_gettime()"); ------------------ | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | ------------------ | | | | 219| 0| { \ | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | ------------------ | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | ------------------ | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | 224| 0| } | | ------------------ ------------------ 42| 0| } 43| 672| INSIST(ts.tv_sec > 0 && ts.tv_nsec >= 0 && ------------------ | | 198| 672|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2.68k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 672, False: 0] | | | | | Branch (54:11): [True: 672, False: 0] | | | | | Branch (54:11): [True: 672, False: 0] | | | | ------------------ | | | | 55| 672| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 44| 672| ts.tv_nsec < (long)NS_PER_SEC); 45| | 46| 672| return (isc_stdtime_t)ts.tv_sec; 47| 672|} isc_thread_getstacksize: 171| 2|isc_thread_getstacksize(void) { 172| 2| size_t stacksize = 0; 173| | 174| 2|#if HAVE_PTHREAD_ATTR_GETSTACKSIZE 175| 2| int ret = pthread_attr_getstacksize(&isc__thread_attr, &stacksize); 176| 2| PTHREADS_RUNTIME_CHECK(pthread_attr_getstacksize, ret); ------------------ | | 284| 2| if ((ret) != 0) { \ | | ------------------ | | | Branch (284:6): [True: 0, False: 2] | | ------------------ | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | ------------------ | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | ------------------ | | | | | | 219| 0| { \ | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | ------------------ | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | ------------------ | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | 224| 0| } | | | | ------------------ | | ------------------ | | 286| 0| } ------------------ 177| 2|#endif /* HAVE_PTHREAD_ATTR_GETSTACKSIZE */ 178| | 179| 2| return stacksize; 180| 2|} isc__tid_initcount: 44| 2|isc__tid_initcount(isc_tid_t count) { 45| 2| REQUIRE(tid_count == 0 || tid_count == count); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 46| 2| REQUIRE(count < ISC_TID_MAX); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 47| 2| if (tid_count == 0) { ------------------ | Branch (47:6): [True: 2, False: 0] ------------------ 48| 2| tid_count = count; 49| 2| } 50| 2|} isc_tid_count: 57| 8|isc_tid_count(void) { 58| 8| return tid_count; 59| 8|} isc_time_set: 55| 2|isc_time_set(isc_time_t *t, unsigned int seconds, unsigned int nanoseconds) { 56| 2| REQUIRE(t != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 57| 2| REQUIRE(nanoseconds < NS_PER_SEC); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 58| | 59| 2| t->seconds = seconds; 60| 2| t->nanoseconds = nanoseconds; 61| 2|} isc_time_isepoch: 72| 2|isc_time_isepoch(const isc_time_t *t) { 73| 2| REQUIRE(t != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 74| 2| INSIST(t->nanoseconds < NS_PER_SEC); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 75| | 76| 2| if (t->seconds == 0 && t->nanoseconds == 0) { ------------------ | Branch (76:6): [True: 2, False: 0] | Branch (76:25): [True: 2, False: 0] ------------------ 77| 2| return true; 78| 2| } 79| | 80| 0| return false; 81| 2|} isc_time_now: 110| 10|isc_time_now(void) { 111| | return time_now(CLOCKSOURCE); ------------------ | | 38| 10|#define CLOCKSOURCE CLOCK_REALTIME_COARSE ------------------ 112| 10|} isc_time_compare: 168| 2|isc_time_compare(const isc_time_t *t1, const isc_time_t *t2) { 169| 2| REQUIRE(t1 != NULL && t2 != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 170| 2| INSIST(t1->nanoseconds < NS_PER_SEC && t2->nanoseconds < NS_PER_SEC); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 2, False: 0] | | | | | Branch (54:11): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 171| | 172| 2| if (t1->seconds < t2->seconds) { ------------------ | Branch (172:6): [True: 0, False: 2] ------------------ 173| 0| return -1; 174| 0| } 175| 2| if (t1->seconds > t2->seconds) { ------------------ | Branch (175:6): [True: 0, False: 2] ------------------ 176| 0| return 1; 177| 0| } 178| 2| if (t1->nanoseconds < t2->nanoseconds) { ------------------ | Branch (178:6): [True: 0, False: 2] ------------------ 179| 0| return -1; 180| 0| } 181| 2| if (t1->nanoseconds > t2->nanoseconds) { ------------------ | Branch (181:6): [True: 1, False: 1] ------------------ 182| 1| return 1; 183| 1| } 184| 1| return 0; 185| 2|} isc_time_formattimestamp: 324| 2|isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) { 325| 2| time_t now; 326| 2| unsigned int flen; 327| 2| struct tm tm; 328| | 329| 2| REQUIRE(t != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 330| 2| INSIST(t->nanoseconds < NS_PER_SEC); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 331| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 332| 2| REQUIRE(len > 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 333| | 334| 2| now = (time_t)t->seconds; 335| 2| flen = strftime(buf, len, "%d-%b-%Y %X", localtime_r(&now, &tm)); 336| 2| INSIST(flen < len); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 337| 2| if (flen != 0) { ------------------ | Branch (337:6): [True: 2, False: 0] ------------------ 338| 2| snprintf(buf + flen, len - flen, ".%03u", 339| 2| t->nanoseconds / NS_PER_MS); 340| 2| } else { 341| 0| strlcpy(buf, "99-Bad-9999 99:99:99.999", len); 342| 0| } 343| 2|} isc_time_formatISO8601Lms: 388| 2|isc_time_formatISO8601Lms(const isc_time_t *t, char *buf, unsigned int len) { 389| 2| time_t now; 390| 2| unsigned int flen; 391| 2| struct tm tm; 392| | 393| 2| REQUIRE(t != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 394| 2| INSIST(t->nanoseconds < NS_PER_SEC); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 395| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 396| 2| REQUIRE(len > 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 397| | 398| 2| now = (time_t)t->seconds; 399| 2| flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", localtime_r(&now, &tm)); 400| 2| INSIST(flen < len); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 401| 2| if (flen > 0U && len - flen >= 6) { ------------------ | Branch (401:6): [True: 2, False: 0] | Branch (401:19): [True: 2, False: 0] ------------------ 402| 2| snprintf(buf + flen, len - flen, ".%03u", 403| 2| t->nanoseconds / NS_PER_MS); 404| 2| } 405| 2|} isc_time_formatISO8601TZms: 408| 2|isc_time_formatISO8601TZms(const isc_time_t *t, char *buf, unsigned int len) { 409| 2| char strftime_buf[64] = { 0 }; 410| 2| char ms_buf[8] = { 0 }; 411| 2| time_t now; 412| 2| unsigned int flen; 413| 2| struct tm tm; 414| | 415| 2| REQUIRE(t != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 416| 2| INSIST(t->nanoseconds < NS_PER_SEC); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 417| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 418| 2| REQUIRE(len > 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 419| | 420| 2| now = (time_t)t->seconds; 421| 2| flen = strftime(strftime_buf, len, "%Y-%m-%dT%H:%M:%S.xxx%z", 422| 2| localtime_r(&now, &tm)); 423| 2| snprintf(ms_buf, sizeof(ms_buf), ".%03u", t->nanoseconds / NS_PER_MS); 424| | 425| 2| INSIST(flen < len); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 426| 2| size_t local_date_len = sizeof("yyyy-mm-ddThh:mm:ss") - 1ul; 427| 2| size_t ms_date_len = local_date_len + 4; 428| | 429| 2| memmove(buf, strftime_buf, local_date_len); 430| 2| memmove(buf + local_date_len, ms_buf, 4); 431| 2| memmove(buf + ms_date_len, strftime_buf + ms_date_len, 3); 432| 2| buf[ms_date_len + 3] = ':'; 433| 2| memmove(buf + ms_date_len + 4, strftime_buf + ms_date_len + 3, 3); 434| 2|} isc_time_formatISO8601ms: 452| 2|isc_time_formatISO8601ms(const isc_time_t *t, char *buf, unsigned int len) { 453| 2| time_t now; 454| 2| unsigned int flen; 455| 2| struct tm tm; 456| | 457| 2| REQUIRE(t != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 458| 2| INSIST(t->nanoseconds < NS_PER_SEC); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 459| 2| REQUIRE(buf != NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 460| 2| REQUIRE(len > 0); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 461| | 462| 2| now = (time_t)t->seconds; 463| 2| flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%SZ", gmtime_r(&now, &tm)); 464| 2| INSIST(flen < len); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 465| 2| if (flen > 0U && len - flen >= 5) { ------------------ | Branch (465:6): [True: 2, False: 0] | Branch (465:19): [True: 2, False: 0] ------------------ 466| 2| flen -= 1; /* rewind one character (Z) */ 467| 2| snprintf(buf + flen, len - flen, ".%03uZ", 468| 2| t->nanoseconds / NS_PER_MS); 469| 2| } 470| 2|} time.c:time_now: 84| 10|time_now(clockid_t clock) { 85| 10| isc_time_t t; 86| 10| struct timespec ts; 87| | 88| 10| RUNTIME_CHECK(clock_gettime(clock, &ts) == 0); ------------------ | | 241| 10| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 10, False: 0] | | ------------------ ------------------ 89| 10| INSIST(ts.tv_sec >= 0 && ts.tv_nsec >= 0 && ------------------ | | 198| 10|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 40| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 10, False: 0] | | | | | Branch (54:11): [True: 10, False: 0] | | | | | Branch (54:11): [True: 10, False: 0] | | | | ------------------ | | | | 55| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 90| 10| ts.tv_nsec < (long)NS_PER_SEC); 91| | 92| | /* 93| | * Ensure the tv_sec value fits in t->seconds. 94| | */ 95| 10| INSIST(sizeof(ts.tv_sec) <= sizeof(t.seconds) || ------------------ | | 198| 10|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [Folded, False: 10] | | | | | Branch (54:11): [True: 10, False: 0] | | | | ------------------ | | | | 55| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 96| 10| ((ts.tv_sec | (unsigned int)-1) ^ (unsigned int)-1) == 0U); 97| | 98| 10| t.seconds = ts.tv_sec; 99| 10| t.nanoseconds = ts.tv_nsec; 100| | 101| 10| return t; 102| 10|} isc__uv_initialize: 132| 2|isc__uv_initialize(void) { 133| | /* 134| | * Ensure the first 3 file descriptors are open 135| | * otherwise, libuv may use one and trigger abort 136| | * when closing it. 137| | * 138| | * See https://github.com/libuv/libuv/pull/4559 139| | */ 140| 2| do { 141| 2| int fd = open("/dev/null", O_RDWR, 0); 142| 2| RUNTIME_CHECK(fd >= 0); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 143| 2| if (fd > STDERR_FILENO) { ------------------ | Branch (143:7): [True: 2, False: 0] ------------------ 144| 2| close(fd); 145| 2| break; 146| 2| } 147| 2| } while (true); ------------------ | Branch (147:11): [True: 0, Folded] ------------------ 148| 2|#if UV_VERSION_HEX >= UV_VERSION(1, 38, 0) 149| 2| int r; 150| 2| isc_mem_create("uv", &isc__uv_mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 151| 2| isc_mem_setdebugging(isc__uv_mctx, 0); 152| 2| isc_mem_setdestroycheck(isc__uv_mctx, false); 153| | 154| 2| r = uv_replace_allocator(isc__uv_malloc, isc__uv_realloc, 155| 2| isc__uv_calloc, isc__uv_free); 156| 2| UV_RUNTIME_CHECK(uv_replace_allocator, r); ------------------ | | 50| 2| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 2] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 157| 2|#endif /* UV_VERSION_HEX >= UV_VERSION(1, 38, 0) */ 158| 2|} uv.c:isc__uv_realloc: 113| 4|isc__uv_realloc(void *ptr, size_t size) { 114| 4| return isc_mem_reallocate(isc__uv_mctx, ptr, size); ------------------ | | 143| 4| isc__mem_reallocate((c), (p), (s), 0 _ISC_MEM_FILELINE) ------------------ 115| 4|} uv.c:isc__uv_calloc: 118| 4|isc__uv_calloc(size_t count, size_t size) { 119| | return isc_mem_callocate(isc__uv_mctx, count, size); ------------------ | | 140| 4| isc__mem_allocate((c), ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 4| ({ \ | | | | 33| 4| typeof(a) _c; \ | | | | 34| 4| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 4| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 4| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 4| _c; \ | | | | 37| 4| }) | | ------------------ | | 141| 4| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 4|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 120| 4|} isc__xml_initialize: 52| 2|isc__xml_initialize(void) { 53| |#ifdef HAVE_LIBXML2 54| |#ifndef LIBXML_HAS_DEPRECATED_MEMORY_ALLOCATION_FUNCTIONS 55| | isc_mem_create("libxml2", &isc__xml_mctx); 56| | isc_mem_setdebugging(isc__xml_mctx, 0); 57| | isc_mem_setdestroycheck(isc__xml_mctx, false); 58| | 59| | RUNTIME_CHECK(xmlMemSetup(isc__xml_free, isc__xml_malloc, 60| | isc__xml_realloc, isc__xml_strdup) == 0); 61| |#endif /* !LIBXML_HAS_DEPRECATED_MEMORY_ALLOCATION_FUNCTIONS */ 62| | 63| | xmlInitParser(); 64| |#endif /* HAVE_LIBXML2 */ 65| 2|}