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); ------------------ | | 236| 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.69k|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 318| 1.69k| isc_result_t result; 319| 1.69k| dns_message_t *message = NULL; 320| 1.69k| unsigned char query_tsig[23 + 32 + 6] = { 0 }; 321| 1.69k| bool addasig = false; 322| 1.69k| bool addtime = false; 323| 1.69k| bool addtsig = false; 324| 1.69k| bool setquerytsig = false; 325| 1.69k| bool settsigkey = false; 326| 1.69k| bool subtime = false; 327| 1.69k| bool withring = false; 328| 1.69k| 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.69k| if (size > 65535 || size < 2) { ------------------ | Branch (341:6): [True: 6, False: 1.69k] | Branch (341:22): [True: 1, False: 1.69k] ------------------ 342| 7| return 0; 343| 7| } 344| | 345| 1.69k| addasig = (*data & 0x80) != 0; 346| 1.69k| addtime = (*data & 0x40) != 0; 347| 1.69k| addtsig = (*data & 0x20) != 0; 348| 1.69k| setquerytsig = (*data & 0x10) != 0; 349| 1.69k| settsigkey = (*data & 0x08) != 0; 350| 1.69k| subtime = (*data & 0x04) != 0; 351| 1.69k| withring = (*data & 0x02) != 0; 352| 1.69k| withview = (*data & 0x01) != 0; 353| | 354| 1.69k| data++; 355| 1.69k| size--; 356| | 357| 1.69k| if (debug) { ------------------ | Branch (357:6): [True: 0, False: 1.69k] ------------------ 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.69k| result = create_message(&message, data, size, addasig, addtsig); 366| 1.69k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (366:6): [True: 543, False: 1.14k] ------------------ 367| 543| return 0; 368| 543| } 369| | 370| | /* 371| | * Make time calculations consistent. 372| | */ 373| 1.14k| message->fuzzing = 1; 374| 1.14k| message->fuzztime = fuzztime; 375| 1.14k| if (addtime) { ------------------ | Branch (375:6): [True: 332, False: 817] ------------------ 376| 332| message->fuzztime += 1200; 377| 332| } 378| 1.14k| if (subtime) { ------------------ | Branch (378:6): [True: 807, False: 342] ------------------ 379| 807| message->fuzztime -= 1200; 380| 807| } 381| | 382| 1.14k| if ((message->flags & DNS_MESSAGEFLAG_QR) != 0) { ------------------ | Branch (382:6): [True: 332, False: 817] ------------------ 383| 332| if (setquerytsig) { ------------------ | Branch (383:7): [True: 200, False: 132] ------------------ 384| 200| isc_buffer_t b; 385| 200| unsigned char hmacname[] = HMACSHA256; ------------------ | | 87| 200|#define HMACSHA256 "\x0bhmac-sha256" ------------------ 386| 200| unsigned char hmacvalue[32] = { 387| 200| 0x22, 0x4d, 0x58, 0x07, 0x64, 0x8d, 0x14, 0x00, 388| 200| 0x9d, 0x8e, 0xfc, 0x1c, 0xd0, 0x49, 0x55, 0xe9, 389| 200| 0xcc, 0x90, 0x21, 0x87, 0x3b, 0x5f, 0xaf, 0x5c, 390| 200| 0x88, 0x99, 0xdc, 0x27, 0xc8, 0xdf, 0xb3, 0x4b 391| 200| }; 392| | 393| | /* 394| | * Valid TSIG rdata for tsig-key over a plain 395| | * DNS QUERY for ./SOA/IN with no flags set. 396| | */ 397| 200| isc_buffer_init(&b, query_tsig, sizeof(query_tsig)); 398| 200| isc_buffer_putmem(&b, hmacname, sizeof(hmacname)); 399| 200| isc_buffer_putuint16(&b, 0); /* time high */ 400| 200| isc_buffer_putuint32(&b, 0x622abec0); /* time low */ 401| 200| isc_buffer_putuint16(&b, 300); /* Fudge */ 402| 200| isc_buffer_putuint16(&b, 32); /* Mac Length */ 403| | /* Mac */ 404| 200| isc_buffer_putmem(&b, hmacvalue, 32); 405| 200| isc_buffer_putuint16(&b, 7674); /* Original Id */ 406| 200| isc_buffer_putuint16(&b, 0); /* Error */ 407| 200| isc_buffer_putuint16(&b, 0); /* Other len */ 408| | 409| 200| dns_message_setquerytsig(message, &b); 410| 200| } 411| 332| } 412| | 413| 1.14k| if (settsigkey) { ------------------ | Branch (413:6): [True: 260, False: 889] ------------------ 414| 260| result = dns_message_settsigkey(message, tsigkey); 415| 260| if (debug) { ------------------ | Branch (415:7): [True: 0, False: 260] ------------------ 416| 0| fprintf(stderr, "dns_message_settsigkey => %s\n", 417| 0| isc_result_totext(result)); 418| 0| } 419| 260| } 420| | 421| 1.14k| dns_view_setkeyring(view, withring ? ring : emptyring); ------------------ | Branch (421:28): [True: 488, False: 661] ------------------ 422| | 423| 1.14k| result = dns_message_checksig(message, withview ? view : NULL); ------------------ | Branch (423:41): [True: 926, False: 223] ------------------ 424| 1.14k| if (debug) { ------------------ | Branch (424:6): [True: 0, False: 1.14k] ------------------ 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.14k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (437:6): [True: 1.07k, False: 70] ------------------ 438| 1.07k| goto cleanup; 439| 1.07k| } 440| | 441| 1.14k|cleanup: 442| 1.14k| if (message != NULL) { ------------------ | Branch (442:6): [True: 1.14k, False: 0] ------------------ 443| 1.14k| dns_message_detach(&message); 444| 1.14k| } 445| | 446| 1.14k| return 0; 447| 1.14k|} dns_message_checksig.c:create_message: 242| 1.69k| bool addasig, bool addtsig) { 243| 1.69k| isc_result_t result; 244| 1.69k| dns_message_t *message = NULL; 245| 1.69k| isc_buffer_t b; 246| 1.69k| static unsigned char buf[65535]; 247| | 248| 1.69k| isc_buffer_init(&b, buf, sizeof(buf)); 249| | 250| | /* Message ID */ 251| 1.69k| isc_buffer_putuint16(&b, 0); 252| | 253| | /* QR, Opcode, other flags = 0, rcode = 0 */ 254| 1.69k| isc_buffer_putuint16(&b, (*data & 0x1f) << 11); 255| | /* Counts */ 256| 1.69k| isc_buffer_putuint16(&b, 1); 257| 1.69k| isc_buffer_putuint16(&b, 0); 258| 1.69k| isc_buffer_putuint16(&b, 0); 259| 1.69k| isc_buffer_putuint16(&b, addasig ? 1 : 0); ------------------ | Branch (259:27): [True: 1.67k, False: 16] ------------------ 260| | 261| | /* Question ./IN/SOA */ 262| 1.69k| isc_buffer_putuint8(&b, 0); 263| 1.69k| isc_buffer_putuint16(&b, 6); 264| 1.69k| isc_buffer_putuint16(&b, 1); 265| | 266| 1.69k| if (addasig) { ------------------ | Branch (266:6): [True: 1.67k, False: 16] ------------------ 267| | /* Signature */ 268| 1.67k| if (addtsig) { ------------------ | Branch (268:7): [True: 984, False: 692] ------------------ 269| 984| const unsigned char keyname[] = "\x08tsig-key"; 270| 984| isc_buffer_putmem(&b, keyname, sizeof(keyname)); 271| 984| isc_buffer_putuint16(&b, dns_rdatatype_tsig); ------------------ | | 190| 984|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ 272| 984| isc_buffer_putuint16(&b, dns_rdataclass_any); ------------------ | | 34| 984|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ 273| 984| } else { 274| 692| isc_buffer_putuint8(&b, 0); /* '.' */ 275| 692| isc_buffer_putuint16(&b, dns_rdatatype_sig); ------------------ | | 138| 692|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ 276| 692| isc_buffer_putuint16(&b, dns_rdataclass_in); ------------------ | | 24| 692|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ 277| 692| } 278| 1.67k| isc_buffer_putuint32(&b, 0); /* ttl */ 279| 1.67k| data++; 280| 1.67k| size--; 281| 1.67k| if (size > isc_buffer_availablelength(&b) - 2) { ------------------ | | 161| 1.67k|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (281:7): [True: 10, False: 1.66k] ------------------ 282| 10| size = isc_buffer_availablelength(&b) - 2; ------------------ | | 161| 10|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 283| 10| } 284| 1.67k| isc_buffer_putuint16(&b, size); 285| 1.67k| isc_buffer_putmem(&b, data, size); 286| 1.67k| } 287| | 288| 1.69k| dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &message); 289| | 290| 1.69k| result = dns_message_parse(message, &b, 0); 291| 1.69k| if (debug) { ------------------ | Branch (291:6): [True: 0, False: 1.69k] ------------------ 292| 0| fprintf(stderr, "dns_message_parse => %s\n", 293| 0| isc_result_totext(result)); 294| 0| } 295| 1.69k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (295:6): [True: 543, False: 1.14k] ------------------ 296| 543| dns_message_detach(&message); 297| 1.14k| } else { 298| 1.14k| if (debug) { ------------------ | Branch (298:7): [True: 0, False: 1.14k] ------------------ 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.14k| *messagep = message; 312| 1.14k| } 313| 1.69k| return result; 314| 1.69k|} 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); ------------------ | | 198| 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)); ------------------ | | 144| 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])), ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 4| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 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: 470| 2|dns__acl_initialize(void) {} dns_aclenv_create: 595| 2|dns_aclenv_create(isc_mem_t *mctx, dns_aclenv_t **envp) { 596| 2| dns_aclenv_t *env = isc_mem_get(mctx, sizeof(*env)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 597| 2| *env = (dns_aclenv_t){ 598| 2| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 599| 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)) | | ------------------ ------------------ 600| 2| }; 601| | 602| 2| isc_mem_attach(mctx, &env->mctx); 603| 2| isc_refcount_init(&env->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 604| | 605| 2| dns_acl_create(mctx, 0, &env->localhost); 606| 2| dns_acl_create(mctx, 0, &env->localnets); 607| | 608| 2| *envp = env; 609| 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)); ------------------ | | 144| 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); ------------------ | | 202| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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(); \ | | | | ------------------ | | | | | | 206| 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(); \ | | | | ------------------ | | | | | | 206| 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(); \ | | | | ------------------ | | | | | | 206| 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| 200|dns_db_iscache(dns_db_t *db) { 168| | /* 169| | * Does 'db' have cache semantics? 170| | */ 171| | 172| 200| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 173| | 174| 200| if ((db->attributes & DNS_DBATTR_CACHE) != 0) { ------------------ | Branch (174:6): [True: 0, False: 200] ------------------ 175| 0| return true; 176| 0| } 177| | 178| 200| return false; 179| 200|} 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 200| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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: 503| 200| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 504| | /* 505| | * Find the best match for 'name' and 'type' in version 'version' 506| | * of 'db', passing in 'arg'. 507| | */ 508| | 509| 200| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 510| 200| REQUIRE(type != dns_rdatatype_rrsig); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 511| 200| REQUIRE(dns_name_hasbuffer(foundname)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 512| 200| REQUIRE(rdataset == NULL || (DNS_RDATASET_VALID(rdataset) && ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 0, False: 200] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 513| 200| !dns_rdataset_isassociated(rdataset))); 514| 200| REQUIRE(sigrdataset == NULL || ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((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: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 515| 200| (DNS_RDATASET_VALID(sigrdataset) && 516| 200| !dns_rdataset_isassociated(sigrdataset))); 517| | 518| 200| if (db->methods->find != NULL) { ------------------ | Branch (518:6): [True: 200, False: 0] ------------------ 519| 200| return (db->methods->find)(db, name, version, type, options, 520| 200| now, foundname, methods, clientinfo, 521| 200| rdataset, 522| 200| sigrdataset DNS__DB_FLARG_PASS); 523| 200| } 524| 0| return ISC_R_NOTIMPLEMENTED; 525| 200|} dns__db_detachnode: 541| 8|dns__db_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) { 542| | /* 543| | * Detach *nodep from its node. 544| | */ 545| | 546| 8| REQUIRE(nodep != NULL && *nodep != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 547| 8| dns_dbnode_t *node = *nodep; 548| 8| REQUIRE(node->methods != NULL && node->methods->detachnode != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 549| | 550| 8| (node->methods->detachnode)(nodep DNS__DB_FLARG_PASS); 551| | 552| 8| ENSURE(*nodep == NULL); ------------------ | | 200| 8|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 8, False: 0] | | | | ------------------ | | | | 49| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 553| 8|} dns__db_findrdataset: 596| 14| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 597| 14| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 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))) | | ------------------ ------------------ 598| 14| REQUIRE(node != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 599| 14| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 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(!dns_rdataset_isassociated(rdataset)); ------------------ | | 198| 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(covers == dns_rdatatype_none || dns_rdatatype_issig(type)); ------------------ | | 198| 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))) | | ------------------ ------------------ 602| 14| REQUIRE(type != dns_rdatatype_any); ------------------ | | 198| 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(sigrdataset == NULL || ------------------ | | 198| 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))) | | ------------------ ------------------ 604| 14| (DNS_RDATASET_VALID(sigrdataset) && 605| 14| !dns_rdataset_isassociated(sigrdataset))); 606| | 607| 14| return (db->methods->findrdataset)(db, node, version, type, covers, now, 608| 14| rdataset, 609| 14| sigrdataset DNS__DB_FLARG_PASS); 610| 14|} dns_db_nodecount: 752| 2|dns_db_nodecount(dns_db_t *db) { 753| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 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))) | | ------------------ ------------------ 754| | 755| 2| if (db->methods->nodecount != NULL) { ------------------ | Branch (755:6): [True: 2, False: 0] ------------------ 756| 2| return (db->methods->nodecount)(db); 757| 2| } 758| 0| return 0; 759| 2|} dns__db_getoriginnode: 807| 2|dns__db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { 808| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 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))) | | ------------------ ------------------ 809| 2| REQUIRE(dns_db_iszone(db)); ------------------ | | 198| 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))) | | ------------------ ------------------ 810| 2| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 198| 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| | 812| 2| if (db->methods->getoriginnode != NULL) { ------------------ | Branch (812:6): [True: 2, False: 0] ------------------ 813| 2| return (db->methods->getoriginnode)(db, 814| 2| nodep DNS__DB_FLARG_PASS); 815| 2| } else if (db->methods->findnode != NULL) { ------------------ | Branch (815:13): [True: 0, False: 0] ------------------ 816| 0| return (db->methods->findnode)(db, &db->origin, false, NULL, 817| 0| NULL, nodep DNS__DB_FLARG_PASS); 818| 0| } 819| | 820| 0| return ISC_R_NOTFOUND; 821| 2|} dns_db_setgluecachestats: 1033| 2|dns_db_setgluecachestats(dns_db_t *db, isc_stats_t *stats) { 1034| 2| REQUIRE(dns_db_iszone(db)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1035| 2| REQUIRE(stats != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1036| | 1037| 2| if (db->methods->setgluecachestats != NULL) { ------------------ | Branch (1037:6): [True: 2, False: 0] ------------------ 1038| 2| return (db->methods->setgluecachestats)(db, stats); 1039| 2| } 1040| | 1041| 0| return ISC_R_NOTIMPLEMENTED; 1042| 2|} dns_db_setmaxrrperset: 1072| 2|dns_db_setmaxrrperset(dns_db_t *db, uint32_t value) { 1073| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1074| | 1075| 2| if (db->methods->setmaxrrperset != NULL) { ------------------ | Branch (1075:6): [True: 2, False: 0] ------------------ 1076| 2| (db->methods->setmaxrrperset)(db, value); 1077| 2| } 1078| 2|} dns_db_setmaxtypepername: 1081| 2|dns_db_setmaxtypepername(dns_db_t *db, uint32_t value) { 1082| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1083| | 1084| 2| if (db->methods->setmaxtypepername != NULL) { ------------------ | Branch (1084:6): [True: 2, False: 0] ------------------ 1085| 2| (db->methods->setmaxtypepername)(db, value); 1086| 2| } 1087| 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: 896| 2|call_updatenotify(dns_db_t *db) { 897| 2| rcu_read_lock(); 898| 2| struct cds_lfht *update_listeners = 899| 2| rcu_dereference(db->update_listeners); 900| 2| if (update_listeners != NULL) { ------------------ | Branch (900:6): [True: 2, False: 0] ------------------ 901| 2| struct cds_lfht_iter iter; 902| 2| dns_dbonupdatelistener_t *listener; 903| 2| cds_lfht_for_each_entry(update_listeners, &iter, listener, ------------------ | | 133| 2| for (cds_lfht_first(ht, iter), \ | | 134| 2| pos = cds_lfht_entry(cds_lfht_iter_get_node(iter), \ | | ------------------ | | | | 129| 2| caa_container_of_check_null(ptr, type, member) | | | | ------------------ | | | | | | 122| 2| __extension__ \ | | | | | | 123| 2| ({ \ | | | | | | 124| 2| const __typeof__(((type *) NULL)->member) * __ptr = (ptr); \ | | | | | | 125| 2| (__ptr) ? (type *)((char *)__ptr - offsetof(type, member)) : NULL; \ | | | | | | ------------------ | | | | | | | Branch (125:3): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 126| 2| }) | | | | ------------------ | | ------------------ | | 135| 2| __typeof__(*(pos)), member); \ | | 136| 2| pos != NULL; \ | | ------------------ | | | Branch (136:3): [True: 0, False: 2] | | ------------------ | | 137| 2| cds_lfht_next(ht, iter), \ | | 138| 0| pos = cds_lfht_entry(cds_lfht_iter_get_node(iter), \ | | ------------------ | | | | 129| 0| caa_container_of_check_null(ptr, type, member) | | | | ------------------ | | | | | | 122| 0| __extension__ \ | | | | | | 123| 0| ({ \ | | | | | | 124| 0| const __typeof__(((type *) NULL)->member) * __ptr = (ptr); \ | | | | | | 125| 0| (__ptr) ? (type *)((char *)__ptr - offsetof(type, member)) : NULL; \ | | | | | | ------------------ | | | | | | | Branch (125:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 126| 0| }) | | | | ------------------ | | ------------------ | | 139| 2| __typeof__(*(pos)), member)) ------------------ 904| 2| ht_node) { 905| 0| if (!cds_lfht_is_node_deleted(&listener->ht_node)) { ------------------ | Branch (905:8): [True: 0, False: 0] ------------------ 906| 0| listener->onupdate(db, listener->onupdate_arg); 907| 0| } 908| 0| } 909| 2| } 910| | rcu_read_unlock(); 911| 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): ------------------ | | 52| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 4|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 4| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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): ------------------ | | 52| 12|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 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| 91| isc_mem_t *mctx, dst_key_t **key) { 127| 91| isc_buffer_t b; 128| 91| isc_region_t r; 129| | 130| 91| INSIST(DNS_NAME_VALID(name)); ------------------ | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 91, False: 0] | | | | | Branch (54:11): [True: 91, False: 0] | | | | ------------------ | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 131| 91| INSIST(rdata != NULL); ------------------ | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 91, False: 0] | | | | ------------------ | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 132| 91| INSIST(mctx != NULL); ------------------ | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 91, False: 0] | | | | ------------------ | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 133| 91| INSIST(key != NULL); ------------------ | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 91, False: 0] | | | | ------------------ | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 134| 91| INSIST(*key == NULL); ------------------ | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 91, False: 0] | | | | ------------------ | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 135| 91| REQUIRE(rdata->type == dns_rdatatype_key || ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 91, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 136| 91| rdata->type == dns_rdatatype_dnskey); 137| | 138| 91| dns_rdata_toregion(rdata, &r); 139| 91| isc_buffer_init(&b, r.base, r.length); 140| 91| isc_buffer_add(&b, r.length); 141| 91| return dst_key_fromdns(name, rdata->rdclass, &b, mctx, key); 142| 91|} dns_dnssec_verifymessage: 900| 91| dst_key_t *key) { 901| 91| dns_rdata_sig_t sig; /* SIG(0) */ 902| 91| unsigned char header[DNS_MESSAGE_HEADERLEN]; 903| 91| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 91| { \ | | 148| 91| .data = NULL, \ | | 149| 91| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 91|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 91| { \ | | | | | | 27| 91| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 91|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 91| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 91|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 91| } | | | | ------------------ | | ------------------ | | 150| 91| } ------------------ 904| 91| isc_region_t r, source_r, sig_r, header_r; 905| 91| isc_stdtime_t now; 906| 91| dst_context_t *ctx = NULL; 907| 91| isc_mem_t *mctx; 908| 91| isc_result_t result; 909| 91| uint16_t addcount, addcount_n; 910| 91| bool signeedsfree = false; 911| | 912| 91| REQUIRE(source != NULL); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 913| 91| REQUIRE(msg != NULL); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 914| 91| REQUIRE(key != NULL); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 915| | 916| 91| mctx = msg->mctx; 917| | 918| 91| msg->verify_attempted = 1; 919| 91| msg->verified_sig = 0; 920| 91| msg->sig0status = dns_tsigerror_badsig; 921| | 922| 91| if (is_response(msg)) { ------------------ | | 44| 91|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) | | ------------------ | | | Branch (44:26): [True: 1, False: 90] | | ------------------ ------------------ 923| 1| if (msg->query.base == NULL) { ------------------ | Branch (923:7): [True: 1, False: 0] ------------------ 924| 1| return DNS_R_UNEXPECTEDTSIG; 925| 1| } 926| 1| } 927| | 928| 90| isc_buffer_usedregion(source, &source_r); 929| | 930| 90| CHECK(dns_rdataset_first(msg->sig0)); ------------------ | | 255| 90| { \ | | 256| 90| result = (r); \ | | 257| 90| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 90] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 90| } ------------------ 931| 90| dns_rdataset_current(msg->sig0, &rdata); 932| | 933| 90| CHECK(dns_rdata_tostruct(&rdata, &sig, NULL)); ------------------ | | 255| 90| { \ | | 256| 90| result = (r); \ | | 257| 90| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 90] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 90| } ------------------ 934| 90| signeedsfree = true; 935| | 936| 90| if (sig.labels != 0) { ------------------ | Branch (936:6): [True: 7, False: 83] ------------------ 937| 7| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 266| 7| { \ | | 267| 7| result = (r); \ | | 268| 7| goto cleanup; \ | | 269| 7| } ------------------ 938| 0| } 939| | 940| 83| if (isc_serial_lt(sig.timeexpire, sig.timesigned)) { ------------------ | Branch (940:6): [True: 47, False: 36] ------------------ 941| 47| msg->sig0status = dns_tsigerror_badtime; 942| 47| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 266| 47| { \ | | 267| 47| result = (r); \ | | 268| 47| goto cleanup; \ | | 269| 47| } ------------------ 943| 0| } 944| | 945| 36| if (msg->fuzzing) { ------------------ | Branch (945:6): [True: 36, False: 0] ------------------ 946| 36| now = msg->fuzztime; 947| 36| } else { 948| 0| now = isc_stdtime_now(); 949| 0| } 950| | 951| 36| if (isc_serial_lt((uint32_t)now, sig.timesigned)) { ------------------ | Branch (951:6): [True: 9, False: 27] ------------------ 952| 9| msg->sig0status = dns_tsigerror_badtime; 953| 9| CLEANUP(DNS_R_SIGFUTURE); ------------------ | | 266| 9| { \ | | 267| 9| result = (r); \ | | 268| 9| goto cleanup; \ | | 269| 9| } ------------------ 954| 27| } else if (isc_serial_lt(sig.timeexpire, (uint32_t)now)) { ------------------ | Branch (954:13): [True: 18, False: 9] ------------------ 955| 18| msg->sig0status = dns_tsigerror_badtime; 956| 18| CLEANUP(DNS_R_SIGEXPIRED); ------------------ | | 266| 18| { \ | | 267| 18| result = (r); \ | | 268| 18| goto cleanup; \ | | 269| 18| } ------------------ 957| 0| } 958| | 959| 9| if (!dns_name_equal(dst_key_name(key), &sig.signer)) { ------------------ | Branch (959:6): [True: 0, False: 9] ------------------ 960| 0| msg->sig0status = dns_tsigerror_badkey; 961| 0| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 962| 0| } 963| | 964| 9| CHECK(dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, false, ------------------ | | 255| 9| { \ | | 256| 9| result = (r); \ | | 257| 9| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 9] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 9| } ------------------ 965| 9| &ctx)); 966| | 967| | /* 968| | * Digest the SIG(0) record, except for the signature. 969| | */ 970| 9| dns_rdata_toregion(&rdata, &r); 971| 9| r.length -= sig.siglen; 972| 9| CHECK(dst_context_adddata(ctx, &r)); ------------------ | | 255| 9| { \ | | 256| 9| result = (r); \ | | 257| 9| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 9] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 9| } ------------------ 973| | 974| | /* 975| | * If this is a response, digest the query. 976| | */ 977| 9| if (is_response(msg)) { ------------------ | | 44| 9|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) | | ------------------ | | | Branch (44:26): [True: 0, False: 9] | | ------------------ ------------------ 978| 0| CHECK(dst_context_adddata(ctx, &msg->query)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 979| 0| } 980| | 981| | /* 982| | * Extract the header. 983| | */ 984| 9| memmove(header, source_r.base, DNS_MESSAGE_HEADERLEN); ------------------ | | 145| 9|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 985| | 986| | /* 987| | * Decrement the additional field counter. 988| | */ 989| 9| memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2); ------------------ | | 145| 9|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 990| 9| addcount_n = ntohs(addcount); 991| 9| addcount = htons((uint16_t)(addcount_n - 1)); 992| 9| memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2); ------------------ | | 145| 9|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 993| | 994| | /* 995| | * Digest the modified header. 996| | */ 997| 9| header_r.base = (unsigned char *)header; 998| 9| header_r.length = DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 9|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 999| 9| CHECK(dst_context_adddata(ctx, &header_r)); ------------------ | | 255| 9| { \ | | 256| 9| result = (r); \ | | 257| 9| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 9] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 9| } ------------------ 1000| | 1001| | /* 1002| | * Digest all non-SIG(0) records. 1003| | */ 1004| 9| r.base = source_r.base + DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 9|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1005| 9| r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 9|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1006| 9| CHECK(dst_context_adddata(ctx, &r)); ------------------ | | 255| 9| { \ | | 256| 9| result = (r); \ | | 257| 9| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 9] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 9| } ------------------ 1007| | 1008| 9| sig_r.base = sig.signature; 1009| 9| sig_r.length = sig.siglen; 1010| 9| result = dst_context_verify(ctx, &sig_r); 1011| 9| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1011:6): [True: 8, False: 1] ------------------ 1012| 8| msg->sig0status = dns_tsigerror_badsig; 1013| 8| goto cleanup; 1014| 8| } 1015| | 1016| 1| msg->verified_sig = 1; 1017| 1| msg->sig0status = dns_rcode_noerror; ------------------ | | 269| 1|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 1018| | 1019| 1| dst_context_destroy(&ctx); 1020| 1| dns_rdata_freestruct(&sig); 1021| | 1022| 1| return ISC_R_SUCCESS; 1023| | 1024| 89|cleanup: 1025| 89| if (signeedsfree) { ------------------ | Branch (1025:6): [True: 89, False: 0] ------------------ 1026| 89| dns_rdata_freestruct(&sig); 1027| 89| } 1028| 89| if (ctx != NULL) { ------------------ | Branch (1028:6): [True: 8, False: 81] ------------------ 1029| 8| dst_context_destroy(&ctx); 1030| 8| } 1031| | 1032| 89| return result; 1033| 9|} dst__lib_initialize: 198| 2|dst__lib_initialize(void) { 199| 2| isc_mem_create("dst", &dst__mctx); ------------------ | | 236| 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: 246| 138|dst_algorithm_supported(unsigned int alg) { 247| 138| if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL) { ------------------ | Branch (247:6): [True: 0, False: 138] | Branch (247:29): [True: 0, False: 138] ------------------ 248| 0| return false; 249| 0| } 250| 138| return true; 251| 138|} dst_context_create: 268| 43| bool useforsigning, dst_context_t **dctxp) { 269| 43| dst_context_t *dctx; 270| 43| isc_result_t result; 271| | 272| 43| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 86| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 43, False: 0] | | | | | Branch (42:11): [True: 43, False: 0] | | | | ------------------ | | | | 43| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 273| 43| REQUIRE(mctx != NULL); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 43| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 43, False: 0] | | | | ------------------ | | | | 43| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 274| 43| REQUIRE(dctxp != NULL && *dctxp == NULL); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 86| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 43, False: 0] | | | | | Branch (42:11): [True: 43, False: 0] | | | | ------------------ | | | | 43| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 275| | 276| 43| if (key->func->createctx == NULL) { ------------------ | Branch (276:6): [True: 0, False: 43] ------------------ 277| 0| return DST_R_UNSUPPORTEDALG; 278| 0| } 279| 43| if (key->keydata.generic == NULL) { ------------------ | Branch (279:6): [True: 0, False: 43] ------------------ 280| 0| return DST_R_NULLKEY; 281| 0| } 282| | 283| 43| dctx = isc_mem_get(mctx, sizeof(*dctx)); ------------------ | | 144| 43|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 284| 43| *dctx = (dst_context_t){ 285| 43| .category = category, 286| 43| .use = (useforsigning) ? DO_SIGN : DO_VERIFY, ------------------ | Branch (286:10): [True: 0, False: 43] ------------------ 287| 43| }; 288| | 289| 43| dst_key_attach(key, &dctx->key); 290| 43| isc_mem_attach(mctx, &dctx->mctx); 291| 43| result = key->func->createctx(key, dctx); 292| 43| if (result != ISC_R_SUCCESS) { ------------------ | Branch (292:6): [True: 0, False: 43] ------------------ 293| 0| if (dctx->key != NULL) { ------------------ | Branch (293:7): [True: 0, False: 0] ------------------ 294| 0| dst_key_free(&dctx->key); 295| 0| } 296| 0| isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(dst_context_t)); ------------------ | | 187| 0| do { \ | | 188| 0| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 0| (p) = NULL; \ | | 190| 0| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 0] | | ------------------ ------------------ 297| 0| return result; 298| 0| } 299| 43| dctx->magic = CTX_MAGIC; ------------------ | | 54| 43|#define CTX_MAGIC ISC_MAGIC('D', 'S', 'T', 'C') | | ------------------ | | | | 31| 43|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 300| 43| *dctxp = dctx; 301| 43| return ISC_R_SUCCESS; 302| 43|} dst_context_destroy: 305| 43|dst_context_destroy(dst_context_t **dctxp) { 306| 43| dst_context_t *dctx; 307| | 308| 43| REQUIRE(dctxp != NULL && VALID_CTX(*dctxp)); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 43, False: 0] | | | | | Branch (42:11): [True: 43, False: 0] | | | | | Branch (42:11): [True: 43, False: 0] | | | | ------------------ | | | | 43| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 309| | 310| 43| dctx = *dctxp; 311| 43| *dctxp = NULL; 312| 43| INSIST(dctx->key->func->destroyctx != NULL); ------------------ | | 202| 43|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 43| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 43, False: 0] | | | | ------------------ | | | | 55| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 313| 43| dctx->key->func->destroyctx(dctx); 314| 43| if (dctx->key != NULL) { ------------------ | Branch (314:6): [True: 43, False: 0] ------------------ 315| 43| dst_key_free(&dctx->key); 316| 43| } 317| 43| dctx->magic = 0; 318| | isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(dst_context_t)); ------------------ | | 187| 43| do { \ | | 188| 43| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 43| (p) = NULL; \ | | 190| 43| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 43] | | ------------------ ------------------ 319| 43|} dst_context_adddata: 322| 254|dst_context_adddata(dst_context_t *dctx, const isc_region_t *data) { 323| 254| REQUIRE(VALID_CTX(dctx)); ------------------ | | 198| 254|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 508| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 254, False: 0] | | | | | Branch (42:11): [True: 254, False: 0] | | | | ------------------ | | | | 43| 254| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 324| 254| REQUIRE(data != NULL); ------------------ | | 198| 254|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 254| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 254, False: 0] | | | | ------------------ | | | | 43| 254| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 325| 254| INSIST(dctx->key->func->adddata != NULL); ------------------ | | 202| 254|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 254| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 254, False: 0] | | | | ------------------ | | | | 55| 254| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 326| | 327| 254| return dctx->key->func->adddata(dctx, data); 328| 254|} dst_context_verify: 354| 43|dst_context_verify(dst_context_t *dctx, isc_region_t *sig) { 355| 43| REQUIRE(VALID_CTX(dctx)); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 86| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 43, False: 0] | | | | | Branch (42:11): [True: 43, False: 0] | | | | ------------------ | | | | 43| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 356| 43| REQUIRE(sig != NULL); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 43| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 43, False: 0] | | | | ------------------ | | | | 43| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 357| | 358| 43| CHECKALG(dctx->key->key_alg); ------------------ | | 188| 43| do { \ | | 189| 43| isc_result_t _r; \ | | 190| 43| _r = algorithm_status(alg); \ | | 191| 43| if (_r != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (191:7): [True: 0, False: 43] | | ------------------ | | 192| 43| return ((_r)); \ | | 193| 43| } while (0); | | ------------------ | | | Branch (193:11): [Folded, False: 43] | | ------------------ ------------------ 359| 43| if (dctx->key->keydata.generic == NULL) { ------------------ | Branch (359:6): [True: 0, False: 43] ------------------ 360| 0| return DST_R_NULLKEY; 361| 0| } 362| | 363| 43| if (dctx->key->func->verify == NULL) { ------------------ | Branch (363:6): [True: 0, False: 43] ------------------ 364| 0| return DST_R_NOTPUBLICKEY; 365| 0| } 366| | 367| 43| return dctx->key->func->verify(dctx, sig); 368| 43|} dst_key_todns: 635| 2|dst_key_todns(const dst_key_t *key, isc_buffer_t *target) { 636| 2| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 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))) | | ------------------ ------------------ 637| 2| REQUIRE(target != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 638| | 639| 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] | | ------------------ ------------------ 640| | 641| 2| if (key->func->todns == NULL) { ------------------ | Branch (641:6): [True: 0, False: 2] ------------------ 642| 0| return DST_R_UNSUPPORTEDALG; 643| 0| } 644| | 645| 2| if (isc_buffer_availablelength(target) < 4) { ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (645:6): [True: 0, False: 2] ------------------ 646| 0| return ISC_R_NOSPACE; 647| 0| } 648| 2| isc_buffer_putuint16(target, (uint16_t)(key->key_flags & 0xffff)); 649| 2| isc_buffer_putuint8(target, (uint8_t)key->key_proto); 650| 2| isc_buffer_putuint8(target, 651| 2| (uint8_t)dst_algorithm_tosecalg(key->key_alg)); 652| | 653| 2| if (key->keydata.generic == NULL) { ------------------ | Branch (653:6): [True: 0, False: 2] ------------------ 654| 0| return ISC_R_SUCCESS; 655| 0| } 656| | 657| 2| return key->func->todns(key, target); 658| 2|} dst_key_fromdns: 662| 91| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 663| 91| uint8_t alg, proto; 664| 91| uint32_t flags; 665| 91| dst_key_t *key = NULL; 666| 91| dns_keytag_t id, rid; 667| 91| isc_region_t r; 668| | 669| 91| isc_buffer_remainingregion(source, &r); 670| | 671| 91| if (isc_buffer_remaininglength(source) < 4) { ------------------ | | 159| 91|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (671:6): [True: 0, False: 91] ------------------ 672| 0| return DST_R_INVALIDPUBLICKEY; 673| 0| } 674| 91| flags = isc_buffer_getuint16(source); 675| 91| proto = isc_buffer_getuint8(source); 676| 91| alg = isc_buffer_getuint8(source); 677| | 678| 91| id = dst_region_computeid(&r); 679| 91| rid = dst_region_computerid(&r); 680| | 681| 91| RETERR(frombuffer(name, alg, flags, proto, rdclass, source, mctx, ------------------ | | 276| 91| { \ | | 277| 91| isc_result_t _r = (x); \ | | 278| 91| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 91] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 91| } ------------------ 682| 91| &key)); 683| 91| key->key_id = id; 684| 91| key->key_rid = rid; 685| | 686| 91| *keyp = key; 687| 91| return ISC_R_SUCCESS; 688| 91|} dst_key_frombuffer: 693| 2| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 694| 2| dst_key_t *key = NULL; 695| 2| isc_result_t result; 696| | 697| 2| RETERR(frombuffer(name, alg, flags, protocol, rdclass, source, mctx, ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 698| 2| &key)); 699| | 700| 2| result = computeid(key); 701| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (701:6): [True: 0, False: 2] ------------------ 702| 0| dst_key_free(&key); 703| 0| return result; 704| 0| } 705| | 706| 2| *keyp = key; 707| 2| return ISC_R_SUCCESS; 708| 2|} dst_key_attach: 1195| 45|dst_key_attach(dst_key_t *source, dst_key_t **target) { 1196| 45| REQUIRE(target != NULL && *target == NULL); ------------------ | | 198| 45|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 90| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 45, False: 0] | | | | | Branch (42:11): [True: 45, False: 0] | | | | ------------------ | | | | 43| 45| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1197| 45| REQUIRE(VALID_KEY(source)); ------------------ | | 198| 45|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 90| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 45, False: 0] | | | | | Branch (42:11): [True: 45, False: 0] | | | | ------------------ | | | | 43| 45| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1198| | 1199| | isc_refcount_increment(&source->refs); ------------------ | | 81| 45| ({ \ | | 82| 45| uint_fast32_t __v; \ | | 83| 45| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 45| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 45| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 202| 45|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 90| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:11): [True: 45, False: 0] | | | | | | | Branch (54:11): [True: 45, False: 0] | | | | | | ------------------ | | | | | | 55| 45| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 45| __v; \ | | 86| 45| }) ------------------ 1200| 45| *target = source; 1201| 45|} dst_key_free: 1204| 136|dst_key_free(dst_key_t **keyp) { 1205| 136| REQUIRE(keyp != NULL && VALID_KEY(*keyp)); ------------------ | | 198| 136|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 544| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 136, False: 0] | | | | | Branch (42:11): [True: 136, False: 0] | | | | | Branch (42:11): [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))) | | ------------------ ------------------ 1206| 136| dst_key_t *key = *keyp; 1207| 136| *keyp = NULL; 1208| | 1209| 136| if (isc_refcount_decrement(&key->refs) == 1) { ------------------ | | 94| 136| ({ \ | | 95| 136| uint_fast32_t __v; \ | | 96| 136| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 136| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 136| INSIST(__v > 0); \ | | ------------------ | | | | 202| 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))) | | | | ------------------ | | ------------------ | | 98| 136| __v; \ | | 99| 136| }) ------------------ | Branch (1209:6): [True: 91, False: 45] ------------------ 1210| 91| isc_refcount_destroy(&key->refs); ------------------ | | 60| 91| ISC_REQUIRE(isc_refcount_current(target) == 0) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1211| 91| isc_mem_t *mctx = key->mctx; 1212| 91| if (key->keydata.generic != NULL) { ------------------ | Branch (1212:7): [True: 91, False: 0] ------------------ 1213| 91| INSIST(key->func->destroy != NULL); ------------------ | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 91, False: 0] | | | | ------------------ | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1214| 91| key->func->destroy(key); 1215| 91| } 1216| 91| if (key->directory != NULL) { ------------------ | Branch (1216:7): [True: 0, False: 91] ------------------ 1217| 0| isc_mem_free(mctx, key->directory); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1218| 0| } 1219| 91| if (key->label != NULL) { ------------------ | Branch (1219:7): [True: 0, False: 91] ------------------ 1220| 0| isc_mem_free(mctx, key->label); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1221| 0| } 1222| 91| dns_name_free(key->key_name, mctx); 1223| 91| isc_mem_put(mctx, key->key_name, sizeof(dns_name_t)); ------------------ | | 171| 91| do { \ | | 172| 91| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 91| (p) = NULL; \ | | 174| 91| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 91] | | ------------------ ------------------ 1224| 91| if (key->key_tkeytoken) { ------------------ | Branch (1224:7): [True: 0, False: 91] ------------------ 1225| 0| isc_buffer_free(&key->key_tkeytoken); 1226| 0| } 1227| 91| isc_mutex_destroy(&key->mdlock); ------------------ | | 72| 91|#define isc_mutex_destroy(mp) isc__mutex_destroy(mp) | | ------------------ | | | | 100| 91| { \ | | | | 101| 91| int _ret = pthread_mutex_destroy(mp); \ | | | | 102| 91| PTHREADS_RUNTIME_CHECK(pthread_mutex_destroy, _ret); \ | | | | ------------------ | | | | | | 288| 91| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 91] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 103| 91| } | | ------------------ ------------------ 1228| 91| isc_safe_memwipe(key, sizeof(*key)); 1229| | isc_mem_putanddetach(&mctx, key, sizeof(*key)); ------------------ | | 187| 91| do { \ | | 188| 91| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 91| (p) = NULL; \ | | 190| 91| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 91] | | ------------------ ------------------ 1230| 91| } 1231| 136|} dst_key_sigsize: 1253| 190|dst_key_sigsize(const dst_key_t *key, unsigned int *n) { 1254| 190| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 190|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 380| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 190, False: 0] | | | | | Branch (42:11): [True: 190, False: 0] | | | | ------------------ | | | | 43| 190| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1255| 190| REQUIRE(n != NULL); ------------------ | | 198| 190|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 190| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 190, False: 0] | | | | ------------------ | | | | 43| 190| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1256| | 1257| 190| switch (key->key_alg) { 1258| 0| case DST_ALG_RSASHA1: ------------------ | Branch (1258:2): [True: 0, False: 190] ------------------ 1259| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (1259:2): [True: 0, False: 190] ------------------ 1260| 0| case DST_ALG_RSASHA256: ------------------ | Branch (1260:2): [True: 0, False: 190] ------------------ 1261| 0| case DST_ALG_RSASHA512: ------------------ | Branch (1261:2): [True: 0, False: 190] ------------------ 1262| 0| *n = (key->key_size + 7) / 8; 1263| 0| break; 1264| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (1264:2): [True: 0, False: 190] ------------------ 1265| 0| *n = (key->key_size + 7) / 8 + sizeof(oid_rsasha256); 1266| 0| break; 1267| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (1267:2): [True: 0, False: 190] ------------------ 1268| 0| *n = (key->key_size + 7) / 8 + sizeof(oid_rsasha512); 1269| 0| break; 1270| 0| case DST_ALG_ECDSA256: ------------------ | Branch (1270:2): [True: 0, False: 190] ------------------ 1271| 0| *n = DNS_SIG_ECDSA256SIZE; ------------------ | | 69| 0|#define DNS_SIG_ECDSA256SIZE 64 ------------------ 1272| 0| break; 1273| 0| case DST_ALG_ECDSA384: ------------------ | Branch (1273:2): [True: 0, False: 190] ------------------ 1274| 0| *n = DNS_SIG_ECDSA384SIZE; ------------------ | | 72| 0|#define DNS_SIG_ECDSA384SIZE 96 ------------------ 1275| 0| break; 1276| 0| case DST_ALG_ED25519: ------------------ | Branch (1276:2): [True: 0, False: 190] ------------------ 1277| 0| *n = DNS_SIG_ED25519SIZE; ------------------ | | 75| 0|#define DNS_SIG_ED25519SIZE 64 ------------------ 1278| 0| break; 1279| 0| case DST_ALG_ED448: ------------------ | Branch (1279:2): [True: 0, False: 190] ------------------ 1280| 0| *n = DNS_SIG_ED448SIZE; ------------------ | | 78| 0|#define DNS_SIG_ED448SIZE 114 ------------------ 1281| 0| break; 1282| 0| case DST_ALG_HMACMD5: ------------------ | Branch (1282:2): [True: 0, False: 190] ------------------ 1283| 0| *n = ISC_MD5_DIGESTLENGTH; ------------------ | | 48| 0|#define ISC_MD5_DIGESTLENGTH 16 ------------------ 1284| 0| break; 1285| 0| case DST_ALG_HMACSHA1: ------------------ | Branch (1285:2): [True: 0, False: 190] ------------------ 1286| 0| *n = ISC_SHA1_DIGESTLENGTH; ------------------ | | 50| 0|#define ISC_SHA1_DIGESTLENGTH 20 ------------------ 1287| 0| break; 1288| 0| case DST_ALG_HMACSHA224: ------------------ | Branch (1288:2): [True: 0, False: 190] ------------------ 1289| 0| *n = ISC_SHA224_DIGESTLENGTH; ------------------ | | 52| 0|#define ISC_SHA224_DIGESTLENGTH 28 ------------------ 1290| 0| break; 1291| 190| case DST_ALG_HMACSHA256: ------------------ | Branch (1291:2): [True: 190, False: 0] ------------------ 1292| 190| *n = ISC_SHA256_DIGESTLENGTH; ------------------ | | 54| 190|#define ISC_SHA256_DIGESTLENGTH 32 ------------------ 1293| 190| break; 1294| 0| case DST_ALG_HMACSHA384: ------------------ | Branch (1294:2): [True: 0, False: 190] ------------------ 1295| 0| *n = ISC_SHA384_DIGESTLENGTH; ------------------ | | 56| 0|#define ISC_SHA384_DIGESTLENGTH 48 ------------------ 1296| 0| break; 1297| 0| case DST_ALG_HMACSHA512: ------------------ | Branch (1297:2): [True: 0, False: 190] ------------------ 1298| 0| *n = ISC_SHA512_DIGESTLENGTH; ------------------ | | 58| 0|#define ISC_SHA512_DIGESTLENGTH 64 ------------------ 1299| 0| break; 1300| 0| case DST_ALG_GSSAPI: ------------------ | Branch (1300:2): [True: 0, False: 190] ------------------ 1301| 0| *n = 128; /*%< XXX */ 1302| 0| break; 1303| 0| default: ------------------ | Branch (1303:2): [True: 0, False: 190] ------------------ 1304| 0| return DST_R_UNSUPPORTEDALG; 1305| 190| } 1306| 190| return ISC_R_SUCCESS; 1307| 190|} dst_algorithm_tosecalg: 2603| 2|dst_algorithm_tosecalg(dst_algorithm_t dst_alg) { 2604| 2| static dns_secalg_t dns_alg[DST_MAX_ALGS] = { 2605| 2| [DST_ALG_RSASHA256PRIVATEOID] = DNS_KEYALG_PRIVATEOID, 2606| 2| [DST_ALG_RSASHA512PRIVATEOID] = DNS_KEYALG_PRIVATEOID, 2607| |#if TEST_PRIVATEDNS 2608| | [DST_ALG_RSASHA256PRIVATEDNS] = DNS_KEYALG_PRIVATEDNS, 2609| | [DST_ALG_RSASHA512PRIVATEDNS] = DNS_KEYALG_PRIVATEDNS, 2610| |#endif 2611| 2| }; 2612| | 2613| 2| if (dst_alg < 256) { ------------------ | Branch (2613:6): [True: 2, False: 0] ------------------ 2614| 2| return dst_alg; 2615| 2| } 2616| 0| if (dst_alg < DST_MAX_ALGS) { ------------------ | Branch (2616:6): [True: 0, False: 0] ------------------ 2617| 0| return dns_alg[dst_alg]; 2618| 0| } 2619| 0| return 0; 2620| 0|} dst_api.c:get_key_struct: 1381| 93| dns_rdataclass_t rdclass, dns_ttl_t ttl, isc_mem_t *mctx) { 1382| 93| dst_key_t *key; 1383| | 1384| 93| key = isc_mem_get(mctx, sizeof(dst_key_t)); ------------------ | | 144| 93|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1385| 93| *key = (dst_key_t){ 1386| 93| .key_name = isc_mem_get(mctx, sizeof(dns_name_t)), ------------------ | | 144| 93|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1387| 93| .key_alg = alg, 1388| 93| .key_flags = flags, 1389| 93| .key_proto = protocol, 1390| 93| .key_size = bits, 1391| 93| .key_class = rdclass, 1392| 93| .key_ttl = ttl, 1393| 93| .func = dst_t_func[alg], 1394| 93| }; 1395| | 1396| 93| dns_name_init(key->key_name); 1397| 93| dns_name_dup(name, mctx, key->key_name); 1398| | 1399| 93| isc_refcount_init(&key->refs, 1); ------------------ | | 44| 93|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 1400| 93| isc_mem_attach(mctx, &key->mctx); 1401| | 1402| 93| isc_mutex_init(&key->mdlock); ------------------ | | 68| 93|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 93| { \ | | | | 80| 93| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 93| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 93| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 93] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 93| } | | ------------------ ------------------ 1403| | 1404| 93| key->magic = KEY_MAGIC; ------------------ | | 53| 93|#define KEY_MAGIC ISC_MAGIC('D', 'S', 'T', 'K') | | ------------------ | | | | 31| 93|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1405| 93| return key; 1406| 93|} dst_api.c:computeid: 2074| 2|computeid(dst_key_t *key) { 2075| 2| isc_buffer_t dnsbuf; 2076| 2| unsigned char dns_array[DNS_RDATA_MAXLENGTH]; 2077| 2| isc_region_t r; 2078| | 2079| 2| isc_buffer_init(&dnsbuf, dns_array, sizeof(dns_array)); 2080| 2| RETERR(dst_key_todns(key, &dnsbuf)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 2081| | 2082| 2| isc_buffer_usedregion(&dnsbuf, &r); 2083| 2| key->key_id = dst_region_computeid(&r); 2084| 2| key->key_rid = dst_region_computerid(&r); 2085| 2| return ISC_R_SUCCESS; 2086| 2|} dst_api.c:frombuffer: 2091| 93| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 2092| 93| dst_key_t *key; 2093| 93| isc_result_t result; 2094| | 2095| 93| REQUIRE(dns_name_isabsolute(name)); ------------------ | | 198| 93|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 93| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 93, False: 0] | | | | ------------------ | | | | 43| 93| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2096| 93| REQUIRE(source != NULL); ------------------ | | 198| 93|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 93| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 93, False: 0] | | | | ------------------ | | | | 43| 93| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2097| 93| REQUIRE(mctx != NULL); ------------------ | | 198| 93|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 93| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 93, False: 0] | | | | ------------------ | | | | 43| 93| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2098| 93| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 198| 93|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 186| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 93, False: 0] | | | | | Branch (42:11): [True: 93, False: 0] | | | | ------------------ | | | | 43| 93| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2099| | 2100| 93| if (alg == DNS_KEYALG_PRIVATEDNS) { ------------------ | Branch (2100:6): [True: 0, False: 93] ------------------ 2101| 0| isc_buffer_t b = *source; 2102| 0| isc_buffer_setactive(&b, isc_buffer_remaininglength(&b)); ------------------ | | 159| 0|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 2103| 0| alg = dst_algorithm_fromprivatedns(&b); 2104| 0| if (alg == 0) { ------------------ | Branch (2104:7): [True: 0, False: 0] ------------------ 2105| 0| return DST_R_UNSUPPORTEDALG; 2106| 0| } 2107| 0| } 2108| | 2109| 93| if (alg == DNS_KEYALG_PRIVATEOID) { ------------------ | Branch (2109:6): [True: 0, False: 93] ------------------ 2110| 0| isc_buffer_t b = *source; 2111| 0| alg = dst_algorithm_fromprivateoid(&b); 2112| 0| if (alg == 0) { ------------------ | Branch (2112:7): [True: 0, False: 0] ------------------ 2113| 0| return DST_R_UNSUPPORTEDALG; 2114| 0| } 2115| 0| } 2116| | 2117| 93| key = get_key_struct(name, alg, flags, protocol, 0, rdclass, 0, mctx); 2118| | 2119| 93| if (isc_buffer_remaininglength(source) > 0) { ------------------ | | 159| 93|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (2119:6): [True: 93, False: 0] ------------------ 2120| 93| result = algorithm_status(alg); 2121| 93| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2121:7): [True: 0, False: 93] ------------------ 2122| 0| dst_key_free(&key); 2123| 0| return result; 2124| 0| } 2125| 93| if (key->func->fromdns == NULL) { ------------------ | Branch (2125:7): [True: 0, False: 93] ------------------ 2126| 0| dst_key_free(&key); 2127| 0| return DST_R_UNSUPPORTEDALG; 2128| 0| } 2129| | 2130| 93| result = key->func->fromdns(key, source); 2131| 93| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2131:7): [True: 0, False: 93] ------------------ 2132| 0| dst_key_free(&key); 2133| 0| return result; 2134| 0| } 2135| 93| } 2136| | 2137| 93| *keyp = key; 2138| 93| return ISC_R_SUCCESS; 2139| 93|} dst_api.c:algorithm_status: 2142| 138|algorithm_status(unsigned int alg) { 2143| 138| if (dst_algorithm_supported(alg)) { ------------------ | Branch (2143:6): [True: 138, False: 0] ------------------ 2144| 138| return ISC_R_SUCCESS; 2145| 138| } 2146| 0| return DST_R_UNSUPPORTEDALG; 2147| 138|} 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 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.57k|dns_fixedname_init(dns_fixedname_t *fixed) { 20| 4.57k| dns_name_init(&fixed->name); 21| 4.57k| isc_buffer_init(&fixed->buffer, fixed->data, DNS_NAME_MAXWIRE); ------------------ | | 190| 4.57k|#define DNS_NAME_MAXWIRE 255 ------------------ 22| 4.57k| dns_name_setbuffer(&fixed->name, &fixed->buffer); 23| 4.57k|} dns_fixedname_name: 31| 4.36k|dns_fixedname_name(dns_fixedname_t *fixed) { 32| 4.36k| return &fixed->name; 33| 4.36k|} dns_fixedname_initname: 36| 3.93k|dns_fixedname_initname(dns_fixedname_t *fixed) { 37| 3.93k| dns_fixedname_init(fixed); 38| 3.93k| return dns_fixedname_name(fixed); 39| 3.93k|} dns_fwdtable_create: 56| 2| dns_fwdtable_t **fwdtablep) { 57| 2| dns_fwdtable_t *fwdtable = NULL; 58| | 59| 2| REQUIRE(fwdtablep != NULL && *fwdtablep == NULL); ------------------ | | 198| 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)); ------------------ | | 144| 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| 34|hmac_createctx(const dst_key_t *key, dst_context_t *dctx) { 162| 34| isc_result_t result; 163| 34| isc_hmac_t *ctx = isc_hmac_new(); /* Either returns or abort()s */ 164| | 165| 34| result = isc_hmac_init(ctx, key->keydata.hmac_key); 166| 34| if (result != ISC_R_SUCCESS) { ------------------ | Branch (166:6): [True: 0, False: 34] ------------------ 167| 0| isc_hmac_free(ctx); 168| 0| return DST_R_UNSUPPORTEDALG; 169| 0| } 170| | 171| 34| dctx->ctxdata.hmac_ctx = ctx; 172| 34| return ISC_R_SUCCESS; 173| 34|} hmac_link.c:hmac_destroyctx: 176| 34|hmac_destroyctx(dst_context_t *dctx) { 177| 34| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 178| 34| REQUIRE(ctx != NULL); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 179| | 180| 34| isc_hmac_free(ctx); 181| | dctx->ctxdata.hmac_ctx = NULL; 182| 34|} hmac_link.c:hmac_adddata: 185| 227|hmac_adddata(const dst_context_t *dctx, const isc_region_t *data) { 186| 227| isc_result_t result; 187| 227| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 188| | 189| 227| REQUIRE(ctx != NULL); ------------------ | | 198| 227|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 227| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 227, False: 0] | | | | ------------------ | | | | 43| 227| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 190| | 191| 227| result = isc_hmac_update(ctx, data->base, data->length); 192| 227| if (result != ISC_R_SUCCESS) { ------------------ | Branch (192:6): [True: 0, False: 227] ------------------ 193| 0| return DST_R_OPENSSLFAILURE; 194| 0| } 195| | 196| 227| return ISC_R_SUCCESS; 197| 227|} hmac_link.c:hmac_verify: 209| 34|hmac_verify(const dst_context_t *dctx, const isc_region_t *sig) { 210| 34| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 211| 34| unsigned char digest[ISC_MAX_MD_SIZE]; 212| 34| isc_buffer_t hmac; 213| | 214| 34| REQUIRE(ctx != NULL); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 215| | 216| 34| isc_buffer_init(&hmac, digest, sizeof(digest)); 217| | 218| 34| if (isc_hmac_final(ctx, &hmac) != ISC_R_SUCCESS) { ------------------ | Branch (218:6): [True: 0, False: 34] ------------------ 219| 0| return DST_R_OPENSSLFAILURE; 220| 0| } 221| | 222| 34| if (sig->length > isc_buffer_usedlength(&hmac)) { ------------------ | | 157| 34|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ | Branch (222:6): [True: 0, False: 34] ------------------ 223| 0| return DST_R_VERIFYFAILURE; 224| 0| } 225| | 226| 34| return isc_safe_memequal(digest, sig->base, sig->length) ------------------ | Branch (226:9): [True: 7, False: 27] ------------------ 227| 34| ? ISC_R_SUCCESS 228| 34| : DST_R_VERIFYFAILURE; 229| 34|} 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); ------------------ | | 198| 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| 34| dst_context_t *dctx) { \ 58| 34| return (hmac_createctx(key, dctx)); \ 59| 34| } \ hmac_link.c:hmacsha256_destroyctx: 60| 34| static void hmac##alg##_destroyctx(dst_context_t *dctx) { \ 61| 34| hmac_destroyctx(dctx); \ 62| 34| } \ hmac_link.c:hmacsha256_adddata: 64| 227| const isc_region_t *data) { \ 65| 227| return (hmac_adddata(dctx, data)); \ 66| 227| } \ hmac_link.c:hmacsha256_verify: 72| 34| const isc_region_t *sig) { \ 73| 34| return (hmac_verify(dctx, sig)); \ 74| 34| } \ 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| 909|dns_decompress_getpermitted(dns_decompress_t dctx) { 252| 909| return dctx == DNS_DECOMPRESS_ALWAYS || ------------------ | Branch (252:9): [True: 907, False: 2] ------------------ 253| 2| dctx == DNS_DECOMPRESS_PERMITTED; ------------------ | Branch (253:9): [True: 0, False: 2] ------------------ 254| 909|} rdata.c:dns_decompress_setpermitted: 237| 2.03k|dns_decompress_setpermitted(dns_decompress_t dctx, bool permitted) { 238| 2.03k| if (dctx == DNS_DECOMPRESS_NEVER || dctx == DNS_DECOMPRESS_ALWAYS) { ------------------ | Branch (238:6): [True: 0, False: 2.03k] | Branch (238:38): [True: 2.03k, False: 0] ------------------ 239| 2.03k| return dctx; 240| 2.03k| } 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| 2.03k|} 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.57k|dns_name_init(dns_name_t *name) { 210| 4.57k| *name = (dns_name_t){ 211| 4.57k| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 4.57k|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 4.57k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 4.57k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.57k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.57k| { \ | | | | 27| 4.57k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.57k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.57k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.57k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.57k| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 4.57k| { \ | | 22| 4.57k| .head = NULL, \ | | 23| 4.57k| .tail = NULL, \ | | 24| 4.57k| } ------------------ 214| 4.57k| }; 215| 4.57k|} fixedname.c:dns_name_setbuffer: 298| 4.57k|dns_name_setbuffer(dns_name_t *name, isc_buffer_t *buffer) { 299| 4.57k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 4.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.14k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.57k, False: 0] | | | | | Branch (42:11): [True: 4.57k, False: 0] | | | | ------------------ | | | | 43| 4.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 300| 4.57k| REQUIRE((buffer != NULL && name->buffer == NULL) || (buffer == NULL)); ------------------ | | 198| 4.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 13.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.57k, False: 0] | | | | | Branch (42:11): [True: 4.57k, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 4.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 301| | 302| 4.57k| name->buffer = buffer; 303| 4.57k|} name.c:dns_name_countlabels: 595| 10|dns_name_countlabels(const dns_name_t *name) { 596| 10| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 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| 91|dns_name_invalidate(dns_name_t *name) { 265| 91| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 91, False: 0] | | | | | Branch (42:11): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 266| | 267| 91| name->magic = 0; 268| 91| name->ndata = NULL; 269| 91| name->length = 0; 270| 91| name->attributes = (struct dns_name_attrs){}; 271| 91| name->buffer = NULL; 272| 91| ISC_LINK_INIT(name, link); ------------------ | | 57| 91|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 91| do { \ | | | | 54| 91| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 91|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 91| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 91|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 91| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 91] | | | | ------------------ | | ------------------ ------------------ 273| 91|} 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)); ------------------ | | 198| 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.56k|dns_name_init(dns_name_t *name) { 210| 4.56k| *name = (dns_name_t){ 211| 4.56k| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 4.56k|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 4.56k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 4.56k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.56k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.56k| { \ | | | | 27| 4.56k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.56k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.56k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.56k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.56k| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 4.56k| { \ | | 22| 4.56k| .head = NULL, \ | | 23| 4.56k| .tail = NULL, \ | | 24| 4.56k| } ------------------ 214| 4.56k| }; 215| 4.56k|} tsig.c:dns_name_toregion: 705| 68|dns_name_toregion(const dns_name_t *name, isc_region_t *r) { 706| 68| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 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))) | | ------------------ ------------------ 707| 68| REQUIRE(r != NULL); ------------------ | | 198| 68|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 68| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [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))) | | ------------------ ------------------ 708| | 709| 68| r->base = name->ndata; 710| 68| r->length = name->length; 711| 68|} 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| 93|dns_name_init(dns_name_t *name) { 210| 93| *name = (dns_name_t){ 211| 93| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 93|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 93|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 93| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 93|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 93| { \ | | | | 27| 93| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 93|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 93| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 93|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 93| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 93| { \ | | 22| 93| .head = NULL, \ | | 23| 93| .tail = NULL, \ | | 24| 93| } ------------------ 214| 93| }; 215| 93|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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| 84|dns_rdatatype_questiononly(dns_rdatatype_t type) { 623| 84| return (dns_rdatatype_attributes(type) & 624| 84| DNS_RDATATYPEATTR_QUESTIONONLY) != 0; 625| 84|} 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)); ------------------ | | 144| 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); ------------------ | | 180| 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); ------------------ | | 198| 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)); ------------------ | | 144| 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), ------------------ | | 167| 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)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 608| | /* 609| | * Retry. 610| | */ 611| 0| result = isc_stdio_open(j->filename, "rb+", &fp); 612| 4| } else { 613| 4| CLEANUP(ISC_R_NOTFOUND); ------------------ | | 266| 4| { \ | | 267| 4| result = (r); \ | | 268| 4| goto cleanup; \ | | 269| 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); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 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)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 631| 0| CHECK(journal_read(j, &rawheader, sizeof(rawheader))); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 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); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 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); \ | | ------------------ | | | | 202| 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); ------------------ | | 144| 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)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 677| | 678| 0| j->index = isc_mem_cget(mctx, j->header.index_size, ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 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); ------------------ | | 202| 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, ------------------ | | 176| 0| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 0| (p) = NULL; \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180: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, ------------------ | | 176| 0| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 0| (p) = NULL; \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:11): [Folded, False: 0] | | ------------------ ------------------ 720| 0| sizeof(journal_pos_t)); 721| 0| } 722| 4| isc_mem_free(j->mctx, j->filename); ------------------ | | 197| 4| do { \ | | 198| 4| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 4| (p) = NULL; \ | | 200| 4| } while (0) | | ------------------ | | | Branch (200: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)); ------------------ | | 187| 4| do { \ | | 188| 4| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 4| (p) = NULL; \ | | 190| 4| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 4] | | ------------------ ------------------ 727| 4| return result; 728| 0|} dst_region_computeid: 30| 207|dst_region_computeid(const isc_region_t *source) { 31| 207| uint32_t ac; 32| 207| const unsigned char *p; 33| 207| int size; 34| | 35| 207| REQUIRE(source != NULL); ------------------ | | 198| 207|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 207| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 207, False: 0] | | | | ------------------ | | | | 43| 207| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 36| 207| REQUIRE(source->length >= 4); ------------------ | | 198| 207|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 207| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 207, False: 0] | | | | ------------------ | | | | 43| 207| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 37| | 38| 207| p = source->base; 39| 207| size = source->length; 40| | 41| 27.2k| for (ac = 0; size > 1; size -= 2, p += 2) { ------------------ | Branch (41:15): [True: 27.0k, False: 207] ------------------ 42| 27.0k| ac += ((*p) << 8) + *(p + 1); 43| 27.0k| } 44| | 45| 207| if (size > 0) { ------------------ | Branch (45:6): [True: 0, False: 207] ------------------ 46| 0| ac += ((*p) << 8); 47| 0| } 48| 207| ac += (ac >> 16) & 0xffff; 49| | 50| 207| return (uint16_t)(ac & 0xffff); 51| 207|} dst_region_computerid: 54| 93|dst_region_computerid(const isc_region_t *source) { 55| 93| uint32_t ac; 56| 93| const unsigned char *p; 57| 93| int size; 58| | 59| 93| REQUIRE(source != NULL); ------------------ | | 198| 93|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 93| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 93, False: 0] | | | | ------------------ | | | | 43| 93| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 60| 93| REQUIRE(source->length >= 4); ------------------ | | 198| 93|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 93| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 93, False: 0] | | | | ------------------ | | | | 43| 93| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 61| | 62| 93| p = source->base; 63| 93| size = source->length; 64| | 65| 93| ac = ((*p) << 8) + *(p + 1); 66| 93| ac |= DNS_KEYFLAG_REVOKE; 67| 12.0k| for (size -= 2, p += 2; size > 1; size -= 2, p += 2) { ------------------ | Branch (67:26): [True: 11.9k, False: 93] ------------------ 68| 11.9k| ac += ((*p) << 8) + *(p + 1); 69| 11.9k| } 70| | 71| 93| if (size > 0) { ------------------ | Branch (71:6): [True: 0, False: 93] ------------------ 72| 0| ac += ((*p) << 8); 73| 0| } 74| 93| ac += (ac >> 16) & 0xffff; 75| | 76| 93| return (uint16_t)(ac & 0xffff); 77| 93|} dst_key_name: 80| 9|dst_key_name(const dst_key_t *key) { 81| 9| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 18| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 9, False: 0] | | | | | Branch (42:11): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 82| 9| return key->key_name; 83| 9|} dst_key_size: 86| 2|dst_key_size(const dst_key_t *key) { 87| 2| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 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| 192|dst_key_alg(const dst_key_t *key) { 93| 192| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 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))) | | ------------------ ------------------ 94| 192| return key->key_alg; 95| 192|} dst_key_getbits: 213| 19|dst_key_getbits(const dst_key_t *key) { 214| 19| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 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))) | | ------------------ ------------------ 215| 19| return key->key_bits; 216| 19|} 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); \ | | ------------------ | | | | 202| 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: 2550| 2| dns_ttl_t maxttl) { 2551| 2| dns_loadctx_t *lctx = NULL; 2552| 2| isc_result_t result; 2553| | 2554| 2| loadctx_create(format, mctx, options, resign, top, zclass, origin, 2555| 2| callbacks, NULL, NULL, include_cb, include_arg, NULL, 2556| 2| &lctx); 2557| | 2558| 2| lctx->maxttl = maxttl; 2559| | 2560| 2| CHECK((lctx->openfile)(lctx, master_file)); ------------------ | | 255| 2| { \ | | 256| 2| result = (r); \ | | 257| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 2] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 2| } ------------------ 2561| | 2562| 2| result = (lctx->load)(lctx); 2563| 2| INSIST(result != DNS_R_CONTINUE); ------------------ | | 202| 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))) | | ------------------ ------------------ 2564| | 2565| 2|cleanup: 2566| 2| dns_loadctx_detach(&lctx); 2567| 2| return result; 2568| 2|} dns_master_initrawheader: 2916| 2|dns_master_initrawheader(dns_masterrawheader_t *header) { 2917| 2| memset(header, 0, sizeof(dns_masterrawheader_t)); 2918| 2|} master.c:loadctx_destroy: 414| 2|loadctx_destroy(dns_loadctx_t *lctx) { 415| 2| REQUIRE(DNS_LCTX_VALID(lctx)); ------------------ | | 198| 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", ------------------ | | 217| 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)); ------------------ | | 187| 2| do { \ | | 188| 2| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 2| (p) = NULL; \ | | 190| 2| } while (0) | | ------------------ | | | Branch (190: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)); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174: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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 144| 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(); ------------------ | | 206| 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['('] = 1; 538| 2| specials[')'] = 1; 539| 2| specials['"'] = 1; 540| 2| isc_lex_setspecials(lctx->lex, specials); 541| 2| isc_lex_setcomments(lctx->lex, ISC_LEXCOMMENT_DNSMASTERFILE); ------------------ | | 97| 2|#define ISC_LEXCOMMENT_DNSMASTERFILE 0x08 ------------------ 542| 2| } 543| | 544| 2| lctx->now = isc_stdtime_now(); 545| | 546| 2| lctx->top = dns_fixedname_initname(&lctx->fixed_top); 547| 2| dns_name_toregion(top, &r); 548| 2| dns_name_fromregion(lctx->top, &r); 549| | 550| 2| dns_master_initrawheader(&lctx->header); 551| | 552| 2| isc_refcount_init(&lctx->references, 1); /* Implicit attach. */ ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 553| 2| isc_mem_attach(mctx, &lctx->mctx); 554| | 555| 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)) | | ------------------ ------------------ 556| 2| *lctxp = lctx; 557| 2| return; 558| 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)); ------------------ | | 144| 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: 966| 2|openfile_text(dns_loadctx_t *lctx, const char *master_file) { 967| 2| return isc_lex_openfile(lctx->lex, master_file); 968| 2|} master.c:load_text: 984| 2|load_text(dns_loadctx_t *lctx) { 985| 2| dns_rdataclass_t rdclass; 986| 2| dns_rdatatype_t type, covers; 987| 2| uint32_t ttl_offset = 0; 988| 2| dns_name_t *new_name = NULL; 989| 2| bool current_has_delegation = false; 990| 2| bool finish_origin = false; 991| 2| bool finish_include = false; 992| 2| bool read_till_eol = false; 993| 2| bool initialws; 994| 2| char *include_file = NULL; 995| 2| isc_token_t token; 996| 2| isc_result_t result = ISC_R_UNEXPECTED; 997| 2| rdatalist_head_t glue_list; 998| 2| rdatalist_head_t current_list; 999| 2| dns_rdatalist_t *rdatalist = NULL; 1000| 2| dns_rdatalist_t *new_rdatalist = NULL; 1001| 2| int rdlcount = 0; 1002| 2| int rdlcount_save = 0; 1003| 2| int rdatalist_size = 0; 1004| 2| isc_buffer_t buffer; 1005| 2| isc_buffer_t target; 1006| 2| isc_buffer_t target_ft; 1007| 2| isc_buffer_t target_save; 1008| 2| dns_rdata_t *rdata = NULL; 1009| 2| dns_rdata_t *new_rdata = NULL; 1010| 2| int rdcount = 0; 1011| 2| int rdcount_save = 0; 1012| 2| int rdata_size = 0; 1013| 2| unsigned char *target_mem = NULL; 1014| 2| int target_size = TSIZ; ------------------ | | 72| 2|#define TSIZ (128 * 1024) ------------------ 1015| 2| int new_in_use; 1016| 2| isc_mem_t *mctx = NULL; 1017| 2| dns_rdatacallbacks_t *callbacks = NULL; 1018| 2| dns_incctx_t *ictx = NULL; 1019| 2| char *range = NULL; 1020| 2| char *lhs = NULL; 1021| 2| char *gtype = NULL; 1022| 2| char *rhs = NULL; 1023| 2| const char *source = NULL; 1024| 2| unsigned long line = 0; 1025| 2| bool explicit_ttl; 1026| 2| char classname1[DNS_RDATACLASS_FORMATSIZE]; 1027| 2| char classname2[DNS_RDATACLASS_FORMATSIZE]; 1028| 2| unsigned int options = 0; 1029| | 1030| 2| REQUIRE(DNS_LCTX_VALID(lctx)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1031| 2| callbacks = lctx->callbacks; 1032| 2| mctx = lctx->mctx; 1033| 2| ictx = lctx->inc; 1034| | 1035| 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] | | ------------------ ------------------ 1036| 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] | | ------------------ ------------------ 1037| | 1038| | /* 1039| | * Allocate target_size of buffer space. This is greater than twice 1040| | * the maximum individual RR data size. 1041| | */ 1042| 2| target_mem = isc_mem_get(mctx, target_size); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1043| 2| isc_buffer_init(&target, target_mem, target_size); 1044| 2| target_save = target; 1045| | 1046| | /* open a database transaction */ 1047| 2| if (callbacks->setup != NULL) { ------------------ | Branch (1047:6): [True: 2, False: 0] ------------------ 1048| 2| callbacks->setup(callbacks->add_private); 1049| 2| } 1050| | 1051| 2| if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) { ------------------ | | 47| 2|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ | Branch (1051:6): [True: 0, False: 2] ------------------ 1052| 0| options |= DNS_RDATA_CHECKNAMES; ------------------ | | 210| 0|#define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES | | ------------------ | | | | 135| 0|#define DNS_NAME_CHECKNAMES 0x0002 /*%< Used by rdata. */ | | ------------------ ------------------ 1053| 0| } 1054| 2| if ((lctx->options & DNS_MASTER_CHECKNAMESFAIL) != 0) { ------------------ | | 48| 2|#define DNS_MASTER_CHECKNAMESFAIL 0x00000200 ------------------ | Branch (1054:6): [True: 0, False: 2] ------------------ 1055| 0| options |= DNS_RDATA_CHECKNAMESFAIL; ------------------ | | 211| 0|#define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL | | ------------------ | | | | 136| 0|#define DNS_NAME_CHECKNAMESFAIL 0x0004 /*%< Used by rdata. */ | | ------------------ ------------------ 1056| 0| } 1057| 2| if ((lctx->options & DNS_MASTER_CHECKMX) != 0) { ------------------ | | 52| 2|#define DNS_MASTER_CHECKMX 0x00000800 ------------------ | Branch (1057:6): [True: 0, False: 2] ------------------ 1058| 0| options |= DNS_RDATA_CHECKMX; ------------------ | | 213| 0|#define DNS_RDATA_CHECKMX DNS_NAME_CHECKMX | | ------------------ | | | | 138| 0|#define DNS_NAME_CHECKMX 0x0010 /*%< Used by rdata. */ | | ------------------ ------------------ 1059| 0| } 1060| 2| if ((lctx->options & DNS_MASTER_CHECKMXFAIL) != 0) { ------------------ | | 53| 2|#define DNS_MASTER_CHECKMXFAIL 0x00001000 ------------------ | Branch (1060:6): [True: 0, False: 2] ------------------ 1061| 0| options |= DNS_RDATA_CHECKMXFAIL; ------------------ | | 214| 0|#define DNS_RDATA_CHECKMXFAIL DNS_NAME_CHECKMXFAIL | | ------------------ | | | | 139| 0|#define DNS_NAME_CHECKMXFAIL 0x0020 /*%< Used by rdata. */ | | ------------------ ------------------ 1062| 0| } 1063| 2| source = isc_lex_getsourcename(lctx->lex); 1064| 8| while (true) { ------------------ | Branch (1064:9): [True: 8, Folded] ------------------ 1065| 8| dns_rdatalist_t *this = NULL; 1066| | 1067| 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] | | ------------------ ------------------ 1068| 0| result = ISC_R_CANCELED; 1069| 0| goto log_and_cleanup; 1070| 0| } 1071| | 1072| 8| initialws = false; 1073| 8| line = isc_lex_getsourceline(lctx->lex); 1074| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1075| 8| &token, true); 1076| 8| line = isc_lex_getsourceline(lctx->lex); 1077| | 1078| 8| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1078:7): [True: 2, False: 6] ------------------ 1079| 2| if (read_till_eol) { ------------------ | Branch (1079:8): [True: 0, False: 2] ------------------ 1080| 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] | | ------------------ ------------------ 1081| 0| } 1082| | /* Pop the include stack? */ 1083| 2| if (ictx->parent != NULL) { ------------------ | Branch (1083:8): [True: 0, False: 2] ------------------ 1084| 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] | | ------------------ ------------------ 1085| 0| lctx->inc = ictx->parent; 1086| 0| ictx->parent = NULL; 1087| 0| incctx_destroy(lctx->mctx, ictx); 1088| 0| RUNTIME_CHECK(isc_lex_close(lctx->lex) == ------------------ | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 0, False: 0] | | ------------------ ------------------ 1089| 0| ISC_R_SUCCESS); 1090| 0| line = isc_lex_getsourceline(lctx->lex); 1091| 0| POST(line); ------------------ | | 74| 0|#define POST(x) (void)(x) ------------------ 1092| 0| source = isc_lex_getsourcename(lctx->lex); 1093| 0| ictx = lctx->inc; 1094| 0| continue; 1095| 0| } 1096| 2| break; 1097| 2| } 1098| | 1099| 6| if (token.type == isc_tokentype_eol) { ------------------ | Branch (1099:7): [True: 0, False: 6] ------------------ 1100| 0| read_till_eol = false; 1101| 0| continue; /* blank line */ 1102| 0| } 1103| | 1104| 6| if (read_till_eol) { ------------------ | Branch (1104:7): [True: 0, False: 6] ------------------ 1105| 0| continue; 1106| 0| } 1107| | 1108| 6| if (token.type == isc_tokentype_initialws) { ------------------ | Branch (1108:7): [True: 0, False: 6] ------------------ 1109| | /* 1110| | * Still working on the same name. 1111| | */ 1112| 0| initialws = true; 1113| 6| } else if (token.type == isc_tokentype_string || ------------------ | Branch (1113:14): [True: 6, False: 0] ------------------ 1114| 0| token.type == isc_tokentype_qstring) ------------------ | Branch (1114:7): [True: 0, False: 0] ------------------ 1115| 6| { 1116| | /* 1117| | * "$" Support. 1118| | * 1119| | * "$ORIGIN" and "$INCLUDE" can both take domain names. 1120| | * The processing of "$ORIGIN" and "$INCLUDE" extends 1121| | * across the normal domain name processing. 1122| | */ 1123| | 1124| 6| if (strcasecmp(DNS_AS_STR(token), "$ORIGIN") == 0) { ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1124:8): [True: 0, False: 6] ------------------ 1125| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1126| 0| finish_origin = true; 1127| 6| } else if (strcasecmp(DNS_AS_STR(token), "$TTL") == 0) { ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1127:15): [True: 0, False: 6] ------------------ 1128| 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) == \ | | ------------------ | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | ------------------ | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | ------------------ | | | | | Branch (245:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 228| 0| ISC_R_SUCCESS); \ | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | 230| 0| POST(line); \ | | ------------------ | | | | 74| 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] | | ------------------ ------------------ 1129| 0| lctx->ttl = 0; 1130| 0| lctx->default_ttl_known = true;); 1131| 0| result = dns_ttl_fromtext( 1132| 0| &token.value.as_textregion, &lctx->ttl); 1133| 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] | | | | ------------------ | | ------------------ ------------------ 1134| 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| } ------------------ 1135| 0| lctx->ttl = 0; 1136| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1136:16): [True: 0, False: 0] ------------------ 1137| 0| goto insist_and_cleanup; 1138| 0| } 1139| 0| limit_ttl(callbacks, source, line, &lctx->ttl); 1140| 0| lctx->default_ttl = lctx->ttl; 1141| 0| lctx->default_ttl_known = true; 1142| 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) == \ | | | | | | ------------------ | | | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 74| 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] | | ------------------ ------------------ 1143| 0| continue; 1144| 6| } else if (strcasecmp(DNS_AS_STR(token), "$INCLUDE") == ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1144:15): [True: 0, False: 6] ------------------ 1145| 6| 0) 1146| 0| { 1147| 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] | | ------------------ ------------------ 1148| 0| if (ttl_offset != 0) { ------------------ | Branch (1148:9): [True: 0, False: 0] ------------------ 1149| 0| (callbacks->error)(callbacks, 1150| 0| "%s: %s:%lu: " 1151| 0| "$INCLUDE " 1152| 0| "may not be used " 1153| 0| "with $DATE", 1154| 0| "dns_master_load", 1155| 0| source, line); 1156| 0| result = DNS_R_SYNTAX; 1157| 0| goto insist_and_cleanup; 1158| 0| } 1159| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1160| 0| false); 1161| 0| if (include_file != NULL) { ------------------ | Branch (1161:9): [True: 0, False: 0] ------------------ 1162| 0| isc_mem_free(mctx, include_file); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1163| 0| } 1164| 0| include_file = 1165| 0| isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 167| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1166| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1167| | 1168| 0| if (token.type == isc_tokentype_eol || ------------------ | Branch (1168:9): [True: 0, False: 0] ------------------ 1169| 0| token.type == isc_tokentype_eof) ------------------ | Branch (1169:9): [True: 0, False: 0] ------------------ 1170| 0| { 1171| 0| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1171:10): [True: 0, False: 0] ------------------ 1172| 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] | | ------------------ ------------------ 1173| 0| } 1174| | /* 1175| | * No origin field. 1176| | */ 1177| 0| result = pushfile(include_file, 1178| 0| ictx->origin, lctx); 1179| 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] | | | | ------------------ | | ------------------ ------------------ 1180| 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| } ------------------ 1181| 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)) | | ------------------ ------------------ 1182| 0| continue; 1183| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1183:17): [True: 0, False: 0] ------------------ 1184| 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)) | | ------------------ ------------------ 1185| 0| goto insist_and_cleanup; 1186| 0| } 1187| 0| ictx = lctx->inc; 1188| 0| source = isc_lex_getsourcename( 1189| 0| lctx->lex); 1190| 0| line = isc_lex_getsourceline(lctx->lex); 1191| 0| POST(line); ------------------ | | 74| 0|#define POST(x) (void)(x) ------------------ 1192| 0| continue; 1193| 0| } 1194| | /* 1195| | * There is an origin field. Fall through 1196| | * to domain name processing code and do 1197| | * the actual inclusion later. 1198| | */ 1199| 0| finish_include = true; 1200| 6| } else if (strcasecmp(DNS_AS_STR(token), "$DATE") == 0) ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1200:15): [True: 0, False: 6] ------------------ 1201| 0| { 1202| 0| int64_t dump_time64; 1203| 0| isc_stdtime_t dump_time; 1204| 0| isc_stdtime_t current_time = isc_stdtime_now(); 1205| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1206| 0| result = dns_time64_fromtext(DNS_AS_STR(token), ------------------ | | 176| 0|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ 1207| 0| &dump_time64); 1208| 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] | | | | ------------------ | | ------------------ ------------------ 1209| 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| } ------------------ 1210| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 1211| 0| dump_time64 = 0; 1212| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1212:16): [True: 0, False: 0] ------------------ 1213| 0| goto log_and_cleanup; 1214| 0| } 1215| 0| dump_time = (isc_stdtime_t)dump_time64; 1216| 0| if (dump_time != dump_time64) { ------------------ | Branch (1216:9): [True: 0, False: 0] ------------------ 1217| 0| UNEXPECTED_ERROR("%s: %s:%lu: $DATE " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1218| 0| "outside epoch", 1219| 0| "dns_master_load", 1220| 0| source, line); 1221| 0| result = ISC_R_UNEXPECTED; 1222| 0| goto insist_and_cleanup; 1223| 0| } 1224| 0| if (dump_time > current_time) { ------------------ | Branch (1224:9): [True: 0, False: 0] ------------------ 1225| 0| UNEXPECTED_ERROR("%s: %s:%lu: " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1226| 0| "$DATE in future, " 1227| 0| "using current date", 1228| 0| "dns_master_load", 1229| 0| source, line); 1230| 0| dump_time = current_time; 1231| 0| } 1232| 0| ttl_offset = current_time - dump_time; 1233| 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) == \ | | | | | | ------------------ | | | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 74| 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] | | ------------------ ------------------ 1234| 0| continue; 1235| 6| } else if (strcasecmp(DNS_AS_STR(token), "$GENERATE") == ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1235:15): [True: 0, False: 6] ------------------ 1236| 6| 0) 1237| 0| { 1238| | /* 1239| | * Lazy cleanup. 1240| | */ 1241| 0| if (range != NULL) { ------------------ | Branch (1241:9): [True: 0, False: 0] ------------------ 1242| 0| isc_mem_free(mctx, range); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1243| 0| } 1244| 0| if (lhs != NULL) { ------------------ | Branch (1244:9): [True: 0, False: 0] ------------------ 1245| 0| isc_mem_free(mctx, lhs); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1246| 0| } 1247| 0| if (gtype != NULL) { ------------------ | Branch (1247:9): [True: 0, False: 0] ------------------ 1248| 0| isc_mem_free(mctx, gtype); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1249| 0| } 1250| 0| if (rhs != NULL) { ------------------ | Branch (1250:9): [True: 0, False: 0] ------------------ 1251| 0| isc_mem_free(mctx, rhs); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1252| 0| } 1253| 0| range = lhs = gtype = rhs = NULL; 1254| | /* RANGE */ 1255| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1256| 0| range = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 167| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1257| | /* LHS */ 1258| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1259| 0| lhs = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 167| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1260| 0| rdclass = 0; 1261| 0| explicit_ttl = false; 1262| | /* CLASS? */ 1263| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1264| 0| if (dns_rdataclass_fromtext( ------------------ | Branch (1264:9): [True: 0, False: 0] ------------------ 1265| 0| &rdclass, 1266| 0| &token.value.as_textregion) == 1267| 0| ISC_R_SUCCESS) 1268| 0| { 1269| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1270| 0| } 1271| | /* TTL? */ 1272| 0| if (dns_ttl_fromtext(&token.value.as_textregion, ------------------ | Branch (1272:9): [True: 0, False: 0] ------------------ 1273| 0| &lctx->ttl) == 1274| 0| ISC_R_SUCCESS) 1275| 0| { 1276| 0| limit_ttl(callbacks, source, line, 1277| 0| &lctx->ttl); 1278| 0| lctx->ttl_known = true; 1279| 0| explicit_ttl = true; 1280| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1281| 0| } 1282| | /* CLASS? */ 1283| 0| if (rdclass == 0 && ------------------ | Branch (1283:9): [True: 0, False: 0] ------------------ 1284| 0| dns_rdataclass_fromtext( ------------------ | Branch (1284:9): [True: 0, False: 0] ------------------ 1285| 0| &rdclass, 1286| 0| &token.value.as_textregion) == 1287| 0| ISC_R_SUCCESS) 1288| 0| { 1289| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1290| 0| } 1291| | /* TYPE */ 1292| 0| gtype = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 167| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1293| | /* RHS */ 1294| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1295| 0| false); 1296| 0| rhs = isc_mem_strdup(mctx, DNS_AS_STR(token)); ------------------ | | 167| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 1297| 0| if (!lctx->ttl_known && ------------------ | Branch (1297:9): [True: 0, False: 0] ------------------ 1298| 0| !lctx->default_ttl_known) ------------------ | Branch (1298:9): [True: 0, False: 0] ------------------ 1299| 0| { 1300| 0| (*callbacks->error)(callbacks, 1301| 0| "%s: %s:%lu: no " 1302| 0| "TTL specified", 1303| 0| "dns_master_load", 1304| 0| source, line); 1305| 0| result = DNS_R_NOTTL; 1306| 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] | | | | ------------------ | | ------------------ ------------------ 1307| 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| } ------------------ 1308| 0| lctx->ttl = 0; 1309| 0| } else { 1310| 0| goto insist_and_cleanup; 1311| 0| } 1312| 0| } else if (!explicit_ttl && ------------------ | Branch (1312:16): [True: 0, False: 0] ------------------ 1313| 0| lctx->default_ttl_known) ------------------ | Branch (1313:9): [True: 0, False: 0] ------------------ 1314| 0| { 1315| 0| lctx->ttl = lctx->default_ttl; 1316| 0| } 1317| | /* 1318| | * If the class specified does not match the 1319| | * zone's class print out a error message and 1320| | * exit. 1321| | */ 1322| 0| if (rdclass != 0 && rdclass != lctx->zclass) { ------------------ | Branch (1322:9): [True: 0, False: 0] | Branch (1322:25): [True: 0, False: 0] ------------------ 1323| 0| goto bad_class; 1324| 0| } 1325| 0| result = generate(lctx, range, lhs, gtype, rhs, 1326| 0| source, line); 1327| 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] | | | | ------------------ | | ------------------ ------------------ 1328| 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| } ------------------ 1329| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1329:16): [True: 0, False: 0] ------------------ 1330| 0| goto insist_and_cleanup; 1331| 0| } 1332| 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) == \ | | | | | | ------------------ | | | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 74| 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] | | ------------------ ------------------ 1333| 0| continue; 1334| 6| } else if (strncasecmp(DNS_AS_STR(token), "$", 1) == 0) ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1334:15): [True: 0, False: 6] ------------------ 1335| 0| { 1336| 0| (callbacks->error)(callbacks, 1337| 0| "%s: %s:%lu: " 1338| 0| "unknown $ directive '%s'", 1339| 0| "dns_master_load", source, 1340| 0| line, DNS_AS_STR(token)); ------------------ | | 176| 0|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ 1341| 0| result = DNS_R_SYNTAX; 1342| 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] | | | | ------------------ | | ------------------ ------------------ 1343| 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| } ------------------ 1344| 0| } else { 1345| 0| goto insist_and_cleanup; 1346| 0| } 1347| 0| } 1348| | 1349| | /* 1350| | * Normal processing resumes. 1351| | */ 1352| 6| new_in_use = find_free_name(ictx); 1353| 6| new_name = dns_fixedname_initname( 1354| 6| &ictx->fixed[new_in_use]); 1355| 6| isc_buffer_init(&buffer, token.value.as_region.base, 1356| 6| token.value.as_region.length); 1357| 6| isc_buffer_add(&buffer, token.value.as_region.length); 1358| 6| isc_buffer_setactive(&buffer, 1359| 6| token.value.as_region.length); 1360| 6| result = dns_name_fromtext(new_name, &buffer, 1361| 6| ictx->origin, 0); 1362| 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] | | | | ------------------ | | ------------------ ------------------ 1363| 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| } ------------------ 1364| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 1365| 0| read_till_eol = true; 1366| 0| continue; 1367| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1367:15): [True: 0, False: 6] ------------------ 1368| 0| goto log_and_cleanup; 1369| 0| } 1370| | 1371| | /* 1372| | * Finish $ORIGIN / $INCLUDE processing if required. 1373| | */ 1374| 6| if (finish_origin) { ------------------ | Branch (1374:8): [True: 0, False: 6] ------------------ 1375| 0| if (ictx->origin_in_use != -1) { ------------------ | Branch (1375:9): [True: 0, False: 0] ------------------ 1376| 0| ictx->in_use[ictx->origin_in_use] = 1377| 0| false; 1378| 0| } 1379| 0| ictx->origin_in_use = new_in_use; 1380| 0| ictx->in_use[ictx->origin_in_use] = true; 1381| 0| ictx->origin = new_name; 1382| 0| ictx->origin_changed = true; 1383| 0| finish_origin = false; 1384| 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) == \ | | | | | | ------------------ | | | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 74| 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] | | ------------------ ------------------ 1385| 0| continue; 1386| 0| } 1387| 6| if (finish_include) { ------------------ | Branch (1387:8): [True: 0, False: 6] ------------------ 1388| 0| finish_include = false; 1389| 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) == \ | | | | | | ------------------ | | | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | | | ------------------ | | | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 228| 0| ISC_R_SUCCESS); \ | | | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | | | 230| 0| POST(line); \ | | | | | | ------------------ | | | | | | | | 74| 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] | | ------------------ ------------------ 1390| 0| result = pushfile(include_file, new_name, lctx); 1391| 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] | | | | ------------------ | | ------------------ ------------------ 1392| 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| } ------------------ 1393| 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)) | | ------------------ ------------------ 1394| 0| continue; 1395| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1395:16): [True: 0, False: 0] ------------------ 1396| 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)) | | ------------------ ------------------ 1397| 0| goto insist_and_cleanup; 1398| 0| } 1399| 0| ictx = lctx->inc; 1400| 0| ictx->origin_changed = true; 1401| 0| source = isc_lex_getsourcename(lctx->lex); 1402| 0| line = isc_lex_getsourceline(lctx->lex); 1403| 0| POST(line); ------------------ | | 74| 0|#define POST(x) (void)(x) ------------------ 1404| 0| continue; 1405| 0| } 1406| | 1407| | /* 1408| | * "$" Processing Finished 1409| | */ 1410| | 1411| | /* 1412| | * If we are processing glue and the new name does 1413| | * not match the current glue name, commit the glue 1414| | * and pop stacks leaving us in 'normal' processing 1415| | * state. Linked lists are undone by commit(). 1416| | */ 1417| 6| if (ictx->glue != NULL && ------------------ | Branch (1417:8): [True: 0, False: 6] ------------------ 1418| 0| !dns_name_caseequal(ictx->glue, new_name)) ------------------ | Branch (1418:8): [True: 0, False: 0] ------------------ 1419| 0| { 1420| 0| result = commit(callbacks, lctx, &glue_list, 1421| 0| ictx->glue, source, 1422| 0| ictx->glue_line); 1423| 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] | | | | ------------------ | | ------------------ ------------------ 1424| 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| } ------------------ 1425| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1425:16): [True: 0, False: 0] ------------------ 1426| 0| goto insist_and_cleanup; 1427| 0| } 1428| 0| if (ictx->glue_in_use != -1) { ------------------ | Branch (1428:9): [True: 0, False: 0] ------------------ 1429| 0| ictx->in_use[ictx->glue_in_use] = false; 1430| 0| } 1431| 0| ictx->glue_in_use = -1; 1432| 0| ictx->glue = NULL; 1433| 0| rdcount = rdcount_save; 1434| 0| rdlcount = rdlcount_save; 1435| 0| target = target_save; 1436| 0| } 1437| | 1438| | /* 1439| | * If we are in 'normal' processing state and the new 1440| | * name does not match the current name, see if the 1441| | * new name is for glue and treat it as such, 1442| | * otherwise we have a new name so commit what we 1443| | * have. 1444| | */ 1445| 6| if ((ictx->glue == NULL) && ------------------ | Branch (1445:8): [True: 6, False: 0] ------------------ 1446| 6| (ictx->current == NULL || ------------------ | Branch (1446:9): [True: 2, False: 4] ------------------ 1447| 4| !dns_name_caseequal(ictx->current, new_name))) ------------------ | Branch (1447:9): [True: 0, False: 4] ------------------ 1448| 2| { 1449| 2| if (current_has_delegation && ------------------ | Branch (1449:9): [True: 0, False: 2] ------------------ 1450| 0| is_glue(¤t_list, new_name)) ------------------ | Branch (1450:9): [True: 0, False: 0] ------------------ 1451| 0| { 1452| 0| rdcount_save = rdcount; 1453| 0| rdlcount_save = rdlcount; 1454| 0| target_save = target; 1455| 0| ictx->glue = new_name; 1456| 0| ictx->glue_in_use = new_in_use; 1457| 0| ictx->in_use[ictx->glue_in_use] = true; 1458| 2| } else { 1459| 2| result = commit(callbacks, lctx, 1460| 2| ¤t_list, 1461| 2| ictx->current, source, 1462| 2| ictx->current_line); 1463| 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] | | | | ------------------ | | ------------------ ------------------ 1464| 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| } ------------------ 1465| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1465:17): [True: 0, False: 2] ------------------ 1466| 0| goto insist_and_cleanup; 1467| 0| } 1468| 2| rdcount = 0; 1469| 2| rdlcount = 0; 1470| 2| if (ictx->current_in_use != -1) { ------------------ | Branch (1470:10): [True: 0, False: 2] ------------------ 1471| 0| ictx->in_use 1472| 0| [ictx->current_in_use] = 1473| 0| false; 1474| 0| } 1475| 2| ictx->current_in_use = new_in_use; 1476| 2| ictx->in_use[ictx->current_in_use] = 1477| 2| true; 1478| 2| ictx->current = new_name; 1479| 2| current_has_delegation = false; 1480| 2| isc_buffer_init(&target, target_mem, 1481| 2| target_size); 1482| 2| } 1483| | /* 1484| | * Check for internal wildcards. 1485| | */ 1486| 2| if ((lctx->options & ------------------ | Branch (1486:9): [True: 0, False: 2] ------------------ 1487| 2| DNS_MASTER_CHECKWILDCARD) != 0) ------------------ | | 50| 2| 0x00000400 /* Check for internal wildcards. \ ------------------ 1488| 0| { 1489| 0| check_wildcard(ictx, source, line, 1490| 0| callbacks); 1491| 0| } 1492| 2| } 1493| 6| if (dns_master_isprimary(lctx) && ------------------ | Branch (1493:8): [True: 6, False: 0] ------------------ 1494| 6| !dns_name_issubdomain(new_name, lctx->top)) ------------------ | Branch (1494:8): [True: 0, False: 6] ------------------ 1495| 0| { 1496| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1497| 0| dns_name_format(new_name, namebuf, 1498| 0| sizeof(namebuf)); 1499| | /* 1500| | * Ignore out-of-zone data. 1501| | */ 1502| 0| (*callbacks->warn)(callbacks, 1503| 0| "%s:%lu: " 1504| 0| "ignoring out-of-zone data " 1505| 0| "(%s)", 1506| 0| source, line, namebuf); 1507| 0| ictx->drop = true; 1508| 6| } else { 1509| 6| ictx->drop = false; 1510| 6| } 1511| 6| } else { 1512| 0| UNEXPECTED_ERROR("%s:%lu: isc_lex_gettoken() returned " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1513| 0| "unexpected token type (%d)", 1514| 0| source, line, token.type); 1515| 0| result = ISC_R_UNEXPECTED; 1516| 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] | | | | ------------------ | | ------------------ ------------------ 1517| 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| } ------------------ 1518| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 1519| 0| continue; 1520| 0| } else { 1521| 0| goto insist_and_cleanup; 1522| 0| } 1523| 0| } 1524| | 1525| | /* 1526| | * Find TTL, class and type. Both TTL and class are optional 1527| | * and may occur in any order if they exist. TTL and class 1528| | * come before type which must exist. 1529| | * 1530| | * [] [] 1531| | * [] [] 1532| | */ 1533| | 1534| 6| type = dns_rdatatype_none; ------------------ | | 114| 6|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1535| 6| rdclass = 0; 1536| | 1537| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1538| | 1539| 6| if (initialws) { ------------------ | Branch (1539:7): [True: 0, False: 6] ------------------ 1540| 0| if (token.type == isc_tokentype_eol) { ------------------ | Branch (1540:8): [True: 0, False: 0] ------------------ 1541| 0| read_till_eol = false; 1542| 0| continue; /* blank line */ 1543| 0| } 1544| | 1545| 0| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1545:8): [True: 0, False: 0] ------------------ 1546| 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] | | ------------------ ------------------ 1547| 0| read_till_eol = false; 1548| 0| isc_lex_ungettoken(lctx->lex, &token); 1549| 0| continue; 1550| 0| } 1551| | 1552| 0| if (ictx->current == NULL) { ------------------ | Branch (1552:8): [True: 0, False: 0] ------------------ 1553| 0| (*callbacks->error)(callbacks, 1554| 0| "%s:%lu: no current owner " 1555| 0| "name", 1556| 0| source, line); 1557| 0| result = DNS_R_NOOWNER; 1558| 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] | | | | ------------------ | | ------------------ ------------------ 1559| 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| } ------------------ 1560| 0| read_till_eol = true; 1561| 0| continue; 1562| 0| } else { 1563| 0| goto insist_and_cleanup; 1564| 0| } 1565| 0| } 1566| | 1567| 0| if (ictx->origin_changed) { ------------------ | Branch (1567:8): [True: 0, False: 0] ------------------ 1568| 0| char cbuf[DNS_NAME_FORMATSIZE]; 1569| 0| char obuf[DNS_NAME_FORMATSIZE]; 1570| 0| dns_name_format(ictx->current, cbuf, 1571| 0| sizeof(cbuf)); 1572| 0| dns_name_format(ictx->origin, obuf, 1573| 0| sizeof(obuf)); 1574| 0| (*callbacks->warn)(callbacks, 1575| 0| "%s:%lu: record with " 1576| 0| "inherited " 1577| 0| "owner (%s) immediately " 1578| 0| "after " 1579| 0| "$ORIGIN (%s)", 1580| 0| source, line, cbuf, obuf); 1581| 0| } 1582| 0| } 1583| | 1584| 6| ictx->origin_changed = false; 1585| | 1586| 6| if (dns_rdataclass_fromtext(&rdclass, ------------------ | Branch (1586:7): [True: 0, False: 6] ------------------ 1587| 6| &token.value.as_textregion) == 1588| 6| ISC_R_SUCCESS) 1589| 0| { 1590| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1591| 0| } 1592| | 1593| 6| explicit_ttl = false; 1594| 6| result = dns_ttl_fromtext(&token.value.as_textregion, 1595| 6| &lctx->ttl); 1596| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1596:7): [True: 6, False: 0] ------------------ 1597| 6| limit_ttl(callbacks, source, line, &lctx->ttl); 1598| 6| explicit_ttl = true; 1599| 6| lctx->ttl_known = true; 1600| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1601| 6| } 1602| | 1603| 6| if (token.type != isc_tokentype_string) { ------------------ | Branch (1603:7): [True: 0, False: 6] ------------------ 1604| 0| UNEXPECTED_ERROR("isc_lex_gettoken() returned " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1605| 0| "unexpected token type"); 1606| 0| result = ISC_R_UNEXPECTED; 1607| 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] | | | | ------------------ | | ------------------ ------------------ 1608| 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| } ------------------ 1609| 0| read_till_eol = true; 1610| 0| continue; 1611| 0| } else { 1612| 0| goto insist_and_cleanup; 1613| 0| } 1614| 0| } 1615| | 1616| 6| if (rdclass == 0 && ------------------ | Branch (1616:7): [True: 6, False: 0] ------------------ 1617| 6| dns_rdataclass_fromtext(&rdclass, ------------------ | Branch (1617:7): [True: 6, False: 0] ------------------ 1618| 6| &token.value.as_textregion) == 1619| 6| ISC_R_SUCCESS) 1620| 6| { 1621| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1622| 6| } 1623| | 1624| 6| if (token.type != isc_tokentype_string) { ------------------ | Branch (1624:7): [True: 0, False: 6] ------------------ 1625| 0| UNEXPECTED_ERROR("isc_lex_gettoken() returned " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1626| 0| "unexpected token type"); 1627| 0| result = ISC_R_UNEXPECTED; 1628| 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] | | | | ------------------ | | ------------------ ------------------ 1629| 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| } ------------------ 1630| 0| read_till_eol = true; 1631| 0| continue; 1632| 0| } else { 1633| 0| goto insist_and_cleanup; 1634| 0| } 1635| 0| } 1636| | 1637| 6| result = dns_rdatatype_fromtext(&type, 1638| 6| &token.value.as_textregion); 1639| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1639:7): [True: 0, False: 6] ------------------ 1640| 0| (*callbacks->warn)( 1641| 0| callbacks, "%s:%lu: unknown RR type '%.*s'", 1642| 0| source, line, token.value.as_textregion.length, 1643| 0| token.value.as_textregion.base); 1644| 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] | | | | ------------------ | | ------------------ ------------------ 1645| 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| } ------------------ 1646| 0| read_till_eol = true; 1647| 0| continue; 1648| 0| } else { 1649| 0| goto insist_and_cleanup; 1650| 0| } 1651| 0| } 1652| | 1653| | /* 1654| | * If the class specified does not match the zone's class 1655| | * print out a error message and exit. 1656| | */ 1657| 6| if (rdclass != 0 && rdclass != lctx->zclass) { ------------------ | Branch (1657:7): [True: 6, False: 0] | Branch (1657:23): [True: 0, False: 6] ------------------ 1658| 0| bad_class: 1659| | 1660| 0| dns_rdataclass_format(rdclass, classname1, 1661| 0| sizeof(classname1)); 1662| 0| dns_rdataclass_format(lctx->zclass, classname2, 1663| 0| sizeof(classname2)); 1664| 0| (*callbacks->error)(callbacks, 1665| 0| "%s:%lu: class '%s' != " 1666| 0| "zone class '%s'", 1667| 0| source, line, classname1, 1668| 0| classname2); 1669| 0| result = DNS_R_BADCLASS; 1670| 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] | | | | ------------------ | | ------------------ ------------------ 1671| 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| } ------------------ 1672| 0| read_till_eol = true; 1673| 0| continue; 1674| 0| } else { 1675| 0| goto insist_and_cleanup; 1676| 0| } 1677| 0| } 1678| | 1679| 6| if (type == dns_rdatatype_ns && ictx->glue == NULL) { ------------------ | | 116| 12|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (1679:7): [True: 2, False: 4] | Branch (1679:35): [True: 2, False: 0] ------------------ 1680| 2| current_has_delegation = true; 1681| 2| } 1682| | 1683| | /* 1684| | * RFC1123: MD and MF are not allowed to be loaded from 1685| | * master files. 1686| | */ 1687| 6| if (dns_master_isprimary(lctx) && ------------------ | Branch (1687:7): [True: 6, False: 0] ------------------ 1688| 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 (1688:8): [True: 0, False: 6] | Branch (1688:36): [True: 0, False: 6] ------------------ 1689| 0| { 1690| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1691| | 1692| 0| result = DNS_R_OBSOLETE; 1693| | 1694| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1695| 0| (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s", 1696| 0| source, line, "type", typebuf, 1697| 0| isc_result_totext(result)); 1698| 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] | | | | ------------------ | | ------------------ ------------------ 1699| 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| } ------------------ 1700| 0| } else { 1701| 0| goto insist_and_cleanup; 1702| 0| } 1703| 0| } 1704| | 1705| | /* 1706| | * RFC2930: TKEY and TSIG are not allowed to be loaded 1707| | * from master files. 1708| | */ 1709| 6| if (dns_master_isprimary(lctx) && dns_rdatatype_ismeta(type)) { ------------------ | Branch (1709:7): [True: 6, False: 0] | Branch (1709:37): [True: 0, False: 6] ------------------ 1710| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1711| | 1712| 0| result = DNS_R_METATYPE; 1713| | 1714| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1715| 0| (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s", 1716| 0| source, line, "type", typebuf, 1717| 0| isc_result_totext(result)); 1718| 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] | | | | ------------------ | | ------------------ ------------------ 1719| 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| } ------------------ 1720| 0| } else { 1721| 0| goto insist_and_cleanup; 1722| 0| } 1723| 0| } 1724| | 1725| | /* 1726| | * Find a rdata structure. 1727| | */ 1728| 6| if (rdcount == rdata_size) { ------------------ | Branch (1728:7): [True: 2, False: 4] ------------------ 1729| 2| new_rdata = grow_rdata(rdata_size + RDSZ, rdata, ------------------ | | 61| 2|#define RDSZ 512 ------------------ 1730| 2| rdata_size, ¤t_list, 1731| 2| &glue_list, mctx); 1732| 2| rdata_size += RDSZ; ------------------ | | 61| 2|#define RDSZ 512 ------------------ 1733| 2| rdata = new_rdata; 1734| 2| } 1735| | 1736| | /* 1737| | * Peek at the NS record. 1738| | */ 1739| 6| if (type == dns_rdatatype_ns && ------------------ | | 116| 12|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (1739:7): [True: 2, False: 4] ------------------ 1740| 2| lctx->zclass == dns_rdataclass_in && ------------------ | | 24| 8|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (1740:7): [True: 2, False: 0] ------------------ 1741| 2| (lctx->options & DNS_MASTER_CHECKNS) != 0) ------------------ | | 38| 2| 0x00000040 /*%< \ ------------------ | Branch (1741:7): [True: 0, False: 2] ------------------ 1742| 0| { 1743| 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) == \ | | | | ------------------ | | | | | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | | | | | ------------------ | | | | | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | | | | | ------------------ | | | | | | | Branch (245:3): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 228| 0| ISC_R_SUCCESS); \ | | | | 229| 0| line = isc_lex_getsourceline(lctx->lex); \ | | | | 230| 0| POST(line); \ | | | | ------------------ | | | | | | 74| 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] | | | | ------------------ | | ------------------ ------------------ 1744| 0| result = check_ns(lctx, &token, source, line); 1745| 0| isc_lex_ungettoken(lctx->lex, &token); 1746| 0| if ((lctx->options & DNS_MASTER_FATALNS) != 0) { ------------------ | | 43| 0| 0x00000080 /*%< \ ------------------ | Branch (1746:8): [True: 0, False: 0] ------------------ 1747| 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] | | | | ------------------ | | ------------------ ------------------ 1748| 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| } ------------------ 1749| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1749:16): [True: 0, False: 0] ------------------ 1750| 0| goto insist_and_cleanup; 1751| 0| } 1752| 0| } 1753| 0| } 1754| | 1755| | /* 1756| | * Check owner name. 1757| | */ 1758| 6| options &= ~DNS_RDATA_CHECKREVERSE; ------------------ | | 212| 6|#define DNS_RDATA_CHECKREVERSE DNS_NAME_CHECKREVERSE | | ------------------ | | | | 137| 6|#define DNS_NAME_CHECKREVERSE 0x0008 /*%< Used by rdata. */ | | ------------------ ------------------ 1759| 6| if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) { ------------------ | | 47| 6|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ | Branch (1759:7): [True: 0, False: 6] ------------------ 1760| 0| bool ok; 1761| 0| dns_name_t *name; 1762| | 1763| 0| name = (ictx->glue != NULL) ? ictx->glue ------------------ | Branch (1763:11): [True: 0, False: 0] ------------------ 1764| 0| : ictx->current; 1765| 0| ok = dns_rdata_checkowner(name, lctx->zclass, type, 1766| 0| true); 1767| 0| if (!ok) { ------------------ | Branch (1767:8): [True: 0, False: 0] ------------------ 1768| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1769| 0| const char *desc; 1770| 0| dns_name_format(name, namebuf, sizeof(namebuf)); 1771| 0| result = DNS_R_BADOWNERNAME; 1772| 0| desc = isc_result_totext(result); 1773| 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] | | ------------------ ------------------ 1774| 0| type == dns_rdatatype_nsec3) ------------------ | | 164| 0|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1774:9): [True: 0, False: 0] ------------------ 1775| 0| { 1776| 0| (*callbacks->error)( 1777| 0| callbacks, "%s:%lu: %s: %s", 1778| 0| source, line, namebuf, desc); 1779| 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] | | | | ------------------ | | ------------------ ------------------ 1780| 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| } ------------------ 1781| 0| } else { 1782| 0| goto cleanup; 1783| 0| } 1784| 0| } else { 1785| 0| (*callbacks->warn)( 1786| 0| callbacks, "%s:%lu: %s: %s", 1787| 0| source, line, namebuf, desc); 1788| 0| } 1789| 0| } 1790| 0| if (type == dns_rdatatype_ptr && ------------------ | | 126| 0|#define dns_rdatatype_ptr ((dns_rdatatype_t)dns_rdatatype_ptr) ------------------ | Branch (1790:8): [True: 0, False: 0] ------------------ 1791| 0| !dns_name_isdnssd(name) && ------------------ | Branch (1791:8): [True: 0, False: 0] ------------------ 1792| 0| (dns_name_issubdomain(name, &in_addr_arpa) || ------------------ | Branch (1792:9): [True: 0, False: 0] ------------------ 1793| 0| dns_name_issubdomain(name, &ip6_arpa) || ------------------ | Branch (1793:9): [True: 0, False: 0] ------------------ 1794| 0| dns_name_issubdomain(name, &ip6_int))) ------------------ | Branch (1794:9): [True: 0, False: 0] ------------------ 1795| 0| { 1796| 0| options |= DNS_RDATA_CHECKREVERSE; ------------------ | | 212| 0|#define DNS_RDATA_CHECKREVERSE DNS_NAME_CHECKREVERSE | | ------------------ | | | | 137| 0|#define DNS_NAME_CHECKREVERSE 0x0008 /*%< Used by rdata. */ | | ------------------ ------------------ 1797| 0| } 1798| 0| } 1799| | 1800| | /* 1801| | * Read rdata contents. 1802| | */ 1803| 6| dns_rdata_init(&rdata[rdcount]); 1804| 6| target_ft = target; 1805| 6| result = dns_rdata_fromtext(&rdata[rdcount], lctx->zclass, type, 1806| 6| lctx->lex, ictx->origin, options, 1807| 6| lctx->mctx, &target, callbacks); 1808| 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] | | | | ------------------ | | ------------------ ------------------ 1809| 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| } ------------------ 1810| 0| continue; 1811| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1811:14): [True: 0, False: 6] ------------------ 1812| 0| goto insist_and_cleanup; 1813| 0| } 1814| | 1815| 6| if (ictx->drop) { ------------------ | Branch (1815:7): [True: 0, False: 6] ------------------ 1816| 0| target = target_ft; 1817| 0| continue; 1818| 0| } 1819| | 1820| 6| if (type == dns_rdatatype_soa && ------------------ | | 120| 12|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (1820:7): [True: 2, False: 4] ------------------ 1821| 2| (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 2|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (1821:7): [True: 2, False: 0] ------------------ 1822| 2| !dns_name_equal(ictx->current, lctx->top)) ------------------ | Branch (1822:7): [True: 0, False: 2] ------------------ 1823| 0| { 1824| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1825| 0| dns_name_format(ictx->current, namebuf, 1826| 0| sizeof(namebuf)); 1827| 0| (*callbacks->error)(callbacks, 1828| 0| "%s:%lu: SOA " 1829| 0| "record not at top of zone (%s)", 1830| 0| source, line, namebuf); 1831| 0| result = DNS_R_NOTZONETOP; 1832| 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] | | | | ------------------ | | ------------------ ------------------ 1833| 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| } ------------------ 1834| 0| read_till_eol = true; 1835| 0| target = target_ft; 1836| 0| continue; 1837| 0| } else { 1838| 0| goto insist_and_cleanup; 1839| 0| } 1840| 0| } 1841| | 1842| 6| if (type == dns_rdatatype_svcb && ------------------ | | 177| 12|#define dns_rdatatype_svcb ((dns_rdatatype_t)dns_rdatatype_svcb) ------------------ | Branch (1842:7): [True: 0, False: 6] ------------------ 1843| 0| (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 0|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (1843:7): [True: 0, False: 0] ------------------ 1844| 0| (lctx->options & DNS_MASTER_CHECKSVCB) != 0) ------------------ | | 59| 0|#define DNS_MASTER_CHECKSVCB 0x00020000 /*%< Check SVBC records */ ------------------ | Branch (1844:7): [True: 0, False: 0] ------------------ 1845| 0| { 1846| 0| result = dns_rdata_checksvcb(ictx->current, 1847| 0| &rdata[rdcount]); 1848| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1848:8): [True: 0, False: 0] ------------------ 1849| 0| (*callbacks->error)(callbacks, 1850| 0| "%s:%lu: SVCB " 1851| 0| "record not valid: %s", 1852| 0| source, line, 1853| 0| isc_result_totext(result)); 1854| 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] | | | | ------------------ | | ------------------ ------------------ 1855| 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| } ------------------ 1856| 0| target = target_ft; 1857| 0| continue; 1858| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1858:16): [True: 0, False: 0] ------------------ 1859| 0| goto insist_and_cleanup; 1860| 0| } 1861| 0| } 1862| 0| } 1863| | 1864| 6| if (dns_rdatatype_atparent(type) && ------------------ | Branch (1864:7): [True: 0, False: 6] ------------------ 1865| 0| dns_master_isprimary(lctx) && ------------------ | Branch (1865:7): [True: 0, False: 0] ------------------ 1866| 0| dns_name_equal(ictx->current, lctx->top)) ------------------ | Branch (1866:7): [True: 0, False: 0] ------------------ 1867| 0| { 1868| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1869| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1870| | 1871| 0| dns_name_format(ictx->current, namebuf, 1872| 0| sizeof(namebuf)); 1873| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1874| 0| (*callbacks->error)( 1875| 0| callbacks, 1876| 0| "%s:%lu: %s record at top of zone (%s)", source, 1877| 0| line, typebuf, namebuf); 1878| 0| result = DNS_R_ATZONETOP; 1879| 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] | | | | ------------------ | | ------------------ ------------------ 1880| 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| } ------------------ 1881| 0| target = target_ft; 1882| 0| continue; 1883| 0| } else { 1884| 0| goto insist_and_cleanup; 1885| 0| } 1886| 0| } 1887| | 1888| 6| if (dns_rdatatype_issig(type)) { ------------------ | Branch (1888:7): [True: 0, False: 6] ------------------ 1889| 0| covers = dns_rdata_covers(&rdata[rdcount]); 1890| 6| } else { 1891| 6| covers = dns_rdatatype_none; ------------------ | | 114| 6|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1892| 6| } 1893| | 1894| 6| if (!lctx->ttl_known && !lctx->default_ttl_known) { ------------------ | Branch (1894:7): [True: 0, False: 6] | Branch (1894:27): [True: 0, False: 0] ------------------ 1895| 0| if (type == dns_rdatatype_soa) { ------------------ | | 120| 0|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (1895:8): [True: 0, False: 0] ------------------ 1896| 0| (*callbacks->warn)(callbacks, 1897| 0| "%s:%lu: no TTL specified; " 1898| 0| "using SOA MINTTL instead", 1899| 0| source, line); 1900| 0| lctx->ttl = dns_soa_getminimum(&rdata[rdcount]); 1901| 0| limit_ttl(callbacks, source, line, &lctx->ttl); 1902| 0| lctx->default_ttl = lctx->ttl; 1903| 0| lctx->default_ttl_known = true; 1904| 0| } else if ((lctx->options & DNS_MASTER_HINT) != 0) { ------------------ | | 35| 0|#define DNS_MASTER_HINT 0x00000010 /*%< Loading a hint master file. */ ------------------ | Branch (1904:15): [True: 0, False: 0] ------------------ 1905| | /* 1906| | * Zero TTL's are fine for hints. 1907| | */ 1908| 0| lctx->ttl = 0; 1909| 0| lctx->default_ttl = lctx->ttl; 1910| 0| lctx->default_ttl_known = true; 1911| 0| } else { 1912| 0| (*callbacks->warn)(callbacks, 1913| 0| "%s:%lu: no TTL specified; " 1914| 0| "zone rejected", 1915| 0| source, line); 1916| 0| result = DNS_R_NOTTL; 1917| 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] | | | | ------------------ | | ------------------ ------------------ 1918| 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| } ------------------ 1919| 0| lctx->ttl = 0; 1920| 0| } else { 1921| 0| goto insist_and_cleanup; 1922| 0| } 1923| 0| } 1924| 6| } else if (!explicit_ttl && lctx->default_ttl_known) { ------------------ | Branch (1924:14): [True: 0, False: 6] | Branch (1924:31): [True: 0, False: 0] ------------------ 1925| 0| lctx->ttl = lctx->default_ttl; 1926| 6| } else if (!explicit_ttl && lctx->warn_1035) { ------------------ | Branch (1926:14): [True: 0, False: 6] | Branch (1926:31): [True: 0, False: 0] ------------------ 1927| 0| (*callbacks->warn)(callbacks, 1928| 0| "%s:%lu: " 1929| 0| "using RFC1035 TTL semantics", 1930| 0| source, line); 1931| 0| lctx->warn_1035 = false; 1932| 0| } 1933| | 1934| 6| if (type == dns_rdatatype_rrsig && lctx->warn_sigexpired) { ------------------ | | 160| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1934:7): [True: 0, False: 6] | Branch (1934:38): [True: 0, False: 0] ------------------ 1935| 0| dns_rdata_rrsig_t sig; 1936| 0| result = dns_rdata_tostruct(&rdata[rdcount], &sig, 1937| 0| NULL); 1938| 0| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 0, False: 0] | | ------------------ ------------------ 1939| 0| if (isc_serial_lt(sig.timeexpire, lctx->now)) { ------------------ | Branch (1939:8): [True: 0, False: 0] ------------------ 1940| 0| (*callbacks->warn)(callbacks, 1941| 0| "%s:%lu: " 1942| 0| "signature has expired", 1943| 0| source, line); 1944| 0| lctx->warn_sigexpired = false; 1945| 0| } 1946| 0| } 1947| | 1948| 6| if ((lctx->options & DNS_MASTER_AGETTL) != 0) { ------------------ | | 30| 6|#define DNS_MASTER_AGETTL 0x00000001 /*%< Age the ttl based on $DATE. */ ------------------ | Branch (1948:7): [True: 0, False: 6] ------------------ 1949| | /* 1950| | * Adjust the TTL for $DATE. If the RR has 1951| | * already expired, set its TTL to 0. This 1952| | * should be okay even if the TTL stretching 1953| | * feature is not in effect, because it will 1954| | * just be quickly expired by the cache, and the 1955| | * way this was written before the patch it 1956| | * could potentially add 0 TTLs anyway. 1957| | */ 1958| 0| if (lctx->ttl < ttl_offset) { ------------------ | Branch (1958:8): [True: 0, False: 0] ------------------ 1959| 0| lctx->ttl = 0; 1960| 0| } else { 1961| 0| lctx->ttl -= ttl_offset; 1962| 0| } 1963| 0| } 1964| | 1965| | /* 1966| | * Find type in rdatalist. 1967| | * If it does not exist create new one and prepend to list 1968| | * as this will minimise list traversal. 1969| | */ 1970| 6| if (ictx->glue != NULL) { ------------------ | Branch (1970:7): [True: 0, False: 6] ------------------ 1971| 0| this = ISC_LIST_HEAD(glue_list); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1972| 6| } else { 1973| 6| this = ISC_LIST_HEAD(current_list); ------------------ | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1974| 6| } 1975| | 1976| 12| while (this != NULL) { ------------------ | Branch (1976:10): [True: 6, False: 6] ------------------ 1977| 6| if (this->type == type && this->covers == covers) { ------------------ | Branch (1977:8): [True: 0, False: 6] | Branch (1977:30): [True: 0, False: 0] ------------------ 1978| 0| break; 1979| 0| } 1980| 6| this = ISC_LIST_NEXT(this, link); ------------------ | | 140| 6|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 1981| 6| } 1982| | 1983| 6| if (this == NULL) { ------------------ | Branch (1983:7): [True: 6, False: 0] ------------------ 1984| 6| if (rdlcount == rdatalist_size) { ------------------ | Branch (1984:8): [True: 2, False: 4] ------------------ 1985| 2| new_rdatalist = grow_rdatalist( 1986| 2| rdatalist_size + RDLSZ, rdatalist, ------------------ | | 56| 2|#define RDLSZ 32 ------------------ 1987| 2| rdatalist_size, ¤t_list, 1988| 2| &glue_list, mctx); 1989| 2| rdatalist = new_rdatalist; 1990| 2| rdatalist_size += RDLSZ; ------------------ | | 56| 2|#define RDLSZ 32 ------------------ 1991| 2| } 1992| 6| this = &rdatalist[rdlcount++]; 1993| 6| dns_rdatalist_init(this); 1994| 6| this->type = type; 1995| 6| this->covers = covers; 1996| 6| this->rdclass = lctx->zclass; 1997| 6| this->ttl = lctx->ttl; 1998| 6| if (ictx->glue != NULL) { ------------------ | Branch (1998:8): [True: 0, False: 6] ------------------ 1999| 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] | | | | ------------------ | | ------------------ ------------------ 2000| 6| } else { 2001| 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] | | | | ------------------ | | ------------------ ------------------ 2002| 6| link); 2003| 6| } 2004| 6| } else if (this->ttl != lctx->ttl) { ------------------ | Branch (2004:14): [True: 0, False: 0] ------------------ 2005| 0| (*callbacks->warn)(callbacks, 2006| 0| "%s:%lu: " 2007| 0| "TTL set to prior TTL (%lu)", 2008| 0| source, line, this->ttl); 2009| 0| lctx->ttl = this->ttl; 2010| 0| } 2011| | 2012| 6| if ((lctx->options & DNS_MASTER_CHECKTTL) != 0 && ------------------ | | 58| 6|#define DNS_MASTER_CHECKTTL 0x00010000 /*%< Check max-zone-ttl */ ------------------ | Branch (2012:7): [True: 0, False: 6] ------------------ 2013| 0| lctx->ttl > lctx->maxttl) ------------------ | Branch (2013:7): [True: 0, False: 0] ------------------ 2014| 0| { 2015| 0| (callbacks->error)(callbacks, 2016| 0| "dns_master_load: %s:%lu: " 2017| 0| "TTL %d exceeds configured " 2018| 0| "max-zone-ttl %d", 2019| 0| source, line, lctx->ttl, 2020| 0| lctx->maxttl); 2021| 0| result = ISC_R_RANGE; 2022| 0| goto log_and_cleanup; 2023| 0| } 2024| | 2025| 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] | | ------------------ ------------------ 2026| 6| if (ictx->glue != NULL) { ------------------ | Branch (2026:7): [True: 0, False: 6] ------------------ 2027| 0| ictx->glue_line = line; 2028| 6| } else { 2029| 6| ictx->current_line = line; 2030| 6| } 2031| 6| rdcount++; 2032| | 2033| | /* 2034| | * We must have at least 64k as rdlen is 16 bits. 2035| | * If we don't commit everything we have so far. 2036| | */ 2037| 6| if ((target.length - target.used) < MINTSIZ) { ------------------ | | 76| 6|#define MINTSIZ DNS_RDATA_MAXLENGTH | | ------------------ | | | | 181| 6|#define DNS_RDATA_MAXLENGTH 65512U | | ------------------ ------------------ | Branch (2037:7): [True: 0, False: 6] ------------------ 2038| 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] | | ------------------ ------------------ 2039| 0| } 2040| 6| next_line:; 2041| 6| } 2042| | 2043| | /* 2044| | * Commit what has not yet been committed. 2045| | */ 2046| 2| result = commit(callbacks, lctx, ¤t_list, ictx->current, source, 2047| 2| ictx->current_line); 2048| 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] | | | | ------------------ | | ------------------ ------------------ 2049| 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| } ------------------ 2050| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2050:13): [True: 0, False: 2] ------------------ 2051| 0| goto insist_and_cleanup; 2052| 0| } 2053| 2| result = commit(callbacks, lctx, &glue_list, ictx->glue, source, 2054| 2| ictx->glue_line); 2055| 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] | | | | ------------------ | | ------------------ ------------------ 2056| 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| } ------------------ 2057| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2057:13): [True: 0, False: 2] ------------------ 2058| 0| goto insist_and_cleanup; 2059| 2| } else if (lctx->result != ISC_R_SUCCESS) { ------------------ | Branch (2059:13): [True: 0, False: 2] ------------------ 2060| 0| result = lctx->result; 2061| 2| } else if (lctx->seen_include) { ------------------ | Branch (2061:13): [True: 0, False: 2] ------------------ 2062| 0| result = DNS_R_SEENINCLUDE; 2063| 0| } 2064| | 2065| 2| goto cleanup; 2066| | 2067| 2|log_and_cleanup: 2068| 0| LOGIT(result); ------------------ | | 327| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 328| 0| source, line, isc_result_totext(result)) ------------------ 2069| | 2070| 0|insist_and_cleanup: 2071| 0| INSIST(result != ISC_R_SUCCESS); ------------------ | | 202| 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))) | | ------------------ ------------------ 2072| | 2073| 2|cleanup: 2074| | /* commit the database transaction */ 2075| 2| if (callbacks->commit != NULL) { ------------------ | Branch (2075:6): [True: 2, False: 0] ------------------ 2076| 2| callbacks->commit(callbacks->add_private); 2077| 2| } 2078| | 2079| 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] | | ------------------ ------------------ 2080| 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] | | | | ------------------ | | ------------------ ------------------ 2081| 0| } 2082| 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] | | ------------------ ------------------ 2083| 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] | | | | ------------------ | | ------------------ ------------------ 2084| 0| } 2085| 2| if (rdatalist != NULL) { ------------------ | Branch (2085:6): [True: 2, False: 0] ------------------ 2086| 2| isc_mem_cput(mctx, rdatalist, rdatalist_size, ------------------ | | 176| 2| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 2| (p) = NULL; \ | | 180| 2| } while (0) | | ------------------ | | | Branch (180:11): [Folded, False: 2] | | ------------------ ------------------ 2087| 2| sizeof(*rdatalist)); 2088| 2| } 2089| 2| if (rdata != NULL) { ------------------ | Branch (2089:6): [True: 2, False: 0] ------------------ 2090| 2| isc_mem_cput(mctx, rdata, rdata_size, sizeof(*rdata)); ------------------ | | 176| 2| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 2| (p) = NULL; \ | | 180| 2| } while (0) | | ------------------ | | | Branch (180:11): [Folded, False: 2] | | ------------------ ------------------ 2091| 2| } 2092| 2| if (target_mem != NULL) { ------------------ | Branch (2092:6): [True: 2, False: 0] ------------------ 2093| 2| isc_mem_put(mctx, target_mem, target_size); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 2] | | ------------------ ------------------ 2094| 2| } 2095| 2| if (include_file != NULL) { ------------------ | Branch (2095:6): [True: 0, False: 2] ------------------ 2096| 0| isc_mem_free(mctx, include_file); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 2097| 0| } 2098| 2| if (range != NULL) { ------------------ | Branch (2098:6): [True: 0, False: 2] ------------------ 2099| 0| isc_mem_free(mctx, range); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 2100| 0| } 2101| 2| if (lhs != NULL) { ------------------ | Branch (2101:6): [True: 0, False: 2] ------------------ 2102| 0| isc_mem_free(mctx, lhs); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 2103| 0| } 2104| 2| if (gtype != NULL) { ------------------ | Branch (2104:6): [True: 0, False: 2] ------------------ 2105| 0| isc_mem_free(mctx, gtype); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 2106| 0| } 2107| 2| if (rhs != NULL) { ------------------ | Branch (2107:6): [True: 0, False: 2] ------------------ 2108| 0| isc_mem_free(mctx, rhs); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 2109| 0| } 2110| | 2111| 2| return result; 2112| 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: 2827| 6| unsigned int line) { 2828| 6| dns_rdataset_t dataset; 2829| 6| isc_result_t result = ISC_R_SUCCESS; 2830| 6| char namebuf[DNS_NAME_FORMATSIZE]; 2831| 6| void (*error)(struct dns_rdatacallbacks *, const char *, ...); 2832| | 2833| 6| error = callbacks->error; 2834| | 2835| 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] | | ------------------ ------------------ 2836| 6| dns_rdataset_init(&dataset); 2837| 6| dns_rdatalist_tordataset(this, &dataset); 2838| 6| dataset.trust = dns_trust_ultimate; ------------------ | | 380| 6|#define dns_trust_ultimate ((dns_trust_t)dns_trust_ultimate) ------------------ 2839| | /* 2840| | * If this is a secure dynamic zone set the re-signing time. 2841| | */ 2842| 6| if (dataset.type == dns_rdatatype_rrsig && ------------------ | | 160| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (2842:7): [True: 0, False: 6] ------------------ 2843| 0| (lctx->options & DNS_MASTER_RESIGN) != 0) ------------------ | | 55| 0|#define DNS_MASTER_RESIGN 0x00002000 ------------------ | Branch (2843:7): [True: 0, False: 0] ------------------ 2844| 0| { 2845| 0| dataset.attributes.resign = true; 2846| 0| dataset.resign = resign_fromlist(this, lctx); 2847| 0| } 2848| 6| result = callbacks->update(callbacks->add_private, owner, 2849| 6| &dataset, 2850| 6| DNS_DIFFOP_ADD DNS__DB_FILELINE); 2851| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2851:7): [True: 0, False: 6] ------------------ 2852| 0| dns_name_format(owner, namebuf, sizeof(namebuf)); 2853| 0| if (source != NULL) { ------------------ | Branch (2853:8): [True: 0, False: 0] ------------------ 2854| 0| (*error)(callbacks, "%s: %s:%lu: %s: %s", 2855| 0| "dns_master_load", source, line, 2856| 0| namebuf, isc_result_totext(result)); 2857| 0| } else { 2858| 0| (*error)(callbacks, "%s: %s: %s", 2859| 0| "dns_master_load", namebuf, 2860| 0| isc_result_totext(result)); 2861| 0| } 2862| 0| } 2863| 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] | | | | ------------------ | | ------------------ ------------------ 2864| 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| } ------------------ 2865| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2865:14): [True: 0, False: 6] ------------------ 2866| 0| break; 2867| 0| } 2868| 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] | | | | ------------------ | | ------------------ ------------------ 2869| 6| } 2870| | 2871| 6| return result; 2872| 6|} master.c:limit_ttl: 895| 6| unsigned int line, uint32_t *ttlp) { 896| 6| if (*ttlp > 0x7fffffffUL) { ------------------ | Branch (896:6): [True: 0, False: 6] ------------------ 897| 0| (callbacks->warn)(callbacks, 898| 0| "%s: %s:%lu: " 899| 0| "$TTL %lu > MAXTTL, " 900| 0| "setting $TTL to 0", 901| 0| "dns_master_load", source, line, *ttlp); 902| 0| *ttlp = 0; 903| 0| } 904| 6|} master.c:find_free_name: 971| 6|find_free_name(dns_incctx_t *incctx) { 972| 6| int i; 973| | 974| 16| for (i = 0; i < (NBUFS - 1); i++) { ------------------ | | 63| 16|#define NBUFS 4 ------------------ | Branch (974:14): [True: 16, False: 0] ------------------ 975| 16| if (!incctx->in_use[i]) { ------------------ | Branch (975:7): [True: 6, False: 10] ------------------ 976| 6| break; 977| 6| } 978| 16| } 979| 6| INSIST(!incctx->in_use[i]); ------------------ | | 202| 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))) | | ------------------ ------------------ 980| 6| return i; 981| 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: 2742| 2| rdatalist_head_t *current, rdatalist_head_t *glue, isc_mem_t *mctx) { 2743| 2| dns_rdata_t *newlist; 2744| 2| int rdcount = 0; 2745| 2| ISC_LIST(dns_rdata_t) save; ------------------ | | 39| 2| struct { \ | | 40| 2| type *head, *tail; \ | | 41| 2| } ------------------ 2746| | 2747| 2| newlist = isc_mem_cget(mctx, new_len, sizeof(*newlist)); ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 2748| | 2749| | /* 2750| | * Copy current relinking. 2751| | */ 2752| 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] | | ------------------ ------------------ 2753| 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] | | ------------------ ------------------ 2754| 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] | | ------------------ ------------------ 2755| 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] | | | | ------------------ | | ------------------ ------------------ 2756| 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] | | ------------------ ------------------ 2757| 0| } 2758| 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] | | ------------------ ------------------ 2759| 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] | | | | ------------------ | | ------------------ ------------------ 2760| 0| INSIST(rdcount < new_len); ------------------ | | 202| 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))) | | ------------------ ------------------ 2761| 0| newlist[rdcount] = *rdata; 2762| 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] | | ------------------ ------------------ 2763| 0| rdcount++; 2764| 0| } 2765| 0| } 2766| | 2767| | /* 2768| | * Copy glue relinking. 2769| | */ 2770| 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] | | ------------------ ------------------ 2771| 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] | | ------------------ ------------------ 2772| 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] | | ------------------ ------------------ 2773| 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] | | | | ------------------ | | ------------------ ------------------ 2774| 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] | | ------------------ ------------------ 2775| 0| } 2776| 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] | | ------------------ ------------------ 2777| 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] | | | | ------------------ | | ------------------ ------------------ 2778| 0| INSIST(rdcount < new_len); ------------------ | | 202| 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))) | | ------------------ ------------------ 2779| 0| newlist[rdcount] = *rdata; 2780| 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] | | ------------------ ------------------ 2781| 0| rdcount++; 2782| 0| } 2783| 0| } 2784| 2| INSIST(rdcount == old_len || rdcount == 0); ------------------ | | 202| 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))) | | ------------------ ------------------ 2785| 2| if (oldlist != NULL) { ------------------ | Branch (2785:6): [True: 0, False: 2] ------------------ 2786| | isc_mem_cput(mctx, oldlist, old_len, sizeof(*oldlist)); ------------------ | | 176| 0| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 0| (p) = NULL; \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:11): [Folded, False: 0] | | ------------------ ------------------ 2787| 0| } 2788| 2| return newlist; 2789| 2|} master.c:grow_rdatalist: 2696| 2| isc_mem_t *mctx) { 2697| 2| dns_rdatalist_t *newlist; 2698| 2| int rdlcount = 0; 2699| 2| ISC_LIST(dns_rdatalist_t) save; ------------------ | | 39| 2| struct { \ | | 40| 2| type *head, *tail; \ | | 41| 2| } ------------------ 2700| | 2701| 2| newlist = isc_mem_cget(mctx, new_len, sizeof(newlist[0])); ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 2702| | 2703| 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] | | ------------------ ------------------ 2704| 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] | | ------------------ ------------------ 2705| 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] | | | | ------------------ | | ------------------ ------------------ 2706| 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] | | ------------------ ------------------ 2707| 0| } 2708| 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] | | ------------------ ------------------ 2709| 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] | | | | ------------------ | | ------------------ ------------------ 2710| 0| INSIST(rdlcount < new_len); ------------------ | | 202| 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| 0| newlist[rdlcount] = *this; 2712| 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] | | ------------------ ------------------ 2713| 0| rdlcount++; 2714| 0| } 2715| | 2716| 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] | | ------------------ ------------------ 2717| 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] | | ------------------ ------------------ 2718| 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] | | | | ------------------ | | ------------------ ------------------ 2719| 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] | | ------------------ ------------------ 2720| 0| } 2721| 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] | | ------------------ ------------------ 2722| 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] | | | | ------------------ | | ------------------ ------------------ 2723| 0| INSIST(rdlcount < new_len); ------------------ | | 202| 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))) | | ------------------ ------------------ 2724| 0| newlist[rdlcount] = *this; 2725| 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] | | ------------------ ------------------ 2726| 0| rdlcount++; 2727| 0| } 2728| | 2729| 2| INSIST(rdlcount == old_len); ------------------ | | 202| 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))) | | ------------------ ------------------ 2730| 2| if (oldlist != NULL) { ------------------ | Branch (2730:6): [True: 0, False: 2] ------------------ 2731| | isc_mem_cput(mctx, oldlist, old_len, sizeof(*oldlist)); ------------------ | | 176| 0| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 0| (p) = NULL; \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:11): [Folded, False: 0] | | ------------------ ------------------ 2732| 0| } 2733| 2| return newlist; 2734| 2|} dns_message_create: 694| 1.69k| dns_message_t **msgp) { 695| 1.69k| REQUIRE(mctx != NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| 1.69k| REQUIRE(msgp != NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 697| 1.69k| REQUIRE(*msgp == NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 698| 1.69k| REQUIRE(intent == DNS_MESSAGE_INTENTPARSE || ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 699| 1.69k| intent == DNS_MESSAGE_INTENTRENDER); 700| 1.69k| REQUIRE((namepool != NULL && rdspool != NULL) || ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8.46k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 1.69k] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 701| 1.69k| (namepool == NULL && rdspool == NULL)); 702| | 703| 1.69k| dns_message_t *msg = isc_mem_get(mctx, sizeof(dns_message_t)); ------------------ | | 144| 1.69k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 704| 1.69k| *msg = (dns_message_t){ 705| 1.69k| .from_to_wire = intent, 706| 1.69k| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 1.69k|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 707| 1.69k| .scratchpad = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.69k| { \ | | 22| 1.69k| .head = NULL, \ | | 23| 1.69k| .tail = NULL, \ | | 24| 1.69k| } ------------------ 708| 1.69k| .cleanup = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.69k| { \ | | 22| 1.69k| .head = NULL, \ | | 23| 1.69k| .tail = NULL, \ | | 24| 1.69k| } ------------------ 709| 1.69k| .rdatas = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.69k| { \ | | 22| 1.69k| .head = NULL, \ | | 23| 1.69k| .tail = NULL, \ | | 24| 1.69k| } ------------------ 710| 1.69k| .rdatalists = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.69k| { \ | | 22| 1.69k| .head = NULL, \ | | 23| 1.69k| .tail = NULL, \ | | 24| 1.69k| } ------------------ 711| 1.69k| .freerdata = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.69k| { \ | | 22| 1.69k| .head = NULL, \ | | 23| 1.69k| .tail = NULL, \ | | 24| 1.69k| } ------------------ 712| 1.69k| .freerdatalist = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.69k| { \ | | 22| 1.69k| .head = NULL, \ | | 23| 1.69k| .tail = NULL, \ | | 24| 1.69k| } ------------------ 713| 1.69k| .magic = DNS_MESSAGE_MAGIC, ------------------ | | 147| 1.69k|#define DNS_MESSAGE_MAGIC ISC_MAGIC('M', 'S', 'G', '@') | | ------------------ | | | | 31| 1.69k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 714| 1.69k| .namepool = namepool, 715| 1.69k| .rdspool = rdspool, 716| 1.69k| .free_pools = (namepool == NULL && rdspool == NULL), ------------------ | Branch (716:18): [True: 1.69k, False: 0] | Branch (716:38): [True: 1.69k, False: 0] ------------------ 717| 1.69k| }; 718| | 719| 1.69k| isc_mem_attach(mctx, &msg->mctx); 720| | 721| 1.69k| if (msg->free_pools) { ------------------ | Branch (721:6): [True: 1.69k, False: 0] ------------------ 722| 1.69k| dns_message_createpools(mctx, &msg->namepool, &msg->rdspool); 723| 1.69k| } 724| | 725| 1.69k| msginit(msg); 726| | 727| 8.46k| for (size_t i = 0; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (727:21): [True: 6.76k, False: 1.69k] ------------------ 728| 6.76k| ISC_LIST_INIT(msg->sections[i]); ------------------ | | 43| 6.76k| do { \ | | 44| 6.76k| (list).head = NULL; \ | | 45| 6.76k| (list).tail = NULL; \ | | 46| 6.76k| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 6.76k] | | ------------------ ------------------ 729| 6.76k| } 730| | 731| 1.69k| isc_buffer_t *dynbuf = NULL; 732| 1.69k| isc_buffer_allocate(mctx, &dynbuf, SCRATCHPAD_SIZE); ------------------ | | 123| 1.69k|#define SCRATCHPAD_SIZE 1232 ------------------ 733| 1.69k| ISC_LIST_APPEND(msg->scratchpad, dynbuf, link); ------------------ | | 100| 1.69k| do { \ | | 101| 1.69k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.69k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.69k| do { \ | | | | 89| 1.69k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.69k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.69k| } else { \ | | | | 92| 1.69k| (list).head = (elt); \ | | | | 93| 1.69k| } \ | | | | 94| 1.69k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.69k| (elt)->link.next = NULL; \ | | | | 96| 1.69k| (list).tail = (elt); \ | | | | 97| 1.69k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.69k] | | | | ------------------ | | ------------------ | | 103| 1.69k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.69k] | | ------------------ ------------------ 734| | 735| 1.69k| *msgp = msg; 736| 1.69k|} dns_message_parse: 1578| 1.69k| unsigned int options) { 1579| 1.69k| isc_region_t r; 1580| 1.69k| dns_decompress_t dctx; 1581| 1.69k| isc_result_t result; 1582| 1.69k| uint16_t tmpflags; 1583| 1.69k| isc_buffer_t origsource; 1584| 1.69k| bool seen_problem; 1585| 1.69k| bool ignore_tc; 1586| | 1587| 1.69k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1588| 1.69k| REQUIRE(source != NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1589| 1.69k| REQUIRE(msg->from_to_wire == DNS_MESSAGE_INTENTPARSE); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1590| | 1591| 1.69k| seen_problem = false; 1592| 1.69k| ignore_tc = ((options & DNS_MESSAGEPARSE_IGNORETRUNCATION) != 0); ------------------ | | 209| 1.69k| 0x0008 /*%< truncation errors are \ ------------------ 1593| | 1594| 1.69k| origsource = *source; 1595| | 1596| 1.69k| msg->header_ok = 0; 1597| 1.69k| msg->question_ok = 0; 1598| | 1599| 1.69k| if ((options & DNS_MESSAGEPARSE_CLONEBUFFER) == 0) { ------------------ | | 206| 1.69k| 0x0004 /*%< save a copy of the \ ------------------ | Branch (1599:6): [True: 1.69k, False: 0] ------------------ 1600| 1.69k| isc_buffer_usedregion(&origsource, &msg->saved); 1601| 1.69k| } else { 1602| 0| msg->saved.length = isc_buffer_usedlength(&origsource); ------------------ | | 157| 0|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1603| 0| msg->saved.base = isc_mem_get(msg->mctx, msg->saved.length); ------------------ | | 144| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1604| 0| memmove(msg->saved.base, isc_buffer_base(&origsource), ------------------ | | 143| 0|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 1605| 0| msg->saved.length); 1606| 0| msg->free_saved = 1; 1607| 0| } 1608| | 1609| 1.69k| isc_buffer_remainingregion(source, &r); 1610| 1.69k| if (r.length < DNS_MESSAGE_HEADERLEN) { ------------------ | | 145| 1.69k|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ | Branch (1610:6): [True: 0, False: 1.69k] ------------------ 1611| 0| return ISC_R_UNEXPECTEDEND; 1612| 0| } 1613| | 1614| 1.69k| msg->id = isc_buffer_getuint16(source); 1615| 1.69k| tmpflags = isc_buffer_getuint16(source); 1616| 1.69k| msg->opcode = ((tmpflags & DNS_MESSAGE_OPCODE_MASK) >> ------------------ | | 84| 1.69k|#define DNS_MESSAGE_OPCODE_MASK 0x7800U ------------------ 1617| 1.69k| DNS_MESSAGE_OPCODE_SHIFT); ------------------ | | 85| 1.69k|#define DNS_MESSAGE_OPCODE_SHIFT 11 ------------------ 1618| 1.69k| msg->rcode = (dns_rcode_t)(tmpflags & DNS_MESSAGE_RCODE_MASK); ------------------ | | 86| 1.69k|#define DNS_MESSAGE_RCODE_MASK 0x000fU ------------------ 1619| 1.69k| msg->flags = (tmpflags & DNS_MESSAGE_FLAG_MASK); ------------------ | | 87| 1.69k|#define DNS_MESSAGE_FLAG_MASK 0x8ff0U ------------------ 1620| 1.69k| msg->counts[DNS_SECTION_QUESTION] = isc_buffer_getuint16(source); 1621| 1.69k| msg->counts[DNS_SECTION_ANSWER] = isc_buffer_getuint16(source); 1622| 1.69k| msg->counts[DNS_SECTION_AUTHORITY] = isc_buffer_getuint16(source); 1623| 1.69k| msg->counts[DNS_SECTION_ADDITIONAL] = isc_buffer_getuint16(source); 1624| | 1625| 1.69k| msg->header_ok = 1; 1626| 1.69k| msg->state = DNS_SECTION_QUESTION; 1627| | 1628| 1.69k| dctx = DNS_DECOMPRESS_ALWAYS; 1629| | 1630| 1.69k| bool strict_parse = ((options & DNS_MESSAGEPARSE_BESTEFFORT) == 0); ------------------ | | 202| 1.69k| 0x0002 /*%< return a message if a \ ------------------ 1631| 1.69k| isc_result_t early_check_ret = early_sanity_check(msg); 1632| 1.69k| if (strict_parse && (early_check_ret != ISC_R_SUCCESS)) { ------------------ | Branch (1632:6): [True: 1.69k, False: 0] | Branch (1632:22): [True: 8, False: 1.68k] ------------------ 1633| 8| return early_check_ret; 1634| 8| } 1635| | 1636| 1.68k| result = getquestions(source, msg, dctx, options); 1637| | 1638| 1.68k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1638:6): [True: 0, False: 1.68k] | Branch (1638:39): [True: 0, False: 0] ------------------ 1639| 0| goto truncated; 1640| 0| } 1641| 1.68k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1641:6): [True: 0, False: 1.68k] ------------------ 1642| 0| seen_problem = true; 1643| 0| result = ISC_R_SUCCESS; 1644| 0| } 1645| 1.68k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1645:6): [True: 0, False: 1.68k] ------------------ 1646| 0| return result; 1647| 0| } 1648| 1.68k| msg->question_ok = 1; 1649| | 1650| 1.68k| result = getsection(source, msg, dctx, DNS_SECTION_ANSWER, options); 1651| 1.68k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1651:6): [True: 0, False: 1.68k] | Branch (1651:39): [True: 0, False: 0] ------------------ 1652| 0| goto truncated; 1653| 0| } 1654| 1.68k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1654:6): [True: 0, False: 1.68k] ------------------ 1655| 0| seen_problem = true; 1656| 0| result = ISC_R_SUCCESS; 1657| 0| } 1658| 1.68k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1658:6): [True: 0, False: 1.68k] ------------------ 1659| 0| return result; 1660| 0| } 1661| | 1662| 1.68k| result = getsection(source, msg, dctx, DNS_SECTION_AUTHORITY, options); 1663| 1.68k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1663:6): [True: 0, False: 1.68k] | Branch (1663:39): [True: 0, False: 0] ------------------ 1664| 0| goto truncated; 1665| 0| } 1666| 1.68k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1666:6): [True: 0, False: 1.68k] ------------------ 1667| 0| seen_problem = true; 1668| 0| result = ISC_R_SUCCESS; 1669| 0| } 1670| 1.68k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1670:6): [True: 0, False: 1.68k] ------------------ 1671| 0| return result; 1672| 0| } 1673| | 1674| 1.68k| result = getsection(source, msg, dctx, DNS_SECTION_ADDITIONAL, options); 1675| 1.68k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1675:6): [True: 290, False: 1.39k] | Branch (1675:39): [True: 0, False: 290] ------------------ 1676| 0| goto truncated; 1677| 0| } 1678| 1.68k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1678:6): [True: 0, False: 1.68k] ------------------ 1679| 0| seen_problem = true; 1680| 0| result = ISC_R_SUCCESS; 1681| 0| } 1682| 1.68k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1682:6): [True: 535, False: 1.14k] ------------------ 1683| 535| return result; 1684| 535| } 1685| | 1686| 1.14k| isc_buffer_remainingregion(source, &r); 1687| 1.14k| if (r.length != 0) { ------------------ | Branch (1687:6): [True: 0, False: 1.14k] ------------------ 1688| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MESSAGE, 1689| 0| ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1690| 0| "message has %u byte(s) of trailing garbage", 1691| 0| r.length); 1692| 0| } 1693| | 1694| 1.14k|truncated: 1695| | 1696| 1.14k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1696:6): [True: 0, False: 1.14k] | Branch (1696:39): [True: 0, False: 0] ------------------ 1697| 0| return DNS_R_RECOVERABLE; 1698| 0| } 1699| 1.14k| if (seen_problem) { ------------------ | Branch (1699:6): [True: 0, False: 1.14k] ------------------ 1700| 0| return DNS_R_RECOVERABLE; 1701| 0| } 1702| 1.14k| return ISC_R_SUCCESS; 1703| 1.14k|} dns_message_gettempname: 2405| 3.35k|dns_message_gettempname(dns_message_t *msg, dns_name_t **item) { 2406| 3.35k| dns_fixedname_t *fn = NULL; 2407| | 2408| 3.35k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 3.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.71k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | ------------------ | | | | 43| 3.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2409| 3.35k| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 3.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.71k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | ------------------ | | | | 43| 3.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2410| | 2411| 3.35k| fn = isc_mempool_get(msg->namepool); ------------------ | | 168| 3.35k|#define isc_mempool_get(c) isc__mempool_get((c)_ISC_MEM_FILELINE) ------------------ 2412| 3.35k| *item = dns_fixedname_initname(fn); 2413| 3.35k|} dns_message_gettemprdata: 2416| 200|dns_message_gettemprdata(dns_message_t *msg, dns_rdata_t **item) { 2417| 200| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2418| 200| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2419| | 2420| 200| *item = newrdata(msg); 2421| 200|} dns_message_gettemprdataset: 2424| 3.02k|dns_message_gettemprdataset(dns_message_t *msg, dns_rdataset_t **item) { 2425| 3.02k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.04k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2426| 3.02k| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.04k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2427| | 2428| 3.02k| *item = isc_mempool_get(msg->rdspool); ------------------ | | 168| 3.02k|#define isc_mempool_get(c) isc__mempool_get((c)_ISC_MEM_FILELINE) ------------------ 2429| 3.02k| dns_rdataset_init(*item); 2430| 3.02k|} dns_message_gettemprdatalist: 2433| 200|dns_message_gettemprdatalist(dns_message_t *msg, dns_rdatalist_t **item) { 2434| 200| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2435| 200| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2436| | 2437| 200| *item = newrdatalist(msg); 2438| 200|} dns_message_puttempname: 2441| 3.35k|dns_message_puttempname(dns_message_t *msg, dns_name_t **itemp) { 2442| 3.35k| dns_name_t *item = NULL; 2443| | 2444| 3.35k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 3.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.71k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | ------------------ | | | | 43| 3.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2445| 3.35k| REQUIRE(itemp != NULL && *itemp != NULL); ------------------ | | 198| 3.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.71k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | | Branch (42:11): [True: 3.35k, False: 0] | | | | ------------------ | | | | 43| 3.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2446| | 2447| 3.35k| item = *itemp; 2448| 3.35k| *itemp = NULL; 2449| | 2450| 3.35k| REQUIRE(!ISC_LINK_LINKED(item, link)); ------------------ | | 198| 3.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.35k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.35k, False: 0] | | | | ------------------ | | | | 43| 3.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2451| 3.35k| REQUIRE(ISC_LIST_HEAD(item->list) == NULL); ------------------ | | 198| 3.35k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.35k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.35k, False: 0] | | | | ------------------ | | | | 43| 3.35k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2452| | 2453| 3.35k| if (item->hashmap != NULL) { ------------------ | Branch (2453:6): [True: 0, False: 3.35k] ------------------ 2454| 0| isc_hashmap_destroy(&item->hashmap); 2455| 0| } 2456| | 2457| | /* 2458| | * we need to check this in case dns_name_dup() was used. 2459| | */ 2460| 3.35k| if (dns_name_dynamic(item)) { ------------------ | Branch (2460:6): [True: 0, False: 3.35k] ------------------ 2461| 0| dns_name_free(item, msg->mctx); 2462| 0| } 2463| | 2464| | /* 2465| | * 'name' is the first field in dns_fixedname_t, so putting 2466| | * back the address of name is the same as putting back 2467| | * the fixedname. 2468| | */ 2469| | isc_mempool_put(msg->namepool, item); ------------------ | | 207| 3.35k| do { \ | | 208| 3.35k| isc__mempool_put((c), (p)_ISC_MEM_FILELINE); \ | | 209| 3.35k| (p) = NULL; \ | | 210| 3.35k| } while (0) | | ------------------ | | | Branch (210:11): [Folded, False: 3.35k] | | ------------------ ------------------ 2470| 3.35k|} dns_message_puttemprdataset: 2488| 3.02k|dns_message_puttemprdataset(dns_message_t *msg, dns_rdataset_t **item) { 2489| 3.02k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.04k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2490| 3.02k| REQUIRE(item != NULL && *item != NULL); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.04k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2491| | 2492| 3.02k| REQUIRE(!dns_rdataset_isassociated(*item)); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2493| | isc_mempool_put(msg->rdspool, *item); ------------------ | | 207| 3.02k| do { \ | | 208| 3.02k| isc__mempool_put((c), (p)_ISC_MEM_FILELINE); \ | | 209| 3.02k| (p) = NULL; \ | | 210| 3.02k| } while (0) | | ------------------ | | | Branch (210:11): [Folded, False: 3.02k] | | ------------------ ------------------ 2494| 3.02k|} dns_message_settsigkey: 2678| 260|dns_message_settsigkey(dns_message_t *msg, dns_tsigkey_t *key) { 2679| 260| isc_result_t result; 2680| | 2681| | /* 2682| | * Set the TSIG key for 'msg' 2683| | */ 2684| | 2685| 260| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 260|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 520| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 260, False: 0] | | | | | Branch (42:11): [True: 260, False: 0] | | | | ------------------ | | | | 43| 260| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2686| | 2687| 260| if (key == NULL && msg->tsigkey != NULL) { ------------------ | Branch (2687:6): [True: 0, False: 260] | Branch (2687:21): [True: 0, False: 0] ------------------ 2688| 0| if (msg->sig_reserved != 0) { ------------------ | Branch (2688:7): [True: 0, False: 0] ------------------ 2689| 0| dns_message_renderrelease(msg, msg->sig_reserved); 2690| 0| msg->sig_reserved = 0; 2691| 0| } 2692| 0| dns_tsigkey_detach(&msg->tsigkey); 2693| 0| } 2694| 260| if (key != NULL) { ------------------ | Branch (2694:6): [True: 260, False: 0] ------------------ 2695| 260| REQUIRE(msg->tsigkey == NULL && msg->sig0key == NULL); ------------------ | | 198| 260|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 520| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 260, False: 0] | | | | | Branch (42:11): [True: 260, False: 0] | | | | ------------------ | | | | 43| 260| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2696| 260| dns_tsigkey_attach(key, &msg->tsigkey); 2697| 260| if (msg->from_to_wire == DNS_MESSAGE_INTENTRENDER) { ------------------ | Branch (2697:7): [True: 0, False: 260] ------------------ 2698| 0| msg->sig_reserved = spacefortsig(msg->tsigkey, 0); 2699| 0| result = dns_message_renderreserve(msg, 2700| 0| msg->sig_reserved); 2701| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2701:8): [True: 0, False: 0] ------------------ 2702| 0| dns_tsigkey_detach(&msg->tsigkey); 2703| 0| msg->sig_reserved = 0; 2704| 0| return result; 2705| 0| } 2706| 0| } 2707| 260| } 2708| 260| return ISC_R_SUCCESS; 2709| 260|} dns_message_gettsigkey: 2712| 630|dns_message_gettsigkey(dns_message_t *msg) { 2713| | /* 2714| | * Get the TSIG key for 'msg' 2715| | */ 2716| | 2717| 630| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 630, False: 0] | | | | | Branch (42:11): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2718| | 2719| 630| return msg->tsigkey; 2720| 630|} dns_message_setquerytsig: 2723| 200|dns_message_setquerytsig(dns_message_t *msg, isc_buffer_t *querytsig) { 2724| 200| dns_rdata_t *rdata = NULL; 2725| 200| dns_rdatalist_t *list = NULL; 2726| 200| dns_rdataset_t *set = NULL; 2727| 200| isc_buffer_t *buf = NULL; 2728| 200| isc_region_t r; 2729| | 2730| 200| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2731| 200| REQUIRE(msg->querytsig == NULL); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2732| | 2733| 200| if (querytsig == NULL) { ------------------ | Branch (2733:6): [True: 0, False: 200] ------------------ 2734| 0| return; 2735| 0| } 2736| | 2737| 200| dns_message_gettemprdata(msg, &rdata); 2738| | 2739| 200| dns_message_gettemprdatalist(msg, &list); 2740| 200| dns_message_gettemprdataset(msg, &set); 2741| | 2742| 200| isc_buffer_usedregion(querytsig, &r); 2743| 200| isc_buffer_allocate(msg->mctx, &buf, r.length); 2744| 200| isc_buffer_putmem(buf, r.base, r.length); 2745| 200| isc_buffer_usedregion(buf, &r); 2746| 200| dns_rdata_fromregion(rdata, dns_rdataclass_any, dns_rdatatype_tsig, &r); ------------------ | | 34| 200|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ dns_rdata_fromregion(rdata, dns_rdataclass_any, dns_rdatatype_tsig, &r); ------------------ | | 190| 200|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ 2747| 200| dns_message_takebuffer(msg, &buf); 2748| 200| ISC_LIST_APPEND(list->rdata, rdata, link); ------------------ | | 100| 200| do { \ | | 101| 200| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 200| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 200| do { \ | | | | 89| 200| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 200] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 200| } else { \ | | | | 92| 200| (list).head = (elt); \ | | | | 93| 200| } \ | | | | 94| 200| (elt)->link.prev = (list).tail; \ | | | | 95| 200| (elt)->link.next = NULL; \ | | | | 96| 200| (list).tail = (elt); \ | | | | 97| 200| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 200] | | | | ------------------ | | ------------------ | | 103| 200| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 200] | | ------------------ ------------------ 2749| 200| dns_rdatalist_tordataset(list, set); 2750| | 2751| 200| msg->querytsig = set; 2752| 200|} dns_message_takebuffer: 2864| 200|dns_message_takebuffer(dns_message_t *msg, isc_buffer_t **buffer) { 2865| 200| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2866| 200| REQUIRE(buffer != NULL); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2867| 200| REQUIRE(ISC_BUFFER_VALID(*buffer)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2868| | 2869| 200| ISC_LIST_APPEND(msg->cleanup, *buffer, link); ------------------ | | 100| 200| do { \ | | 101| 200| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 200| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 200| do { \ | | | | 89| 200| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 200] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 200| } else { \ | | | | 92| 200| (list).head = (elt); \ | | | | 93| 200| } \ | | | | 94| 200| (elt)->link.prev = (list).tail; \ | | | | 95| 200| (elt)->link.next = NULL; \ | | | | 96| 200| (list).tail = (elt); \ | | | | 97| 200| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 200] | | | | ------------------ | | ------------------ | | 103| 200| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 200] | | ------------------ ------------------ 2870| | *buffer = NULL; 2871| 200|} dns_message_checksig: 3050| 1.14k|dns_message_checksig(dns_message_t *msg, dns_view_t *view) { 3051| 1.14k| isc_buffer_t msgb; 3052| | 3053| 1.14k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 1.14k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.29k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.14k, False: 0] | | | | | Branch (42:11): [True: 1.14k, False: 0] | | | | ------------------ | | | | 43| 1.14k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 3054| | 3055| 1.14k| if (msg->tsigkey == NULL && msg->tsig == NULL && msg->sig0 == NULL) { ------------------ | Branch (3055:6): [True: 889, False: 260] | Branch (3055:30): [True: 519, False: 370] | Branch (3055:51): [True: 67, False: 452] ------------------ 3056| 67| return ISC_R_SUCCESS; 3057| 67| } 3058| | 3059| 1.08k| INSIST(msg->saved.base != NULL); ------------------ | | 202| 1.08k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.08k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.08k, False: 0] | | | | ------------------ | | | | 55| 1.08k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3060| 1.08k| isc_buffer_init(&msgb, msg->saved.base, msg->saved.length); 3061| 1.08k| isc_buffer_add(&msgb, msg->saved.length); 3062| 1.08k| if (msg->tsigkey != NULL || msg->tsig != NULL) { ------------------ | Branch (3062:6): [True: 260, False: 822] | Branch (3062:30): [True: 370, False: 452] ------------------ 3063| |#ifdef SKAN_MSG_DEBUG 3064| | dns_message_dumpsig(msg, "dns_message_checksig#1"); 3065| |#endif /* ifdef SKAN_MSG_DEBUG */ 3066| 630| if (view != NULL) { ------------------ | Branch (3066:7): [True: 447, False: 183] ------------------ 3067| 447| return dns_view_checksig(view, &msgb, msg); 3068| 447| } else { 3069| 183| return dns_tsig_verify(&msgb, msg, NULL, NULL); 3070| 183| } 3071| 630| } else { 3072| 452| dns_rdata_t sigrdata = DNS_RDATA_INIT; ------------------ | | 147| 452| { \ | | 148| 452| .data = NULL, \ | | 149| 452| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 452|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 452| { \ | | | | | | 27| 452| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 452|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 452| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 452|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 452| } | | | | ------------------ | | ------------------ | | 150| 452| } ------------------ 3073| 452| dns_rdata_sig_t sig; 3074| 452| dns_rdataset_t keyset; 3075| 452| isc_result_t result; 3076| 452| uint32_t key_checks, message_checks; 3077| | 3078| 452| result = dns_rdataset_first(msg->sig0); 3079| 452| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 452|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 452| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 452, False: 0] | | | | ------------------ | | | | 55| 452| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3080| 452| dns_rdataset_current(msg->sig0, &sigrdata); 3081| | 3082| | /* 3083| | * This can occur when the message is a dynamic update, since 3084| | * the rdata length checking is relaxed. This should not 3085| | * happen in a well-formed message, since the SIG(0) is only 3086| | * looked for in the additional section, and the dynamic update 3087| | * meta-records are in the prerequisite and update sections. 3088| | */ 3089| 452| if (sigrdata.length == 0) { ------------------ | Branch (3089:7): [True: 0, False: 452] ------------------ 3090| 0| return ISC_R_UNEXPECTEDEND; 3091| 0| } 3092| | 3093| 452| RETERR(dns_rdata_tostruct(&sigrdata, &sig, NULL)); ------------------ | | 276| 452| { \ | | 277| 452| isc_result_t _r = (x); \ | | 278| 452| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 452] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 452| } ------------------ 3094| | 3095| 452| dns_rdataset_init(&keyset); 3096| 452| if (view == NULL) { ------------------ | Branch (3096:7): [True: 28, False: 424] ------------------ 3097| 28| result = DNS_R_KEYUNAUTHORIZED; 3098| 28| goto freesig; 3099| 28| } 3100| 424| result = dns_view_simplefind(view, &sig.signer, 3101| 424| dns_rdatatype_key /* SIG(0) */, 0, ------------------ | | 139| 424|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ 3102| 424| 0, false, &keyset, NULL); 3103| | 3104| 424| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3104:7): [True: 301, False: 123] ------------------ 3105| 301| result = DNS_R_KEYUNAUTHORIZED; 3106| 301| goto freesig; 3107| 301| } else if (keyset.trust < dns_trust_ultimate) { ------------------ | | 380| 123|#define dns_trust_ultimate ((dns_trust_t)dns_trust_ultimate) ------------------ | Branch (3107:14): [True: 0, False: 123] ------------------ 3108| 0| result = DNS_R_KEYUNAUTHORIZED; 3109| 0| goto freesig; 3110| 0| } 3111| 123| result = dns_rdataset_first(&keyset); 3112| 123| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 123|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 123, False: 0] | | | | ------------------ | | | | 55| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3113| | 3114| | /* 3115| | * In order to protect from a possible DoS attack, this function 3116| | * supports limitations on how many keyid checks and how many 3117| | * key checks (message verifications using a matched key) are 3118| | * going to be allowed. 3119| | */ 3120| 123| const uint32_t max_key_checks = 3121| 123| view->sig0key_checks_limit > 0 ------------------ | Branch (3121:4): [True: 0, False: 123] ------------------ 3122| 123| ? view->sig0key_checks_limit 3123| 123| : UINT32_MAX; 3124| 123| const uint32_t max_message_checks = 3125| 123| view->sig0message_checks_limit > 0 ------------------ | Branch (3125:4): [True: 0, False: 123] ------------------ 3126| 123| ? view->sig0message_checks_limit 3127| 123| : UINT32_MAX; 3128| | 3129| 123| for (key_checks = 0, message_checks = 0; 3130| 245| result == ISC_R_SUCCESS && key_checks < max_key_checks && ------------------ | Branch (3130:8): [True: 123, False: 122] | Branch (3130:35): [True: 123, False: 0] ------------------ 3131| 123| message_checks < max_message_checks; ------------------ | Branch (3131:8): [True: 123, False: 0] ------------------ 3132| 123| key_checks++, result = dns_rdataset_next(&keyset)) 3133| 123| { 3134| 123| dns_rdata_t keyrdata = DNS_RDATA_INIT; ------------------ | | 147| 123| { \ | | 148| 123| .data = NULL, \ | | 149| 123| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 123|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 123| { \ | | | | | | 27| 123| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 123|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 123| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 123|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 123| } | | | | ------------------ | | ------------------ | | 150| 123| } ------------------ 3135| 123| dns_rdata_key_t ks; 3136| 123| dst_key_t *key = NULL; 3137| 123| isc_region_t r; 3138| | 3139| 123| dns_rdataset_current(&keyset, &keyrdata); 3140| 123| dns_rdata_tostruct(&keyrdata, &ks, NULL); 3141| | 3142| 123| if (sig.algorithm != ks.algorithm || ------------------ | Branch (3142:8): [True: 9, False: 114] ------------------ 3143| 114| (ks.protocol != DNS_KEYPROTO_DNSSEC && ------------------ | Branch (3143:9): [True: 0, False: 114] ------------------ 3144| 0| ks.protocol != DNS_KEYPROTO_ANY)) ------------------ | Branch (3144:9): [True: 0, False: 0] ------------------ 3145| 9| { 3146| 9| continue; 3147| 9| } 3148| | 3149| 114| dns_rdata_toregion(&keyrdata, &r); 3150| 114| if (dst_region_computeid(&r) != sig.keyid) { ------------------ | Branch (3150:8): [True: 23, False: 91] ------------------ 3151| 23| continue; 3152| 23| } 3153| | 3154| 91| result = dns_dnssec_keyfromrdata(&sig.signer, &keyrdata, 3155| 91| view->mctx, &key); 3156| 91| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3156:8): [True: 0, False: 91] ------------------ 3157| 0| continue; 3158| 0| } 3159| | 3160| 91| result = dns_dnssec_verifymessage(&msgb, msg, key); 3161| 91| dst_key_free(&key); 3162| 91| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3162:8): [True: 1, False: 90] ------------------ 3163| 1| break; 3164| 1| } 3165| 90| message_checks++; 3166| 90| } 3167| 123| if (result == ISC_R_NOMORE) { ------------------ | Branch (3167:7): [True: 122, False: 1] ------------------ 3168| 122| result = DNS_R_KEYUNAUTHORIZED; 3169| 122| } else if (key_checks == max_key_checks) { ------------------ | Branch (3169:14): [True: 0, False: 1] ------------------ 3170| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, 3171| 0| DNS_LOGMODULE_MESSAGE, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 3172| 0| "sig0key-checks-limit reached when " 3173| 0| "trying to check a message signature"); 3174| 0| result = DNS_R_KEYUNAUTHORIZED; 3175| 1| } else if (message_checks == max_message_checks) { ------------------ | Branch (3175:14): [True: 0, False: 1] ------------------ 3176| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, 3177| 0| DNS_LOGMODULE_MESSAGE, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 3178| 0| "sig0message-checks-limit reached when " 3179| 0| "trying to check a message signature"); 3180| 0| result = DNS_R_KEYUNAUTHORIZED; 3181| 0| } 3182| | 3183| 452| freesig: 3184| | dns_rdataset_cleanup(&keyset); ------------------ | | 297| 452| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 452, Folded] | | | Branch (297:26): [True: 123, False: 329] | | ------------------ | | 298| 123| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 123| } ------------------ 3185| 452| dns_rdata_freestruct(&sig); 3186| 452| return result; 3187| 123| } 3188| 1.08k|} dns_message_createpools: 5029| 1.69k| isc_mempool_t **rdspoolp) { 5030| 1.69k| REQUIRE(mctx != NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5031| 1.69k| REQUIRE(namepoolp != NULL && *namepoolp == NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5032| 1.69k| REQUIRE(rdspoolp != NULL && *rdspoolp == NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5033| | 5034| 1.69k| isc_mempool_create(mctx, sizeof(dns_fixedname_t), "dns_fixedname_pool", ------------------ | | 382| 1.69k| isc__mempool_create((c), (s), (n), (mp)_ISC_MEM_FILELINE) ------------------ 5035| 1.69k| namepoolp); 5036| 1.69k| isc_mempool_setfillcount(*namepoolp, NAME_FILLCOUNT); ------------------ | | 124| 1.69k|#define NAME_FILLCOUNT 1024 ------------------ 5037| 1.69k| isc_mempool_setfreemax(*namepoolp, NAME_FREEMAX); ------------------ | | 125| 1.69k|#define NAME_FREEMAX 8 * NAME_FILLCOUNT | | ------------------ | | | | 124| 1.69k|#define NAME_FILLCOUNT 1024 | | ------------------ ------------------ 5038| | 5039| 1.69k| isc_mempool_create(mctx, sizeof(dns_rdataset_t), "dns_rdataset_pool", ------------------ | | 382| 1.69k| isc__mempool_create((c), (s), (n), (mp)_ISC_MEM_FILELINE) ------------------ 5040| 1.69k| rdspoolp); 5041| 1.69k| isc_mempool_setfillcount(*rdspoolp, RDATASET_FILLCOUNT); ------------------ | | 129| 1.69k|#define RDATASET_FILLCOUNT 1024 ------------------ 5042| 1.69k| isc_mempool_setfreemax(*rdspoolp, RDATASET_FREEMAX); ------------------ | | 130| 1.69k|#define RDATASET_FREEMAX 8 * RDATASET_FILLCOUNT | | ------------------ | | | | 129| 1.69k|#define RDATASET_FILLCOUNT 1024 | | ------------------ ------------------ 5043| 1.69k|} dns_message_destroypools: 5046| 1.69k|dns_message_destroypools(isc_mempool_t **namepoolp, isc_mempool_t **rdspoolp) { 5047| 1.69k| REQUIRE(namepoolp != NULL && *namepoolp != NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5048| 1.69k| REQUIRE(rdspoolp != NULL && *rdspoolp != NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 5049| | 5050| 1.69k| ENSURE(isc_mempool_getallocated(*namepoolp) == 0); ------------------ | | 200| 1.69k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 49| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 5051| 1.69k| ENSURE(isc_mempool_getallocated(*rdspoolp) == 0); ------------------ | | 200| 1.69k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 49| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 5052| | 5053| 1.69k| isc_mempool_destroy(rdspoolp); ------------------ | | 399| 1.69k|#define isc_mempool_destroy(mp) isc__mempool_destroy((mp)_ISC_MEM_FILELINE) ------------------ 5054| 1.69k| isc_mempool_destroy(namepoolp); ------------------ | | 399| 1.69k|#define isc_mempool_destroy(mp) isc__mempool_destroy((mp)_ISC_MEM_FILELINE) ------------------ 5055| 1.69k|} message.c:msginit: 425| 1.69k|msginit(dns_message_t *m) { 426| 1.69k| msginitheader(m); 427| 1.69k| msginitprivate(m); 428| 1.69k| msginittsig(m); 429| 1.69k| m->header_ok = 0; 430| 1.69k| m->question_ok = 0; 431| 1.69k| m->tcp_continuation = 0; 432| 1.69k| m->verified_sig = 0; 433| 1.69k| m->verify_attempted = 0; 434| 1.69k| m->query.base = NULL; 435| 1.69k| m->query.length = 0; 436| 1.69k| m->free_query = 0; 437| 1.69k| m->saved.base = NULL; 438| 1.69k| m->saved.length = 0; 439| 1.69k| m->free_saved = 0; 440| 1.69k| m->cc_ok = 0; 441| 1.69k| m->cc_bad = 0; 442| 1.69k| m->tkey = 0; 443| 1.69k| m->rdclass_set = 0; 444| 1.69k| m->has_dname = 0; 445| | m->querytsig = NULL; 446| 1.69k| m->indent.string = "\t"; 447| 1.69k| m->indent.count = 0; 448| 1.69k|} message.c:msginitheader: 378| 1.69k|msginitheader(dns_message_t *m) { 379| 1.69k| m->id = 0; 380| 1.69k| m->flags = 0; 381| 1.69k| m->rcode = 0; 382| 1.69k| m->opcode = 0; 383| 1.69k| m->rdclass = 0; 384| 1.69k|} message.c:msginittsig: 409| 1.69k|msginittsig(dns_message_t *m) { 410| 1.69k| m->tsigstatus = dns_rcode_noerror; ------------------ | | 269| 1.69k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 411| 1.69k| m->querytsigstatus = dns_rcode_noerror; ------------------ | | 269| 1.69k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 412| 1.69k| m->tsigkey = NULL; 413| 1.69k| m->tsigctx = NULL; 414| 1.69k| m->sigstart = -1; 415| 1.69k| m->sig0key = NULL; 416| 1.69k| m->sig0status = dns_rcode_noerror; ------------------ | | 269| 1.69k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 417| 1.69k| m->timeadjust = 0; 418| 1.69k|} message.c:msgreset: 540| 1.69k|msgreset(dns_message_t *msg, bool everything) { 541| 1.69k| dns_msgblock_t *msgblock = NULL, *next_msgblock = NULL; 542| 1.69k| isc_buffer_t *dynbuf = NULL, *next_dynbuf = NULL; 543| | 544| 1.69k| msgresetnames(msg, 0); 545| 1.69k| msgresetopt(msg); 546| 1.69k| msgresetsigs(msg, false); 547| 1.69k| msgresetedns(msg); 548| | 549| | /* 550| | * Clean up linked lists. 551| | */ 552| | 553| | /* 554| | * Run through the free lists, and just unlink anything found there. 555| | * The memory isn't lost since these are part of message blocks we 556| | * have allocated. 557| | */ 558| 1.69k| ISC_LIST_FOREACH(msg->freerdata, rdata, 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| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 1.69k] | | ------------------ | | 236| 1.69k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 1.69k] | | ------------------ | | 237| 1.69k| 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] | | ------------------ ------------------ 559| 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] | | | | ------------------ | | ------------------ ------------------ 560| 0| } 561| 1.69k| ISC_LIST_FOREACH(msg->freerdatalist, rdatalist, 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| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 0, False: 1.69k] | | ------------------ | | 236| 1.69k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 1.69k] | | ------------------ | | 237| 1.69k| 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] | | ------------------ ------------------ 562| 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] | | | | ------------------ | | ------------------ ------------------ 563| 0| } 564| | 565| 1.69k| dynbuf = ISC_LIST_HEAD(msg->scratchpad); ------------------ | | 62| 1.69k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 566| 1.69k| INSIST(dynbuf != NULL); ------------------ | | 202| 1.69k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 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))) | | ------------------ ------------------ 567| 1.69k| if (!everything) { ------------------ | Branch (567:6): [True: 0, False: 1.69k] ------------------ 568| 0| isc_buffer_clear(dynbuf); 569| 0| dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 570| 0| } 571| 3.75k| while (dynbuf != NULL) { ------------------ | Branch (571:9): [True: 2.06k, False: 1.69k] ------------------ 572| 2.06k| next_dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 2.06k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 573| 2.06k| ISC_LIST_UNLINK(msg->scratchpad, dynbuf, link); ------------------ | | 137| 2.06k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 2.06k| do { \ | | | | 133| 2.06k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 2.06k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 2.06k| do { \ | | | | | | 110| 2.06k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 368, False: 1.69k] | | | | | | ------------------ | | | | | | 111| 368| (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| 2.06k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 2.06k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 2.06k| } else { \ | | | | | | 119| 2.06k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2.06k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2.06k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 2.06k| (list).head = (elt)->link.next; \ | | | | | | 121| 2.06k| } \ | | | | | | 122| 2.06k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 2.06k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 2.06k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 2.06k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 2.06k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2.06k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2.06k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 2.06k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 2.06k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 2.06k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 2.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 2.06k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 2.06k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 2.06k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 2.06k] | | | | ------------------ | | ------------------ ------------------ 574| 2.06k| isc_buffer_free(&dynbuf); 575| 2.06k| dynbuf = next_dynbuf; 576| 2.06k| } 577| | 578| 1.69k| msgblock = ISC_LIST_HEAD(msg->rdatas); ------------------ | | 62| 1.69k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 579| 1.69k| if (!everything && msgblock != NULL) { ------------------ | Branch (579:6): [True: 0, False: 1.69k] | Branch (579:21): [True: 0, False: 0] ------------------ 580| 0| msgblock_reset(msgblock); 581| 0| msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 582| 0| } 583| 3.36k| while (msgblock != NULL) { ------------------ | Branch (583:9): [True: 1.67k, False: 1.69k] ------------------ 584| 1.67k| next_msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 1.67k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 585| 1.67k| ISC_LIST_UNLINK(msg->rdatas, msgblock, link); ------------------ | | 137| 1.67k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.67k| do { \ | | | | 133| 1.67k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.67k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.67k| do { \ | | | | | | 110| 1.67k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.67k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.67k| } else { \ | | | | | | 113| 1.67k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.67k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.67k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.67k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.67k| } \ | | | | | | 116| 1.67k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.67k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.67k| } else { \ | | | | | | 119| 1.67k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.67k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.67k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.67k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.67k| } \ | | | | | | 122| 1.67k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.67k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.67k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.67k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.67k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.67k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.67k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.67k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.67k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.67k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.67k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.67k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.67k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.67k] | | | | ------------------ | | ------------------ ------------------ 586| 1.67k| msgblock_free(msg->mctx, msgblock, sizeof(dns_rdata_t)); 587| 1.67k| msgblock = next_msgblock; 588| 1.67k| } 589| | 590| | /* 591| | * rdatalists could be empty. 592| | */ 593| | 594| 1.69k| msgblock = ISC_LIST_HEAD(msg->rdatalists); ------------------ | | 62| 1.69k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 595| 1.69k| if (!everything && msgblock != NULL) { ------------------ | Branch (595:6): [True: 0, False: 1.69k] | Branch (595:21): [True: 0, False: 0] ------------------ 596| 0| msgblock_reset(msgblock); 597| 0| msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 598| 0| } 599| 3.37k| while (msgblock != NULL) { ------------------ | Branch (599:9): [True: 1.68k, False: 1.69k] ------------------ 600| 1.68k| next_msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 1.68k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 601| 1.68k| ISC_LIST_UNLINK(msg->rdatalists, msgblock, link); ------------------ | | 137| 1.68k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.68k| do { \ | | | | 133| 1.68k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.68k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.68k| do { \ | | | | | | 110| 1.68k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.68k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.68k| } else { \ | | | | | | 113| 1.68k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.68k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.68k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.68k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.68k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.68k| } \ | | | | | | 116| 1.68k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.68k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.68k| } else { \ | | | | | | 119| 1.68k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.68k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.68k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.68k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.68k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.68k| } \ | | | | | | 122| 1.68k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.68k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.68k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.68k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.68k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.68k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.68k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.68k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.68k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.68k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.68k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.68k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.68k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.68k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.68k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.68k] | | | | ------------------ | | ------------------ ------------------ 602| 1.68k| msgblock_free(msg->mctx, msgblock, sizeof(dns_rdatalist_t)); 603| 1.68k| msgblock = next_msgblock; 604| 1.68k| } 605| | 606| 1.69k| if (msg->tsigkey != NULL) { ------------------ | Branch (606:6): [True: 628, False: 1.06k] ------------------ 607| 628| dns_tsigkey_detach(&msg->tsigkey); 608| 628| msg->tsigkey = NULL; 609| 628| } 610| | 611| 1.69k| if (msg->tsigctx != NULL) { ------------------ | Branch (611:6): [True: 0, False: 1.69k] ------------------ 612| 0| dst_context_destroy(&msg->tsigctx); 613| 0| } 614| | 615| 1.69k| if (msg->query.base != NULL) { ------------------ | Branch (615:6): [True: 0, False: 1.69k] ------------------ 616| 0| if (msg->free_query != 0) { ------------------ | Branch (616:7): [True: 0, False: 0] ------------------ 617| 0| isc_mem_put(msg->mctx, msg->query.base, ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 618| 0| msg->query.length); 619| 0| } 620| 0| msg->query.base = NULL; 621| 0| msg->query.length = 0; 622| 0| } 623| | 624| 1.69k| if (msg->saved.base != NULL) { ------------------ | Branch (624:6): [True: 1.69k, False: 0] ------------------ 625| 1.69k| if (msg->free_saved != 0) { ------------------ | Branch (625:7): [True: 0, False: 1.69k] ------------------ 626| 0| isc_mem_put(msg->mctx, msg->saved.base, ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 627| 0| msg->saved.length); 628| 0| } 629| 1.69k| msg->saved.base = NULL; 630| 1.69k| msg->saved.length = 0; 631| 1.69k| } 632| | 633| | /* 634| | * cleanup the buffer cleanup list 635| | */ 636| 1.69k| dynbuf = ISC_LIST_HEAD(msg->cleanup); ------------------ | | 62| 1.69k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 637| 1.89k| while (dynbuf != NULL) { ------------------ | Branch (637:9): [True: 200, False: 1.69k] ------------------ 638| 200| next_dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 200|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 639| 200| ISC_LIST_UNLINK(msg->cleanup, dynbuf, link); ------------------ | | 137| 200| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 200| do { \ | | | | 133| 200| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 200| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 200| do { \ | | | | | | 110| 200| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 200] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 200| } else { \ | | | | | | 113| 200| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 200| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 200, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 200| (list).tail = (elt)->link.prev; \ | | | | | | 115| 200| } \ | | | | | | 116| 200| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 200] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 200| } else { \ | | | | | | 119| 200| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 200| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 200, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 200| (list).head = (elt)->link.next; \ | | | | | | 121| 200| } \ | | | | | | 122| 200| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 200|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 200| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 200|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 200| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 200| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 200, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 200| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 200| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 200, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 200| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 200] | | | | | | ------------------ | | | | ------------------ | | | | 135| 200| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 200] | | | | ------------------ | | ------------------ ------------------ 640| 200| isc_buffer_free(&dynbuf); 641| 200| dynbuf = next_dynbuf; 642| 200| } 643| | 644| | /* 645| | * Set other bits to normal default values. 646| | */ 647| 1.69k| if (!everything) { ------------------ | Branch (647:6): [True: 0, False: 1.69k] ------------------ 648| 0| msginit(msg); 649| 0| } 650| 1.69k|} message.c:msgblock_free: 283| 3.36k| unsigned int sizeof_type) { 284| 3.36k| unsigned int length; 285| | 286| 3.36k| length = sizeof(dns_msgblock_t) + (sizeof_type * block->count); 287| | 288| | isc_mem_put(mctx, block, length); ------------------ | | 171| 3.36k| do { \ | | 172| 3.36k| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 3.36k| (p) = NULL; \ | | 174| 3.36k| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 3.36k] | | ------------------ ------------------ 289| 3.36k|} message.c:dns__message_destroy: 749| 1.69k|dns__message_destroy(dns_message_t *msg) { 750| 1.69k| REQUIRE(msg != NULL); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 751| 1.69k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 1.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | | Branch (42:11): [True: 1.69k, False: 0] | | | | ------------------ | | | | 43| 1.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 752| | 753| 1.69k| msgreset(msg, true); 754| | 755| 1.69k| msg->magic = 0; 756| | 757| 1.69k| if (msg->free_pools) { ------------------ | Branch (757:6): [True: 1.69k, False: 0] ------------------ 758| 1.69k| dns_message_destroypools(&msg->namepool, &msg->rdspool); 759| 1.69k| } 760| | 761| | isc_mem_putanddetach(&msg->mctx, msg, sizeof(dns_message_t)); ------------------ | | 187| 1.69k| do { \ | | 188| 1.69k| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 1.69k| (p) = NULL; \ | | 190| 1.69k| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 1.69k] | | ------------------ ------------------ 762| 1.69k|} message.c:early_sanity_check: 1545| 1.69k|early_sanity_check(dns_message_t *msg) { 1546| 1.69k| bool is_unknown_opcode = msg->opcode >= dns_opcode_max; 1547| 1.69k| bool is_query_response = (msg->flags & DNS_MESSAGEFLAG_QR) != 0; 1548| 1.69k| bool no_questions = msg->counts[DNS_SECTION_QUESTION] == 0; 1549| 1.69k| bool many_questions = msg->counts[DNS_SECTION_QUESTION] > 1; 1550| 1.69k| bool has_answer = msg->counts[DNS_SECTION_ANSWER] > 0; 1551| 1.69k| bool has_auth = msg->counts[DNS_SECTION_AUTHORITY] > 0; 1552| | 1553| 1.69k| if (is_unknown_opcode) { ------------------ | Branch (1553:6): [True: 8, False: 1.68k] ------------------ 1554| 8| return DNS_R_NOTIMP; 1555| 1.68k| } else if (many_questions) { ------------------ | Branch (1555:13): [True: 0, False: 1.68k] ------------------ 1556| 0| return DNS_R_FORMERR; 1557| 1.68k| } else if (no_questions && (msg->opcode != dns_opcode_query) && ------------------ | Branch (1557:13): [True: 0, False: 1.68k] | Branch (1557:29): [True: 0, False: 0] ------------------ 1558| 0| (msg->opcode != dns_opcode_status)) ------------------ | Branch (1558:6): [True: 0, False: 0] ------------------ 1559| 0| { 1560| | /* 1561| | * Per RFC9619, the two cases where qdcount == 0 is acceptable 1562| | * are AXFR transfers and cookies, and both have opcode 0. 1563| | * 1564| | * RFC9619 also specifies that msg->opcode == dns_opcode_status 1565| | * is unspecified, so we ignore it. 1566| | */ 1567| 0| return DNS_R_FORMERR; 1568| 1.68k| } else if (msg->opcode == dns_opcode_notify && ------------------ | Branch (1568:13): [True: 264, False: 1.42k] ------------------ 1569| 264| ((is_query_response && has_answer) || has_auth)) ------------------ | Branch (1569:8): [True: 22, False: 242] | Branch (1569:29): [True: 0, False: 22] | Branch (1569:44): [True: 0, False: 264] ------------------ 1570| 0| { 1571| 0| return DNS_R_FORMERR; 1572| 0| } 1573| 1.68k| return ISC_R_SUCCESS; 1574| 1.69k|} message.c:getquestions: 931| 1.68k| unsigned int options) { 932| 1.68k| isc_region_t r; 933| 1.68k| unsigned int count; 934| 1.68k| dns_name_t *name = NULL; 935| 1.68k| dns_rdataset_t *rdataset = NULL; 936| 1.68k| dns_rdatalist_t *rdatalist = NULL; 937| 1.68k| isc_result_t result = ISC_R_SUCCESS; 938| 1.68k| dns_rdatatype_t rdtype; 939| 1.68k| dns_rdataclass_t rdclass; 940| 1.68k| dns_namelist_t *section = &msg->sections[DNS_SECTION_QUESTION]; 941| 1.68k| bool best_effort = ((options & DNS_MESSAGEPARSE_BESTEFFORT) != 0); ------------------ | | 202| 1.68k| 0x0002 /*%< return a message if a \ ------------------ 942| 1.68k| bool seen_problem = false; 943| 1.68k| bool free_name = false; 944| | 945| 1.68k| REQUIRE(msg->counts[DNS_SECTION_QUESTION] <= 1 || best_effort); ------------------ | | 198| 1.68k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.68k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.68k, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 1.68k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 946| | 947| 3.36k| for (count = 0; count < msg->counts[DNS_SECTION_QUESTION]; count++) { ------------------ | Branch (947:18): [True: 1.68k, False: 1.68k] ------------------ 948| 1.68k| name = NULL; 949| 1.68k| dns_message_gettempname(msg, &name); 950| 1.68k| free_name = true; 951| | 952| | /* 953| | * Parse the name out of this packet. 954| | */ 955| 1.68k| isc_buffer_remainingregion(source, &r); 956| 1.68k| isc_buffer_setactive(source, r.length); 957| 1.68k| CHECK(getname(name, source, msg, dctx)); ------------------ | | 255| 1.68k| { \ | | 256| 1.68k| result = (r); \ | | 257| 1.68k| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 1.68k] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 1.68k| } ------------------ 958| | 959| 1.68k| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 1.68k| do { \ | | 101| 1.68k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.68k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.68k| do { \ | | | | 89| 1.68k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.68k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.68k| } else { \ | | | | 92| 1.68k| (list).head = (elt); \ | | | | 93| 1.68k| } \ | | | | 94| 1.68k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.68k| (elt)->link.next = NULL; \ | | | | 96| 1.68k| (list).tail = (elt); \ | | | | 97| 1.68k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.68k] | | | | ------------------ | | ------------------ | | 103| 1.68k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.68k] | | ------------------ ------------------ 960| | 961| 1.68k| free_name = false; 962| | 963| | /* 964| | * Get type and class. 965| | */ 966| 1.68k| isc_buffer_remainingregion(source, &r); 967| 1.68k| if (r.length < 4) { ------------------ | Branch (967:7): [True: 0, False: 1.68k] ------------------ 968| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 969| 0| } 970| 1.68k| rdtype = isc_buffer_getuint16(source); 971| 1.68k| rdclass = isc_buffer_getuint16(source); 972| | 973| | /* 974| | * Notify and update messages need to specify the data class. 975| | */ 976| 1.68k| if ((msg->opcode == dns_opcode_update || ------------------ | Branch (976:8): [True: 270, False: 1.41k] ------------------ 977| 1.41k| msg->opcode == dns_opcode_notify) && ------------------ | Branch (977:8): [True: 264, False: 1.15k] ------------------ 978| 534| (rdclass == dns_rdataclass_none || ------------------ | | 32| 1.06k|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (978:8): [True: 0, False: 534] ------------------ 979| 534| rdclass == dns_rdataclass_any)) ------------------ | | 34| 534|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (979:8): [True: 0, False: 534] ------------------ 980| 0| { 981| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 982| 0| } 983| | 984| | /* 985| | * If this class is different than the one we already read, 986| | * this is an error. 987| | */ 988| 1.68k| if (msg->rdclass_set == 0) { ------------------ | Branch (988:7): [True: 1.68k, False: 0] ------------------ 989| 1.68k| msg->rdclass = rdclass; 990| 1.68k| msg->rdclass_set = 1; 991| 1.68k| } else if (msg->rdclass != rdclass) { ------------------ | Branch (991:14): [True: 0, False: 0] ------------------ 992| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 993| 0| } 994| | 995| | /* 996| | * Is this a TKEY query? 997| | */ 998| 1.68k| if (rdtype == dns_rdatatype_tkey) { ------------------ | | 189| 1.68k|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (998:7): [True: 0, False: 1.68k] ------------------ 999| 0| msg->tkey = 1; 1000| 0| } 1001| | 1002| | /* 1003| | * Allocate a new rdatalist. 1004| | */ 1005| 1.68k| rdatalist = newrdatalist(msg); 1006| 1.68k| rdatalist->type = rdtype; 1007| 1.68k| rdatalist->rdclass = rdclass; 1008| 1.68k| rdatalist->covers = dns_rdatatype_none; ------------------ | | 114| 1.68k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1009| | 1010| | /* 1011| | * Convert rdatalist to rdataset, and attach the latter to 1012| | * the name. 1013| | */ 1014| 1.68k| dns_message_gettemprdataset(msg, &rdataset); 1015| 1.68k| dns_rdatalist_tordataset(rdatalist, rdataset); 1016| | 1017| 1.68k| rdataset->attributes.question = true; 1018| | 1019| 1.68k| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 1.68k| do { \ | | 101| 1.68k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.68k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.68k| do { \ | | | | 89| 1.68k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.68k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.68k| } else { \ | | | | 92| 1.68k| (list).head = (elt); \ | | | | 93| 1.68k| } \ | | | | 94| 1.68k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.68k| (elt)->link.next = NULL; \ | | | | 96| 1.68k| (list).tail = (elt); \ | | | | 97| 1.68k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.68k] | | | | ------------------ | | ------------------ | | 103| 1.68k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.68k] | | ------------------ ------------------ 1020| | 1021| 1.68k| rdataset = NULL; 1022| 1.68k| } 1023| | 1024| 1.68k| if (seen_problem) { ------------------ | Branch (1024:6): [True: 0, False: 1.68k] ------------------ 1025| | /* XXX test coverage */ 1026| 0| result = DNS_R_RECOVERABLE; 1027| 0| } 1028| | 1029| 1.68k|cleanup: 1030| 1.68k| if (rdataset != NULL) { ------------------ | Branch (1030:6): [True: 0, False: 1.68k] ------------------ 1031| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 297| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 0] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 1032| 0| dns_message_puttemprdataset(msg, &rdataset); 1033| 0| } 1034| | 1035| 1.68k| if (free_name) { ------------------ | Branch (1035:6): [True: 0, False: 1.68k] ------------------ 1036| 0| dns_message_puttempname(msg, &name); 1037| 0| } 1038| | 1039| 1.68k| return result; 1040| 1.68k|} message.c:getname: 830| 3.35k| dns_decompress_t dctx) { 831| 3.35k| isc_buffer_t *scratch; 832| 3.35k| isc_result_t result; 833| 3.35k| unsigned int tries; 834| | 835| 3.35k| scratch = currentbuffer(msg); 836| | 837| | /* 838| | * First try: use current buffer. 839| | * Second try: allocate a new buffer and use that. 840| | */ 841| 3.35k| tries = 0; 842| 3.35k| while (tries < 2) { ------------------ | Branch (842:9): [True: 3.35k, False: 0] ------------------ 843| 3.35k| result = dns_name_fromwire(name, source, dctx, scratch); 844| | 845| 3.35k| if (result == ISC_R_NOSPACE) { ------------------ | Branch (845:7): [True: 0, False: 3.35k] ------------------ 846| 0| tries++; 847| | 848| 0| newbuffer(msg, SCRATCHPAD_SIZE); ------------------ | | 123| 0|#define SCRATCHPAD_SIZE 1232 ------------------ 849| 0| scratch = currentbuffer(msg); 850| 0| dns_name_reset(name); 851| 3.35k| } else { 852| 3.35k| return result; 853| 3.35k| } 854| 3.35k| } 855| | 856| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 857| 3.35k|} message.c:currentbuffer: 306| 5.39k|currentbuffer(dns_message_t *msg) { 307| 5.39k| isc_buffer_t *dynbuf; 308| | 309| 5.39k| dynbuf = ISC_LIST_TAIL(msg->scratchpad); ------------------ | | 63| 5.39k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 310| 5.39k| INSIST(dynbuf != NULL); ------------------ | | 202| 5.39k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 5.39k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 5.39k, False: 0] | | | | ------------------ | | | | 55| 5.39k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 311| | 312| 5.39k| return dynbuf; 313| 5.39k|} message.c:newbuffer: 297| 368|newbuffer(dns_message_t *msg, unsigned int size) { 298| 368| isc_buffer_t *dynbuf = NULL; 299| | 300| 368| isc_buffer_allocate(msg->mctx, &dynbuf, size); 301| | 302| | ISC_LIST_APPEND(msg->scratchpad, dynbuf, link); ------------------ | | 100| 368| do { \ | | 101| 368| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 368| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 368| do { \ | | | | 89| 368| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 368, False: 0] | | | | ------------------ | | | | 90| 368| (list).tail->link.next = (elt); \ | | | | 91| 368| } else { \ | | | | 92| 0| (list).head = (elt); \ | | | | 93| 0| } \ | | | | 94| 368| (elt)->link.prev = (list).tail; \ | | | | 95| 368| (elt)->link.next = NULL; \ | | | | 96| 368| (list).tail = (elt); \ | | | | 97| 368| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 368] | | | | ------------------ | | ------------------ | | 103| 368| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 368] | | ------------------ ------------------ 303| 368|} message.c:getsection: 1056| 5.05k| dns_section_t sectionid, unsigned int options) { 1057| 5.05k| isc_region_t r; 1058| 5.05k| unsigned int count, rdatalen; 1059| 5.05k| dns_name_t *name = NULL; 1060| 5.05k| dns_name_t *found_name = NULL; 1061| 5.05k| dns_rdataset_t *rdataset = NULL; 1062| 5.05k| dns_rdataset_t *found_rdataset = NULL; 1063| 5.05k| dns_rdatalist_t *rdatalist = NULL; 1064| 5.05k| isc_result_t result = ISC_R_SUCCESS; 1065| 5.05k| dns_rdatatype_t rdtype, covers; 1066| 5.05k| dns_rdataclass_t rdclass; 1067| 5.05k| dns_rdata_t *rdata = NULL; 1068| 5.05k| dns_ttl_t ttl; 1069| 5.05k| dns_namelist_t *section = &msg->sections[sectionid]; 1070| 5.05k| bool free_name = false, seen_problem = false; 1071| 5.05k| bool free_hashmaps = false; 1072| 5.05k| bool preserve_order = ((options & DNS_MESSAGEPARSE_PRESERVEORDER) != 0); ------------------ | | 200| 5.05k|#define DNS_MESSAGEPARSE_PRESERVEORDER 0x0001 /*%< preserve rdata order */ ------------------ 1073| 5.05k| bool best_effort = ((options & DNS_MESSAGEPARSE_BESTEFFORT) != 0); ------------------ | | 202| 5.05k| 0x0002 /*%< return a message if a \ ------------------ 1074| 5.05k| bool isedns, issigzero, istsig; 1075| 5.05k| isc_hashmap_t *name_map = NULL; 1076| | 1077| 5.05k| if (msg->counts[sectionid] > 1) { ------------------ | Branch (1077:6): [True: 0, False: 5.05k] ------------------ 1078| 0| isc_hashmap_create(msg->mctx, 1, &name_map); 1079| 0| } 1080| | 1081| 6.18k| for (count = 0; count < msg->counts[sectionid]; count++) { ------------------ | Branch (1081:18): [True: 1.67k, False: 4.51k] ------------------ 1082| 1.67k| int recstart = source->current; 1083| 1.67k| bool skip_name_search, skip_type_search; 1084| | 1085| 1.67k| skip_name_search = false; 1086| 1.67k| skip_type_search = false; 1087| 1.67k| isedns = false; 1088| 1.67k| issigzero = false; 1089| 1.67k| istsig = false; 1090| 1.67k| found_rdataset = NULL; 1091| | 1092| 1.67k| name = NULL; 1093| 1.67k| dns_message_gettempname(msg, &name); 1094| 1.67k| free_name = true; 1095| | 1096| | /* 1097| | * Parse the name out of this packet. 1098| | */ 1099| 1.67k| isc_buffer_remainingregion(source, &r); 1100| 1.67k| isc_buffer_setactive(source, r.length); 1101| 1.67k| CHECK(getname(name, source, msg, dctx)); ------------------ | | 255| 1.67k| { \ | | 256| 1.67k| result = (r); \ | | 257| 1.67k| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 1.67k] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 1.67k| } ------------------ 1102| | 1103| | /* 1104| | * Get type, class, ttl, and rdatalen. Verify that at least 1105| | * rdatalen bytes remain. (Some of this is deferred to 1106| | * later.) 1107| | */ 1108| 1.67k| isc_buffer_remainingregion(source, &r); 1109| 1.67k| if (r.length < 2 + 2 + 4 + 2) { ------------------ | Branch (1109:7): [True: 0, False: 1.67k] ------------------ 1110| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1111| 0| } 1112| 1.67k| rdtype = isc_buffer_getuint16(source); 1113| 1.67k| rdclass = isc_buffer_getuint16(source); 1114| | 1115| | /* 1116| | * If there was no question section, we may not yet have 1117| | * established a class. Do so now. 1118| | */ 1119| 1.67k| if (msg->rdclass_set == 0 && ------------------ | Branch (1119:7): [True: 0, False: 1.67k] ------------------ 1120| 0| rdtype != dns_rdatatype_opt && /* class is UDP SIZE */ ------------------ | | 155| 1.67k|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1120:7): [True: 0, False: 0] ------------------ 1121| 0| rdtype != dns_rdatatype_tsig && /* class is ANY */ ------------------ | | 190| 1.67k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1121:7): [True: 0, False: 0] ------------------ 1122| 0| rdtype != dns_rdatatype_tkey) /* class is undefined */ ------------------ | | 189| 0|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1122:7): [True: 0, False: 0] ------------------ 1123| 0| { 1124| 0| msg->rdclass = rdclass; 1125| 0| msg->rdclass_set = 1; 1126| 0| } 1127| | 1128| | /* 1129| | * If this class is different than the one in the question 1130| | * section, bail. 1131| | */ 1132| 1.67k| if (msg->opcode != dns_opcode_update && ------------------ | Branch (1132:7): [True: 1.40k, False: 269] ------------------ 1133| 1.40k| rdtype != dns_rdatatype_tsig && ------------------ | | 190| 3.07k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1133:7): [True: 654, False: 748] ------------------ 1134| 654| rdtype != dns_rdatatype_opt && ------------------ | | 155| 2.32k|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1134:7): [True: 654, False: 0] ------------------ 1135| 654| rdtype != dns_rdatatype_key && /* in a TKEY query */ ------------------ | | 139| 2.32k|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ | Branch (1135:7): [True: 654, False: 0] ------------------ 1136| 654| rdtype != dns_rdatatype_sig && /* SIG(0) */ ------------------ | | 138| 2.32k|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ | Branch (1136:7): [True: 0, False: 654] ------------------ 1137| 0| rdtype != dns_rdatatype_tkey && /* Win2000 TKEY */ ------------------ | | 189| 1.67k|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1137:7): [True: 0, False: 0] ------------------ 1138| 0| msg->rdclass != dns_rdataclass_any && ------------------ | | 34| 1.67k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1138:7): [True: 0, False: 0] ------------------ 1139| 0| msg->rdclass != rdclass) ------------------ | Branch (1139:7): [True: 0, False: 0] ------------------ 1140| 0| { 1141| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1142| 0| } 1143| | 1144| | /* 1145| | * If this is not a TKEY query/response then the KEY 1146| | * record's class needs to match. 1147| | */ 1148| 1.67k| if (msg->opcode != dns_opcode_update && !msg->tkey && ------------------ | Branch (1148:7): [True: 1.40k, False: 269] | Branch (1148:43): [True: 1.40k, False: 0] ------------------ 1149| 1.40k| rdtype == dns_rdatatype_key && ------------------ | | 139| 3.07k|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ | Branch (1149:7): [True: 0, False: 1.40k] ------------------ 1150| 0| msg->rdclass != dns_rdataclass_any && ------------------ | | 34| 1.67k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1150:7): [True: 0, False: 0] ------------------ 1151| 0| msg->rdclass != rdclass) ------------------ | Branch (1151:7): [True: 0, False: 0] ------------------ 1152| 0| { 1153| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1154| 0| } 1155| | 1156| | /* 1157| | * Special type handling for TSIG, OPT, and TKEY. 1158| | */ 1159| 1.67k| if (rdtype == dns_rdatatype_tsig) { ------------------ | | 190| 1.67k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1159:7): [True: 982, False: 689] ------------------ 1160| | /* 1161| | * If it is a tsig, verify that it is in the 1162| | * additional data section. 1163| | */ 1164| 982| if (sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1164:8): [True: 0, False: 982] ------------------ 1165| 982| rdclass != dns_rdataclass_any || ------------------ | | 34| 1.96k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1165:8): [True: 0, False: 982] ------------------ 1166| 982| count != msg->counts[sectionid] - 1) ------------------ | Branch (1166:8): [True: 0, False: 982] ------------------ 1167| 0| { 1168| 0| DO_ERROR(DNS_R_BADTSIG); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1169| 982| } else { 1170| 982| skip_name_search = true; 1171| 982| skip_type_search = true; 1172| 982| istsig = true; 1173| 982| } 1174| 982| } else if (rdtype == dns_rdatatype_opt) { ------------------ | | 155| 689|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1174:14): [True: 0, False: 689] ------------------ 1175| | /* 1176| | * The name of an OPT record must be ".", it 1177| | * must be in the additional data section, and 1178| | * it must be the first OPT we've seen. 1179| | */ 1180| 0| if (!dns_name_equal(dns_rootname, name) || ------------------ | Branch (1180:8): [True: 0, False: 0] ------------------ 1181| 0| sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1181:8): [True: 0, False: 0] ------------------ 1182| 0| msg->opt != NULL) ------------------ | Branch (1182:8): [True: 0, False: 0] ------------------ 1183| 0| { 1184| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1185| 0| } else { 1186| 0| skip_name_search = true; 1187| 0| skip_type_search = true; 1188| 0| isedns = true; 1189| 0| } 1190| 689| } else if (rdtype == dns_rdatatype_tkey) { ------------------ | | 189| 689|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1190:14): [True: 0, False: 689] ------------------ 1191| | /* 1192| | * A TKEY must be in the additional section if this 1193| | * is a query, and the answer section if this is a 1194| | * response. Unless it's a Win2000 client. 1195| | * 1196| | * Its class is ignored. 1197| | */ 1198| 0| dns_section_t tkeysection; 1199| | 1200| 0| if ((msg->flags & DNS_MESSAGEFLAG_QR) == 0) { ------------------ | Branch (1200:8): [True: 0, False: 0] ------------------ 1201| 0| tkeysection = DNS_SECTION_ADDITIONAL; 1202| 0| } else { 1203| 0| tkeysection = DNS_SECTION_ANSWER; 1204| 0| } 1205| 0| if (sectionid != tkeysection && ------------------ | Branch (1205:8): [True: 0, False: 0] ------------------ 1206| 0| sectionid != DNS_SECTION_ANSWER) ------------------ | Branch (1206:8): [True: 0, False: 0] ------------------ 1207| 0| { 1208| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1209| 0| } 1210| 0| } 1211| | 1212| | /* 1213| | * ... now get ttl and rdatalen, and check buffer. 1214| | */ 1215| 1.67k| ttl = isc_buffer_getuint32(source); 1216| 1.67k| rdatalen = isc_buffer_getuint16(source); 1217| 1.67k| r.length -= (2 + 2 + 4 + 2); 1218| 1.67k| if (r.length < rdatalen) { ------------------ | Branch (1218:7): [True: 0, False: 1.67k] ------------------ 1219| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1220| 0| } 1221| | 1222| | /* 1223| | * Read the rdata from the wire format. Interpret the 1224| | * rdata according to its actual class, even if it had a 1225| | * DynDNS meta-class in the packet (unless this is a TSIG). 1226| | * Then put the meta-class back into the finished rdata. 1227| | */ 1228| 1.67k| rdata = newrdata(msg); 1229| 1.67k| if (msg->opcode == dns_opcode_update && ------------------ | Branch (1229:7): [True: 269, False: 1.40k] ------------------ 1230| 269| update(sectionid, rdclass)) ------------------ | Branch (1230:7): [True: 0, False: 269] ------------------ 1231| 0| { 1232| 0| if (rdatalen != 0) { ------------------ | Branch (1232:8): [True: 0, False: 0] ------------------ 1233| 0| CLEANUP(DNS_R_FORMERR); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1234| 0| } 1235| | /* 1236| | * When the rdata is empty, the data pointer is 1237| | * never dereferenced, but it must still be non-NULL. 1238| | * Casting 1 rather than "" avoids warnings about 1239| | * discarding the const attribute of a string, 1240| | * for compilers that would warn about such things. 1241| | */ 1242| 0| rdata->data = (unsigned char *)1; 1243| 0| rdata->length = 0; 1244| 0| rdata->rdclass = rdclass; 1245| 0| rdata->type = rdtype; 1246| 0| rdata->flags = DNS_RDATA_UPDATE; ------------------ | | 166| 0|#define DNS_RDATA_UPDATE 0x0001 /*%< update pseudo record. */ ------------------ 1247| 0| result = ISC_R_SUCCESS; 1248| 1.67k| } else if (rdclass == dns_rdataclass_none && ------------------ | | 32| 3.34k|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (1248:14): [True: 0, False: 1.67k] ------------------ 1249| 0| msg->opcode == dns_opcode_update && ------------------ | Branch (1249:7): [True: 0, False: 0] ------------------ 1250| 0| sectionid == DNS_SECTION_UPDATE) ------------------ | | 186| 0|#define DNS_SECTION_UPDATE DNS_SECTION_AUTHORITY ------------------ | Branch (1250:7): [True: 0, False: 0] ------------------ 1251| 0| { 1252| 0| result = getrdata(source, msg, dctx, msg->rdclass, 1253| 0| rdtype, rdatalen, rdata); 1254| 1.67k| } else { 1255| 1.67k| result = getrdata(source, msg, dctx, rdclass, rdtype, 1256| 1.67k| rdatalen, rdata); 1257| 1.67k| } 1258| 1.67k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1258:7): [True: 535, False: 1.13k] ------------------ 1259| 535| goto cleanup; 1260| 535| } 1261| 1.13k| rdata->rdclass = rdclass; 1262| 1.13k| if (rdtype == dns_rdatatype_rrsig && rdata->flags == 0) { ------------------ | | 160| 2.27k|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1262:7): [True: 0, False: 1.13k] | Branch (1262:40): [True: 0, False: 0] ------------------ 1263| 0| covers = dns_rdata_covers(rdata); 1264| | /* A signature can only cover a real rdata type */ 1265| 0| if (covers == dns_rdatatype_none || ------------------ | | 114| 0|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1265:8): [True: 0, False: 0] ------------------ 1266| 0| dns_rdatatype_ismeta(covers) || ------------------ | Branch (1266:8): [True: 0, False: 0] ------------------ 1267| 0| dns_rdatatype_issig(covers)) ------------------ | Branch (1267:8): [True: 0, False: 0] ------------------ 1268| 0| { 1269| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1270| 0| } 1271| 1.13k| } else if (rdtype == dns_rdatatype_sig /* SIG(0) */ && ------------------ | | 138| 2.27k|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ | Branch (1271:14): [True: 554, False: 582] ------------------ 1272| 554| rdata->flags == 0) ------------------ | Branch (1272:7): [True: 554, False: 0] ------------------ 1273| 554| { 1274| 554| covers = dns_rdata_covers(rdata); 1275| 554| if (covers == dns_rdatatype_none) { ------------------ | | 114| 554|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1275:8): [True: 462, False: 92] ------------------ 1276| 462| if (sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1276:9): [True: 0, False: 462] ------------------ 1277| 462| count != msg->counts[sectionid] - 1 || ------------------ | Branch (1277:9): [True: 0, False: 462] ------------------ 1278| 462| !dns_name_equal(name, dns_rootname)) ------------------ | Branch (1278:9): [True: 0, False: 462] ------------------ 1279| 0| { 1280| 0| DO_ERROR(DNS_R_BADSIG0); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1281| 462| } else { 1282| 462| skip_name_search = true; 1283| 462| skip_type_search = true; 1284| 462| issigzero = true; 1285| 462| } 1286| 462| } else { 1287| 92| covers = dns_rdatatype_none; ------------------ | | 114| 92|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1288| 92| } 1289| 582| } else { 1290| 582| covers = dns_rdatatype_none; ------------------ | | 114| 582|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1291| 582| } 1292| | 1293| | /* 1294| | * Check the ownername of NSEC3 records 1295| | */ 1296| 1.13k| if (rdtype == dns_rdatatype_nsec3 && ------------------ | | 164| 2.27k|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1296:7): [True: 0, False: 1.13k] ------------------ 1297| 0| !dns_rdata_checkowner(name, msg->rdclass, rdtype, false)) ------------------ | Branch (1297:7): [True: 0, False: 0] ------------------ 1298| 0| { 1299| 0| CLEANUP(DNS_R_BADOWNERNAME); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1300| 0| } 1301| | 1302| | /* 1303| | * If we are doing a dynamic update or this is a meta-type, 1304| | * don't bother searching for a name, just append this one 1305| | * to the end of the message. 1306| | */ 1307| 1.13k| if (preserve_order || msg->opcode == dns_opcode_update || ------------------ | Branch (1307:7): [True: 0, False: 1.13k] | Branch (1307:25): [True: 167, False: 969] ------------------ 1308| 969| skip_name_search) ------------------ | Branch (1308:7): [True: 885, False: 84] ------------------ 1309| 1.05k| { 1310| 1.05k| if (!isedns && !istsig && !issigzero) { ------------------ | Branch (1310:8): [True: 1.05k, False: 0] | Branch (1310:19): [True: 470, False: 582] | Branch (1310:30): [True: 8, False: 462] ------------------ 1311| 8| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 8| do { \ | | 101| 8| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 8| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 8| do { \ | | | | 89| 8| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 8] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 8| } else { \ | | | | 92| 8| (list).head = (elt); \ | | | | 93| 8| } \ | | | | 94| 8| (elt)->link.prev = (list).tail; \ | | | | 95| 8| (elt)->link.next = NULL; \ | | | | 96| 8| (list).tail = (elt); \ | | | | 97| 8| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 8] | | | | ------------------ | | ------------------ | | 103| 8| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 8] | | ------------------ ------------------ 1312| 8| free_name = false; 1313| 8| } 1314| 1.05k| } else { 1315| 84| if (name_map == NULL) { ------------------ | Branch (1315:8): [True: 84, False: 0] ------------------ 1316| 84| result = ISC_R_SUCCESS; 1317| 84| goto skip_name_check; 1318| 84| } 1319| | 1320| | /* 1321| | * Run through the section, looking to see if this name 1322| | * is already there. If it is found, put back the 1323| | * allocated name since we no longer need it, and set 1324| | * our name pointer to point to the name we found. 1325| | */ 1326| 0| result = isc_hashmap_add(name_map, dns_name_hash(name), 1327| 0| name_match, name, name, 1328| 0| (void **)&found_name); 1329| | 1330| | /* 1331| | * If it is a new name, append to the section. 1332| | */ 1333| 84| skip_name_check: 1334| 84| switch (result) { 1335| 84| case ISC_R_SUCCESS: ------------------ | Branch (1335:4): [True: 84, False: 0] ------------------ 1336| 84| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 84| do { \ | | 101| 84| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 84| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 84| do { \ | | | | 89| 84| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 84] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 84| } else { \ | | | | 92| 84| (list).head = (elt); \ | | | | 93| 84| } \ | | | | 94| 84| (elt)->link.prev = (list).tail; \ | | | | 95| 84| (elt)->link.next = NULL; \ | | | | 96| 84| (list).tail = (elt); \ | | | | 97| 84| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 84] | | | | ------------------ | | ------------------ | | 103| 84| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 84] | | ------------------ ------------------ 1337| 84| break; 1338| 0| case ISC_R_EXISTS: ------------------ | Branch (1338:4): [True: 0, False: 84] ------------------ 1339| 0| dns_message_puttempname(msg, &name); 1340| 0| name = found_name; 1341| 0| found_name = NULL; 1342| 0| break; 1343| 0| default: ------------------ | Branch (1343:4): [True: 0, False: 84] ------------------ 1344| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1345| 84| } 1346| 84| free_name = false; 1347| 84| } 1348| | 1349| 1.13k| rdatalist = newrdatalist(msg); 1350| 1.13k| rdatalist->type = rdtype; 1351| 1.13k| rdatalist->covers = covers; 1352| 1.13k| rdatalist->rdclass = rdclass; 1353| 1.13k| rdatalist->ttl = ttl; 1354| | 1355| 1.13k| dns_message_gettemprdataset(msg, &rdataset); 1356| 1.13k| dns_rdatalist_tordataset(rdatalist, rdataset); 1357| 1.13k| dns_rdataset_setownercase(rdataset, name); 1358| 1.13k| rdatalist = NULL; 1359| | 1360| | /* 1361| | * Search name for the particular type and class. 1362| | * Skip this stage if in update mode or this is a meta-type. 1363| | */ 1364| 1.13k| if (isedns || istsig || issigzero) { ------------------ | Branch (1364:7): [True: 0, False: 1.13k] | Branch (1364:17): [True: 582, False: 554] | Branch (1364:27): [True: 462, False: 92] ------------------ 1365| | /* Skip adding the rdataset to the tables */ 1366| 1.04k| } else if (preserve_order || msg->opcode == dns_opcode_update || ------------------ | Branch (1366:14): [True: 0, False: 92] | Branch (1366:32): [True: 8, False: 84] ------------------ 1367| 84| skip_type_search) ------------------ | Branch (1367:7): [True: 0, False: 84] ------------------ 1368| 8| { 1369| 8| result = ISC_R_SUCCESS; 1370| | 1371| 8| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 8| do { \ | | 101| 8| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 8| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 8| do { \ | | | | 89| 8| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 8] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 8| } else { \ | | | | 92| 8| (list).head = (elt); \ | | | | 93| 8| } \ | | | | 94| 8| (elt)->link.prev = (list).tail; \ | | | | 95| 8| (elt)->link.next = NULL; \ | | | | 96| 8| (list).tail = (elt); \ | | | | 97| 8| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 8] | | | | ------------------ | | ------------------ | | 103| 8| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 8] | | ------------------ ------------------ 1372| 84| } else { 1373| | /* 1374| | * If this is a type that can only occur in 1375| | * the question section, fail. 1376| | */ 1377| 84| if (dns_rdatatype_questiononly(rdtype)) { ------------------ | Branch (1377:8): [True: 0, False: 84] ------------------ 1378| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1379| 0| } 1380| | 1381| 84| if (ISC_LIST_EMPTY(name->list)) { ------------------ | | 64| 84|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (64:30): [True: 84, False: 0] | | ------------------ ------------------ 1382| 84| result = ISC_R_SUCCESS; 1383| 84| goto skip_rds_check; 1384| 84| } 1385| | 1386| 0| if (name->hashmap == NULL) { ------------------ | Branch (1386:8): [True: 0, False: 0] ------------------ 1387| 0| isc_hashmap_create(msg->mctx, 1, 1388| 0| &name->hashmap); 1389| 0| free_hashmaps = true; 1390| | 1391| 0| INSIST(ISC_LIST_HEAD(name->list) == ------------------ | | 202| 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))) | | ------------------ ------------------ 1392| 0| ISC_LIST_TAIL(name->list)); 1393| | 1394| 0| dns_rdataset_t *old_rdataset = 1395| 0| ISC_LIST_HEAD(name->list); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1396| | 1397| 0| result = isc_hashmap_add( 1398| 0| name->hashmap, rds_hash(old_rdataset), 1399| 0| rds_match, old_rdataset, old_rdataset, 1400| 0| NULL); 1401| | 1402| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 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))) | | ------------------ ------------------ 1403| 0| } 1404| | 1405| 0| result = isc_hashmap_add( 1406| 0| name->hashmap, rds_hash(rdataset), rds_match, 1407| 0| rdataset, rdataset, (void **)&found_rdataset); 1408| | 1409| | /* 1410| | * If we found an rdataset that matches, we need to 1411| | * append this rdata to that set. If we did not, we 1412| | * need to create a new rdatalist, store the important 1413| | * bits there, convert it to an rdataset, and link the 1414| | * latter to the name. Yuck. When appending, make 1415| | * certain that the type isn't a singleton type, such as 1416| | * SOA or CNAME. 1417| | * 1418| | * Note that this check will be bypassed when preserving 1419| | * order, the opcode is an update, or the type search is 1420| | * skipped. 1421| | */ 1422| 84| skip_rds_check: 1423| 84| switch (result) { 1424| 0| case ISC_R_EXISTS: ------------------ | Branch (1424:4): [True: 0, False: 84] ------------------ 1425| | /* Free the rdataset we used as the key */ 1426| 0| dns__message_putassociatedrdataset(msg, 1427| 0| &rdataset); 1428| 0| result = ISC_R_SUCCESS; 1429| 0| rdataset = found_rdataset; 1430| | 1431| 0| if (!dns_rdatatype_issingleton(rdtype)) { ------------------ | Branch (1431:9): [True: 0, False: 0] ------------------ 1432| 0| break; 1433| 0| } 1434| | 1435| 0| dns_rdatalist_fromrdataset(rdataset, 1436| 0| &rdatalist); 1437| 0| dns_rdata_t *first = 1438| 0| ISC_LIST_HEAD(rdatalist->rdata); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1439| 0| INSIST(first != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 1440| 0| if (dns_rdata_compare(rdata, first) != 0) { ------------------ | Branch (1440:9): [True: 0, False: 0] ------------------ 1441| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 911| 0| do { \ | | 912| 0| if (best_effort) { \ | | ------------------ | | | Branch (912:7): [True: 0, False: 0] | | ------------------ | | 913| 0| seen_problem = true; \ | | 914| 0| } else { \ | | 915| 0| result = r; \ | | 916| 0| goto cleanup; \ | | 917| 0| } \ | | 918| 0| } while (0) | | ------------------ | | | Branch (918:11): [Folded, False: 0] | | ------------------ ------------------ 1442| 0| } 1443| 0| break; 1444| 84| case ISC_R_SUCCESS: ------------------ | Branch (1444:4): [True: 84, False: 0] ------------------ 1445| 84| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 84| do { \ | | 101| 84| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 84| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 84| do { \ | | | | 89| 84| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 84] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 84| } else { \ | | | | 92| 84| (list).head = (elt); \ | | | | 93| 84| } \ | | | | 94| 84| (elt)->link.prev = (list).tail; \ | | | | 95| 84| (elt)->link.next = NULL; \ | | | | 96| 84| (list).tail = (elt); \ | | | | 97| 84| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 84] | | | | ------------------ | | ------------------ | | 103| 84| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 84] | | ------------------ ------------------ 1446| 84| break; 1447| 0| default: ------------------ | Branch (1447:4): [True: 0, False: 84] ------------------ 1448| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1449| 84| } 1450| 84| } 1451| | 1452| | /* 1453| | * Minimize TTLs. 1454| | * 1455| | * Section 5.2 of RFC2181 says we should drop 1456| | * nonauthoritative rrsets where the TTLs differ, but we 1457| | * currently treat them the as if they were authoritative and 1458| | * minimize them. 1459| | */ 1460| 1.13k| if (ttl != rdataset->ttl) { ------------------ | Branch (1460:7): [True: 0, False: 1.13k] ------------------ 1461| 0| rdataset->attributes.ttladjusted = true; 1462| 0| if (ttl < rdataset->ttl) { ------------------ | Branch (1462:8): [True: 0, False: 0] ------------------ 1463| 0| rdataset->ttl = ttl; 1464| 0| } 1465| 0| } 1466| | 1467| | /* Append this rdata to the rdataset. */ 1468| 1.13k| dns_rdatalist_fromrdataset(rdataset, &rdatalist); 1469| 1.13k| ISC_LIST_APPEND(rdatalist->rdata, rdata, link); ------------------ | | 100| 1.13k| do { \ | | 101| 1.13k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.13k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.13k| do { \ | | | | 89| 1.13k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.13k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.13k| } else { \ | | | | 92| 1.13k| (list).head = (elt); \ | | | | 93| 1.13k| } \ | | | | 94| 1.13k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.13k| (elt)->link.next = NULL; \ | | | | 96| 1.13k| (list).tail = (elt); \ | | | | 97| 1.13k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.13k] | | | | ------------------ | | ------------------ | | 103| 1.13k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.13k] | | ------------------ ------------------ 1470| | 1471| | /* 1472| | * If this is an OPT, SIG(0) or TSIG record, remember it. 1473| | * Also, set the extended rcode for TSIG. 1474| | * 1475| | * Note msg->opt, msg->sig0 and msg->tsig will only be 1476| | * already set if best-effort parsing is enabled otherwise 1477| | * there will only be at most one of each. 1478| | */ 1479| 1.13k| if (isedns) { ------------------ | Branch (1479:7): [True: 0, False: 1.13k] ------------------ 1480| 0| dns_rcode_t ercode; 1481| | 1482| 0| msg->opt = rdataset; 1483| 0| ercode = (dns_rcode_t)((msg->opt->ttl & 1484| 0| DNS_MESSAGE_EDNSRCODE_MASK) >> ------------------ | | 88| 0|#define DNS_MESSAGE_EDNSRCODE_MASK 0xff000000U ------------------ 1485| 0| 20); 1486| 0| msg->rcode |= ercode; 1487| 0| dns_message_puttempname(msg, &name); 1488| 0| free_name = false; 1489| 1.13k| } else if (issigzero) { ------------------ | Branch (1489:14): [True: 462, False: 674] ------------------ 1490| 462| msg->sig0 = rdataset; 1491| 462| msg->sig0name = name; 1492| 462| msg->sigstart = recstart; 1493| 462| free_name = false; 1494| 674| } else if (istsig) { ------------------ | Branch (1494:14): [True: 582, False: 92] ------------------ 1495| 582| msg->tsig = rdataset; 1496| 582| msg->tsigname = name; 1497| 582| msg->sigstart = recstart; 1498| | /* 1499| | * Windows doesn't like TSIG names to be compressed. 1500| | */ 1501| 582| msg->tsigname->attributes.nocompress = true; 1502| 582| free_name = false; 1503| 582| } else if (rdtype == dns_rdatatype_dname && ------------------ | | 153| 184|#define dns_rdatatype_dname ((dns_rdatatype_t)dns_rdatatype_dname) ------------------ | Branch (1503:14): [True: 0, False: 92] ------------------ 1504| 0| sectionid == DNS_SECTION_ANSWER && ------------------ | Branch (1504:7): [True: 0, False: 0] ------------------ 1505| 0| msg->opcode == dns_opcode_query) ------------------ | Branch (1505:7): [True: 0, False: 0] ------------------ 1506| 0| { 1507| 0| msg->has_dname = 1; 1508| 0| } 1509| 1.13k| rdataset = NULL; 1510| | 1511| 1.13k| if (seen_problem) { ------------------ | Branch (1511:7): [True: 0, False: 1.13k] ------------------ 1512| 0| if (free_name) { ------------------ | Branch (1512:8): [True: 0, False: 0] ------------------ 1513| | /* XXX test coverage */ 1514| 0| dns_message_puttempname(msg, &name); 1515| 0| } 1516| 0| free_name = false; 1517| 0| } 1518| 1.13k| INSIST(!free_name); ------------------ | | 202| 1.13k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.13k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.13k, False: 0] | | | | ------------------ | | | | 55| 1.13k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1519| 1.13k| } 1520| | 1521| 4.51k| if (seen_problem) { ------------------ | Branch (1521:6): [True: 0, False: 4.51k] ------------------ 1522| 0| result = DNS_R_RECOVERABLE; 1523| 0| } 1524| | 1525| 5.05k|cleanup: 1526| 5.05k| if (rdataset != NULL && rdataset != found_rdataset) { ------------------ | Branch (1526:6): [True: 0, False: 5.05k] | Branch (1526:26): [True: 0, False: 0] ------------------ 1527| 0| dns__message_putassociatedrdataset(msg, &rdataset); 1528| 0| } 1529| 5.05k| if (free_name) { ------------------ | Branch (1529:6): [True: 535, False: 4.51k] ------------------ 1530| 535| dns_message_puttempname(msg, &name); 1531| 535| } 1532| | 1533| 5.05k| if (free_hashmaps) { ------------------ | Branch (1533:6): [True: 0, False: 5.05k] ------------------ 1534| 0| cleanup_name_hashmaps(section); 1535| 0| } 1536| | 1537| 5.05k| if (name_map != NULL) { ------------------ | Branch (1537:6): [True: 0, False: 5.05k] ------------------ 1538| 0| isc_hashmap_destroy(&name_map); 1539| 0| } 1540| | 1541| 5.05k| return result; 1542| 4.51k|} message.c:update: 1043| 269|update(dns_section_t section, dns_rdataclass_t rdclass) { 1044| 269| if (section == DNS_SECTION_PREREQUISITE) { ------------------ | | 185| 269|#define DNS_SECTION_PREREQUISITE DNS_SECTION_ANSWER ------------------ | Branch (1044:6): [True: 0, False: 269] ------------------ 1045| 0| return rdclass == dns_rdataclass_any || ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1045:10): [True: 0, False: 0] ------------------ 1046| 0| rdclass == dns_rdataclass_none; ------------------ | | 32| 0|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (1046:10): [True: 0, False: 0] ------------------ 1047| 0| } 1048| 269| if (section == DNS_SECTION_UPDATE) { ------------------ | | 186| 269|#define DNS_SECTION_UPDATE DNS_SECTION_AUTHORITY ------------------ | Branch (1048:6): [True: 0, False: 269] ------------------ 1049| 0| return rdclass == dns_rdataclass_any; ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ 1050| 0| } 1051| 269| return false; 1052| 269|} message.c:getrdata: 862| 1.67k| unsigned int rdatalen, dns_rdata_t *rdata) { 863| 1.67k| isc_buffer_t *scratch; 864| 1.67k| isc_result_t result; 865| 1.67k| unsigned int tries; 866| 1.67k| unsigned int trysize; 867| | 868| 1.67k| scratch = currentbuffer(msg); 869| | 870| 1.67k| isc_buffer_setactive(source, rdatalen); 871| | 872| | /* 873| | * First try: use current buffer. 874| | * Second try: allocate a new buffer of size 875| | * max(SCRATCHPAD_SIZE, 2 * compressed_rdatalen) 876| | * (the data will fit if it was not more than 50% compressed) 877| | * Subsequent tries: double buffer size on each try. 878| | */ 879| 1.67k| tries = 0; 880| 1.67k| trysize = 0; 881| | /* XXX possibly change this to a while (tries < 2) loop */ 882| 2.03k| for (;;) { 883| 2.03k| result = dns_rdata_fromwire(rdata, rdclass, rdtype, source, 884| 2.03k| dctx, scratch); 885| | 886| 2.03k| if (result == ISC_R_NOSPACE) { ------------------ | Branch (886:7): [True: 368, False: 1.67k] ------------------ 887| 368| if (tries == 0) { ------------------ | Branch (887:8): [True: 368, False: 0] ------------------ 888| 368| trysize = 2 * rdatalen; 889| 368| if (trysize < SCRATCHPAD_SIZE) { ------------------ | | 123| 368|#define SCRATCHPAD_SIZE 1232 ------------------ | Branch (889:9): [True: 0, False: 368] ------------------ 890| 0| trysize = SCRATCHPAD_SIZE; ------------------ | | 123| 0|#define SCRATCHPAD_SIZE 1232 ------------------ 891| 0| } 892| 368| } else { 893| 0| INSIST(trysize != 0); ------------------ | | 202| 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))) | | ------------------ ------------------ 894| 0| if (trysize >= 65535) { ------------------ | Branch (894:9): [True: 0, False: 0] ------------------ 895| 0| return ISC_R_NOSPACE; 896| 0| } 897| | /* XXX DNS_R_RRTOOLONG? */ 898| 0| trysize *= 2; 899| 0| } 900| 368| tries++; 901| 368| newbuffer(msg, trysize); 902| | 903| 368| scratch = currentbuffer(msg); 904| 1.67k| } else { 905| 1.67k| return result; 906| 1.67k| } 907| 2.03k| } 908| 1.67k|} message.c:msgresetnames: 459| 1.69k|msgresetnames(dns_message_t *msg, unsigned int first_section) { 460| | /* Clean up name lists. */ 461| 8.46k| for (size_t i = first_section; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (461:33): [True: 6.76k, False: 1.69k] ------------------ 462| 6.76k| ISC_LIST_FOREACH(msg->sections[i], name, link) { ------------------ | | 234| 6.76k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 6.76k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 6.76k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 1.77k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 1.77k, False: 4.99k] | | ------------------ | | 236| 8.54k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 1.77k, False: 6.76k] | | ------------------ | | 237| 6.76k| elt = elt##_next, \ | | 238| 1.77k| 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.77k] | | ------------------ ------------------ 463| | ISC_LIST_UNLINK(msg->sections[i], name, link); ------------------ | | 137| 1.77k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.77k| do { \ | | | | 133| 1.77k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.77k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.77k| do { \ | | | | | | 110| 1.77k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.77k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.77k| } else { \ | | | | | | 113| 1.77k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.77k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.77k| } \ | | | | | | 116| 1.77k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.77k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.77k| } else { \ | | | | | | 119| 1.77k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.77k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.77k| } \ | | | | | | 122| 1.77k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.77k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.77k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.77k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.77k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.77k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.77k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.77k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.77k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.77k] | | | | ------------------ | | ------------------ ------------------ 464| 1.77k| msgresetname(msg, name); 465| 1.77k| dns_message_puttempname(msg, &name); 466| 1.77k| } 467| 6.76k| } 468| 1.69k|} message.c:msgresetname: 451| 1.77k|msgresetname(dns_message_t *msg, dns_name_t *name) { 452| 1.77k| ISC_LIST_FOREACH(name->list, rds, link) { ------------------ | | 234| 1.77k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 1.77k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 1.77k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 1.77k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 1.77k, False: 0] | | ------------------ | | 236| 3.55k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 1.77k, False: 1.77k] | | ------------------ | | 237| 1.77k| elt = elt##_next, \ | | 238| 1.77k| 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.77k] | | ------------------ ------------------ 453| | ISC_LIST_UNLINK(name->list, rds, link); ------------------ | | 137| 1.77k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.77k| do { \ | | | | 133| 1.77k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.77k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.77k| do { \ | | | | | | 110| 1.77k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.77k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.77k| } else { \ | | | | | | 113| 1.77k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.77k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.77k| } \ | | | | | | 116| 1.77k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.77k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.77k| } else { \ | | | | | | 119| 1.77k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.77k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.77k| } \ | | | | | | 122| 1.77k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.77k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.77k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.77k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.77k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.77k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 1.77k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 1.77k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 1.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.77k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.77k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.77k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.77k] | | | | ------------------ | | ------------------ ------------------ 454| 1.77k| dns__message_putassociatedrdataset(msg, &rds); 455| 1.77k| } 456| 1.77k|} message.c:newrdata: 321| 1.87k|newrdata(dns_message_t *msg) { 322| 1.87k| dns_msgblock_t *msgblock; 323| 1.87k| dns_rdata_t *rdata; 324| | 325| 1.87k| rdata = ISC_LIST_HEAD(msg->freerdata); ------------------ | | 62| 1.87k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 326| 1.87k| if (rdata != NULL) { ------------------ | Branch (326:6): [True: 0, False: 1.87k] ------------------ 327| 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] | | | | ------------------ | | ------------------ ------------------ 328| 0| dns_rdata_reset(rdata); 329| 0| return rdata; 330| 0| } 331| | 332| 1.87k| msgblock = ISC_LIST_TAIL(msg->rdatas); ------------------ | | 63| 1.87k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 333| 1.87k| rdata = msgblock_get(msgblock, dns_rdata_t); ------------------ | | 190| 1.87k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 334| 1.87k| if (rdata == NULL) { ------------------ | Branch (334:6): [True: 1.67k, False: 195] ------------------ 335| 1.67k| msgblock = msgblock_allocate(msg->mctx, sizeof(dns_rdata_t), 336| 1.67k| RDATA_COUNT); ------------------ | | 127| 1.67k|#define RDATA_COUNT 8 ------------------ 337| 1.67k| ISC_LIST_APPEND(msg->rdatas, msgblock, link); ------------------ | | 100| 1.67k| do { \ | | 101| 1.67k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.67k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.67k| do { \ | | | | 89| 1.67k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.67k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.67k| } else { \ | | | | 92| 1.67k| (list).head = (elt); \ | | | | 93| 1.67k| } \ | | | | 94| 1.67k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.67k| (elt)->link.next = NULL; \ | | | | 96| 1.67k| (list).tail = (elt); \ | | | | 97| 1.67k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.67k] | | | | ------------------ | | ------------------ | | 103| 1.67k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.67k] | | ------------------ ------------------ 338| | 339| 1.67k| rdata = msgblock_get(msgblock, dns_rdata_t); ------------------ | | 190| 1.67k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 340| 1.67k| } 341| | 342| 1.87k| dns_rdata_init(rdata); 343| 1.87k| return rdata; 344| 1.87k|} message.c:msgblock_internalget: 258| 8.25k|msgblock_internalget(dns_msgblock_t *block, unsigned int sizeof_type) { 259| 8.25k| void *ptr; 260| | 261| 8.25k| if (block == NULL || block->remaining == 0) { ------------------ | Branch (261:6): [True: 3.36k, False: 4.89k] | Branch (261:23): [True: 0, False: 4.89k] ------------------ 262| 3.36k| return NULL; 263| 3.36k| } 264| | 265| 4.89k| block->remaining--; 266| | 267| 4.89k| ptr = (((unsigned char *)block) + sizeof(dns_msgblock_t) + 268| 4.89k| (sizeof_type * block->remaining)); 269| | 270| 4.89k| return ptr; 271| 8.25k|} message.c:msgblock_allocate: 237| 3.36k| unsigned int count) { 238| 3.36k| dns_msgblock_t *block; 239| 3.36k| unsigned int length; 240| | 241| 3.36k| length = sizeof(dns_msgblock_t) + (sizeof_type * count); 242| | 243| 3.36k| block = isc_mem_get(mctx, length); ------------------ | | 144| 3.36k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 244| | 245| 3.36k| block->count = count; 246| 3.36k| block->remaining = count; 247| | 248| 3.36k| ISC_LINK_INIT(block, link); ------------------ | | 57| 3.36k|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 3.36k| do { \ | | | | 54| 3.36k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 3.36k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 3.36k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 3.36k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 3.36k| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 3.36k] | | | | ------------------ | | ------------------ ------------------ 249| | 250| 3.36k| return block; 251| 3.36k|} message.c:newrdatalist: 352| 3.02k|newrdatalist(dns_message_t *msg) { 353| 3.02k| dns_msgblock_t *msgblock; 354| 3.02k| dns_rdatalist_t *rdatalist; 355| | 356| 3.02k| rdatalist = ISC_LIST_HEAD(msg->freerdatalist); ------------------ | | 62| 3.02k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 357| 3.02k| if (rdatalist != NULL) { ------------------ | Branch (357:6): [True: 0, False: 3.02k] ------------------ 358| 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] | | | | ------------------ | | ------------------ ------------------ 359| 0| dns_rdatalist_init(rdatalist); 360| 0| goto out; 361| 0| } 362| | 363| 3.02k| msgblock = ISC_LIST_TAIL(msg->rdatalists); ------------------ | | 63| 3.02k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 364| 3.02k| rdatalist = msgblock_get(msgblock, dns_rdatalist_t); ------------------ | | 190| 3.02k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 365| 3.02k| if (rdatalist == NULL) { ------------------ | Branch (365:6): [True: 1.68k, False: 1.33k] ------------------ 366| 1.68k| msgblock = msgblock_allocate(msg->mctx, sizeof(dns_rdatalist_t), 367| 1.68k| RDATALIST_COUNT); ------------------ | | 128| 1.68k|#define RDATALIST_COUNT 8 ------------------ 368| 1.68k| ISC_LIST_APPEND(msg->rdatalists, msgblock, link); ------------------ | | 100| 1.68k| do { \ | | 101| 1.68k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.68k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.68k| do { \ | | | | 89| 1.68k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.68k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.68k| } else { \ | | | | 92| 1.68k| (list).head = (elt); \ | | | | 93| 1.68k| } \ | | | | 94| 1.68k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.68k| (elt)->link.next = NULL; \ | | | | 96| 1.68k| (list).tail = (elt); \ | | | | 97| 1.68k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.68k] | | | | ------------------ | | ------------------ | | 103| 1.68k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.68k] | | ------------------ ------------------ 369| | 370| 1.68k| rdatalist = msgblock_get(msgblock, dns_rdatalist_t); ------------------ | | 190| 1.68k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 371| 1.68k| } 372| 3.02k|out: 373| 3.02k| dns_rdatalist_init(rdatalist); 374| 3.02k| return rdatalist; 375| 3.02k|} message.c:dns__message_putassociatedrdataset: 2482| 3.02k|dns__message_putassociatedrdataset(dns_message_t *msg, dns_rdataset_t **item) { 2483| 3.02k| dns_rdataset_disassociate(*item); ------------------ | | 301| 3.02k| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 2484| 3.02k| dns_message_puttemprdataset(msg, item); 2485| 3.02k|} message.c:msgresetopt: 471| 1.69k|msgresetopt(dns_message_t *msg) { 472| 1.69k| if (msg->opt != NULL) { ------------------ | Branch (472:6): [True: 0, False: 1.69k] ------------------ 473| 0| if (msg->opt_reserved > 0) { ------------------ | Branch (473:7): [True: 0, False: 0] ------------------ 474| 0| dns_message_renderrelease(msg, msg->opt_reserved); 475| 0| msg->opt_reserved = 0; 476| 0| } 477| 0| dns__message_putassociatedrdataset(msg, &msg->opt); 478| | msg->opt = NULL; 479| 0| msg->cc_ok = 0; 480| 0| msg->cc_bad = 0; 481| 0| } 482| 1.69k|} message.c:msgresetsigs: 485| 1.69k|msgresetsigs(dns_message_t *msg, bool replying) { 486| 1.69k| if (msg->sig_reserved > 0) { ------------------ | Branch (486:6): [True: 0, False: 1.69k] ------------------ 487| 0| dns_message_renderrelease(msg, msg->sig_reserved); 488| 0| msg->sig_reserved = 0; 489| 0| } 490| 1.69k| if (msg->tsig != NULL) { ------------------ | Branch (490:6): [True: 582, False: 1.11k] ------------------ 491| 582| INSIST(dns_rdataset_isassociated(msg->tsig)); ------------------ | | 202| 582|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 582| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 582, False: 0] | | | | ------------------ | | | | 55| 582| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 492| 582| INSIST(msg->namepool != NULL); ------------------ | | 202| 582|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 582| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 582, False: 0] | | | | ------------------ | | | | 55| 582| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 493| 582| if (replying) { ------------------ | Branch (493:7): [True: 0, False: 582] ------------------ 494| 0| INSIST(msg->querytsig == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 495| 0| msg->querytsig = msg->tsig; 496| 582| } else { 497| 582| dns__message_putassociatedrdataset(msg, &msg->tsig); 498| 582| if (msg->querytsig != NULL) { ------------------ | Branch (498:8): [True: 149, False: 433] ------------------ 499| 149| dns__message_putassociatedrdataset( 500| 149| msg, &msg->querytsig); 501| 149| } 502| 582| } 503| 582| dns_message_puttempname(msg, &msg->tsigname); 504| 582| msg->tsig = NULL; 505| 1.11k| } else if (msg->querytsig != NULL && !replying) { ------------------ | Branch (505:13): [True: 51, False: 1.05k] | Branch (505:39): [True: 51, False: 0] ------------------ 506| 51| dns__message_putassociatedrdataset(msg, &msg->querytsig); 507| 51| msg->querytsig = NULL; 508| 51| } 509| 1.69k| if (msg->sig0 != NULL) { ------------------ | Branch (509:6): [True: 462, False: 1.23k] ------------------ 510| 462| dns__message_putassociatedrdataset(msg, &msg->sig0); 511| 462| msg->sig0 = NULL; 512| 462| } 513| 1.69k| if (msg->sig0name != NULL) { ------------------ | Branch (513:6): [True: 462, False: 1.23k] ------------------ 514| 462| dns_message_puttempname(msg, &msg->sig0name); 515| 462| } 516| 1.69k|} message.c:msginitprivate: 387| 1.69k|msginitprivate(dns_message_t *m) { 388| 1.69k| unsigned int i; 389| | 390| 8.46k| for (i = 0; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (390:14): [True: 6.76k, False: 1.69k] ------------------ 391| 6.76k| m->cursors[i] = NULL; 392| 6.76k| m->counts[i] = 0; 393| 6.76k| } 394| 1.69k| m->opt = NULL; 395| 1.69k| m->sig0 = NULL; 396| 1.69k| m->sig0name = NULL; 397| 1.69k| m->tsig = NULL; 398| 1.69k| m->tsigname = NULL; 399| 1.69k| m->state = DNS_SECTION_ANY; /* indicate nothing parsed or rendered */ 400| 1.69k| m->opt_reserved = 0; 401| 1.69k| m->sig_reserved = 0; 402| 1.69k| m->reserved = 0; 403| 1.69k| m->padding = 0; 404| 1.69k| m->padding_off = 0; 405| | m->buffer = NULL; 406| 1.69k|} message.c:msgresetedns: 519| 1.69k|msgresetedns(dns_message_t *msg) { 520| 1.69k| if (msg->edns.opts != NULL) { ------------------ | Branch (520:6): [True: 0, False: 1.69k] ------------------ 521| 0| INSIST(msg->edns.maxopts != 0); ------------------ | | 202| 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))) | | ------------------ ------------------ 522| 0| for (size_t i = 0; i < msg->edns.count; i++) { ------------------ | Branch (522:22): [True: 0, False: 0] ------------------ 523| 0| if (msg->edns.opts[i].value != NULL) { ------------------ | Branch (523:8): [True: 0, False: 0] ------------------ 524| 0| isc_mem_put(msg->mctx, msg->edns.opts[i].value, ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 525| 0| msg->edns.opts[i].length); 526| 0| } 527| 0| } 528| | isc_mem_cput(msg->mctx, msg->edns.opts, ------------------ | | 176| 0| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 0| (p) = NULL; \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:11): [Folded, False: 0] | | ------------------ ------------------ 529| 0| (size_t)msg->edns.maxopts, sizeof(dns_ednsopt_t)); 530| 0| } 531| 1.69k| msg->edns.maxopts = 0; 532| 1.69k| msg->edns.count = 0; 533| 1.69k|} dns_name_hasbuffer: 119| 200|dns_name_hasbuffer(const dns_name_t *name) { 120| | /* 121| | * Does 'name' have a dedicated buffer? 122| | */ 123| | 124| 200| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 125| | 126| 200| if (name->buffer != NULL) { ------------------ | Branch (126:6): [True: 200, False: 0] ------------------ 127| 200| return true; 128| 200| } 129| | 130| 0| return false; 131| 200|} dns_name_isabsolute: 134| 105|dns_name_isabsolute(const dns_name_t *name) { 135| | /* 136| | * Does 'name' end in the root label? 137| | */ 138| | 139| 105| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 105|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 210| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 105, False: 0] | | | | | Branch (42:11): [True: 105, False: 0] | | | | ------------------ | | | | 43| 105| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 140| | 141| 105| return name->attributes.absolute; 142| 105|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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| 711|dns_name_hash(const dns_name_t *name) { 315| 711| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 711|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.42k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 711, False: 0] | | | | | Branch (42:11): [True: 711, False: 0] | | | | ------------------ | | | | 43| 711| ((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| 711|} 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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| 5.31k|dns_name_equal(const dns_name_t *name1, const dns_name_t *name2) { 438| 5.31k| 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| 5.31k| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 198| 5.31k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.6k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.31k, False: 0] | | | | | Branch (42:11): [True: 5.31k, False: 0] | | | | ------------------ | | | | 43| 5.31k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 450| 5.31k| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 198| 5.31k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.6k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.31k, False: 0] | | | | | Branch (42:11): [True: 5.31k, False: 0] | | | | ------------------ | | | | 43| 5.31k| ((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| 5.31k| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 198| 5.31k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.31k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.31k, False: 0] | | | | ------------------ | | | | 43| 5.31k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 455| | 456| 5.31k| if (name1 == name2) { ------------------ | Branch (456:6): [True: 0, False: 5.31k] ------------------ 457| 0| return true; 458| 0| } 459| | 460| 5.31k| length = name1->length; 461| 5.31k| if (length != name2->length) { ------------------ | Branch (461:6): [True: 3.89k, False: 1.41k] ------------------ 462| 3.89k| return false; 463| 3.89k| } 464| | 465| | /* label lengths are < 64 so tolower() does not affect them */ 466| 1.41k| return isc_ascii_lowerequal(name1->ndata, name2->ndata, length); 467| 5.31k|} 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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.62k|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.62k| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 1.62k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.62k, False: 0] | | | | | Branch (42:11): [True: 1.62k, False: 0] | | | | ------------------ | | | | 43| 1.62k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 645| 1.62k| REQUIRE(DNS_NAME_VALID(target)); ------------------ | | 198| 1.62k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.62k, False: 0] | | | | | Branch (42:11): [True: 1.62k, False: 0] | | | | ------------------ | | | | 43| 1.62k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 646| 1.62k| REQUIRE(DNS_NAME_BINDABLE(target)); ------------------ | | 198| 1.62k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.62k, False: 0] | | | | | Branch (42:11): [True: 1.62k, False: 0] | | | | ------------------ | | | | 43| 1.62k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 647| | 648| 1.62k| target->ndata = source->ndata; 649| 1.62k| target->length = source->length; 650| 1.62k| target->attributes = source->attributes; 651| 1.62k| target->attributes.readonly = false; 652| | target->attributes.dynamic = false; 653| 1.62k|} dns_name_fromregion: 656| 1.27k|dns_name_fromregion(dns_name_t *name, const isc_region_t *r) { 657| 1.27k| size_t length; 658| 1.27k| isc_region_t r2 = { .base = NULL, .length = 0 }; 659| | 660| | /* 661| | * Make 'name' refer to region 'r'. 662| | */ 663| | 664| 1.27k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.55k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 665| 1.27k| REQUIRE(r != NULL); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 666| 1.27k| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.55k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 667| | 668| 1.27k| name->ndata = r->base; 669| 1.27k| if (name->buffer != NULL) { ------------------ | Branch (669:6): [True: 4, False: 1.27k] ------------------ 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.27k| } else { 677| 1.27k| length = (r->length <= DNS_NAME_MAXWIRE) ? r->length ------------------ | | 190| 1.27k|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (677:12): [True: 955, False: 319] ------------------ 678| 1.27k| : DNS_NAME_MAXWIRE; ------------------ | | 190| 1.59k|#define DNS_NAME_MAXWIRE 255 ------------------ 679| 1.27k| } 680| | 681| 1.27k| name->attributes.absolute = false; 682| | 683| 1.27k| if (length > 0) { ------------------ | Branch (683:6): [True: 1.27k, False: 0] ------------------ 684| 1.27k| size_t offset = 0; 685| 1.27k| uint8_t nlabels = 0; 686| 14.1k| while (offset != length) { ------------------ | Branch (686:10): [True: 14.1k, False: 0] ------------------ 687| 14.1k| uint8_t count; 688| | 689| 14.1k| INSIST(nlabels < DNS_NAME_MAXLABELS); ------------------ | | 202| 14.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 14.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 14.1k, False: 0] | | | | ------------------ | | | | 55| 14.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 690| 14.1k| nlabels++; 691| | 692| 14.1k| count = name->ndata[offset]; 693| 14.1k| INSIST(count <= DNS_NAME_LABELLEN); ------------------ | | 202| 14.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 14.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 14.1k, False: 0] | | | | ------------------ | | | | 55| 14.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 694| | 695| 14.1k| offset += count + 1; 696| 14.1k| INSIST(offset <= length); ------------------ | | 202| 14.1k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 14.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 14.1k, False: 0] | | | | ------------------ | | | | 55| 14.1k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 697| | 698| 14.1k| if (count == 0) { ------------------ | Branch (698:8): [True: 1.27k, False: 12.8k] ------------------ 699| 1.27k| name->attributes.absolute = true; 700| 1.27k| break; 701| 1.27k| } 702| 14.1k| } 703| 1.27k| name->length = offset; 704| 1.27k| } 705| | 706| 1.27k| if (name->buffer != NULL) { ------------------ | Branch (706:6): [True: 4, False: 1.27k] ------------------ 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.27k|} dns_name_fromtext: 966| 16| const dns_name_t *origin, unsigned int options) { 967| 16| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 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)); ------------------ | | 198| 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 minimal = ((options & DNS_NAME_QUOTED) != 0); ------------------ | | 885| 10|#define DNS_NAME_QUOTED 0x04U /* minimal escaping within double quotes */ ------------------ 985| 10| bool principal = ((options & DNS_NAME_PRINCIPAL) != 0); ------------------ | | 884| 10|#define DNS_NAME_PRINCIPAL 0x02U /* do not escape $ and @ */ ------------------ 986| 10| bool first = true; 987| | 988| | /* 989| | * This function assumes the name is in proper uncompressed 990| | * wire format. 991| | */ 992| 10| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 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))) | | ------------------ ------------------ 993| 10| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 198| 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))) | | ------------------ ------------------ 994| | 995| 10| oused = target->used; 996| | 997| 10| ndata = name->ndata; 998| 10| nlen = name->length; 999| 10| labels = dns_name_countlabels(name); 1000| | 1001| 10| if (labels == 0 && nlen == 0) { ------------------ | Branch (1001:6): [True: 0, False: 10] | Branch (1001:21): [True: 0, False: 0] ------------------ 1002| | /* 1003| | * Special handling for an empty name. 1004| | */ 1005| 0| omit_final_dot = true; 1006| 0| CHECK(isc_buffer_reserve(target, 1)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 1007| 0| isc_buffer_putuint8(target, '@'); 1008| | 1009| | /* 1010| | * Skip the while() loop. 1011| | */ 1012| 0| nlen = 0; 1013| 10| } else if (nlen == 1 && labels == 1 && *ndata == '\0') { ------------------ | Branch (1013:13): [True: 0, False: 10] | Branch (1013:26): [True: 0, False: 0] | Branch (1013:41): [True: 0, False: 0] ------------------ 1014| | /* 1015| | * Special handling for the root label. 1016| | */ 1017| 0| saw_root = true; 1018| 0| omit_final_dot = false; 1019| | 1020| | /* 1021| | * Skip the while() loop. 1022| | */ 1023| 0| nlen = 0; 1024| 0| } 1025| | 1026| 20| while (labels > 0 && nlen > 0) { ------------------ | Branch (1026:9): [True: 20, False: 0] | Branch (1026:23): [True: 20, False: 0] ------------------ 1027| 20| unsigned int count = *ndata++; 1028| 20| labels--; 1029| 20| nlen--; 1030| 20| if (count == 0) { ------------------ | Branch (1030:7): [True: 10, False: 10] ------------------ 1031| 10| saw_root = true; 1032| 10| break; 1033| 10| } else if (!first) { ------------------ | Branch (1033:14): [True: 0, False: 10] ------------------ 1034| 0| CHECK(isc_buffer_reserve(target, 1)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 1035| 0| isc_buffer_putuint8(target, '.'); 1036| 0| } 1037| 10| first = false; 1038| | 1039| 10| if (count <= DNS_NAME_LABELLEN) { ------------------ | | 192| 10|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (1039:7): [True: 10, False: 0] ------------------ 1040| 10| unsigned char c; 1041| | 1042| 10| INSIST(nlen >= count); ------------------ | | 202| 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))) | | ------------------ ------------------ 1043| | 1044| 80| while (count > 0) { ------------------ | Branch (1044:11): [True: 70, False: 10] ------------------ 1045| 70| uint32_t value; 1046| | 1047| 70| c = *ndata; 1048| 70| switch (c) { 1049| | /* Special modifiers in zone files. */ 1050| 0| case 0x40: /* '@' */ ------------------ | Branch (1050:5): [True: 0, False: 70] ------------------ 1051| 0| case 0x24: /* '$' */ ------------------ | Branch (1051:5): [True: 0, False: 70] ------------------ 1052| 0| if (principal) { ------------------ | Branch (1052:10): [True: 0, False: 0] ------------------ 1053| 0| goto no_escape; 1054| 0| } 1055| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 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 0x3B: /* ';' */ ------------------ | Branch (1058:5): [True: 0, False: 70] ------------------ 1059| 0| if (minimal) { ------------------ | Branch (1059:10): [True: 0, False: 0] ------------------ 1060| 0| goto no_escape; 1061| 0| } 1062| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 1063| 0| case 0x22: /* '"' */ ------------------ | Branch (1063:5): [True: 0, False: 70] ------------------ 1064| 0| case 0x2E: /* '.' */ ------------------ | Branch (1064:5): [True: 0, False: 70] ------------------ 1065| 0| case 0x5C: /* '\\' */ ------------------ | Branch (1065:5): [True: 0, False: 70] ------------------ 1066| 0| value = '\\' << 8 | c; 1067| 0| CHECK(isc_buffer_reserve(target, 2)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 1068| 0| isc_buffer_putuint16(target, value); 1069| 0| ndata++; 1070| 0| nlen--; 1071| 0| break; 1072| 0| no_escape: 1073| 70| default: ------------------ | Branch (1073:5): [True: 70, False: 0] ------------------ 1074| 70| if ((c > 0x20 && c < 0x7f) || ------------------ | Branch (1074:11): [True: 70, False: 0] | Branch (1074:23): [True: 70, False: 0] ------------------ 1075| 0| (c == 0x20 && minimal)) ------------------ | Branch (1075:11): [True: 0, False: 0] | Branch (1075:24): [True: 0, False: 0] ------------------ 1076| 70| { 1077| 70| CHECK(isc_buffer_reserve(target, ------------------ | | 255| 70| { \ | | 256| 70| result = (r); \ | | 257| 70| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 70] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 70| } ------------------ 1078| 70| 1)); 1079| 70| isc_buffer_putuint8(target, c); 1080| 70| ndata++; 1081| 70| nlen--; 1082| 70| } else { 1083| 0| value = 0x5c << 24; 1084| 0| value |= (0x30 + 1085| 0| ((c / 100) % 10)) 1086| 0| << 16; 1087| 0| value |= 1088| 0| (0x30 + ((c / 10) % 10)) 1089| 0| << 8; 1090| 0| value |= 0x30 + (c % 10); 1091| 0| CHECK(isc_buffer_reserve(target, ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 1092| 0| 4)); 1093| 0| isc_buffer_putuint32(target, 1094| 0| value); 1095| 0| ndata++; 1096| 0| nlen--; 1097| 0| } 1098| 70| } 1099| 70| count--; 1100| 70| } 1101| 10| } else { 1102| 0| FATAL_ERROR("Unexpected label type %02x", count); ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1103| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1104| 0| } 1105| 10| } 1106| | 1107| 10| if (saw_root && !omit_final_dot) { ------------------ | Branch (1107:6): [True: 10, False: 0] | Branch (1107:18): [True: 0, False: 10] ------------------ 1108| 0| CHECK(isc_buffer_reserve(target, 1)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 1109| 0| isc_buffer_putuint8(target, '.'); 1110| 0| } 1111| | 1112| 10| if (isc_buffer_availablelength(target) > 1) { ------------------ | | 161| 10|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1112:6): [True: 10, False: 0] ------------------ 1113| 10| uint8_t *p = isc_buffer_used(target); ------------------ | | 149| 10| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1114| 10| *p = 0; 1115| 10| } 1116| | 1117| 10| if (totext_filter_proc != NULL) { ------------------ | Branch (1117:6): [True: 0, False: 10] ------------------ 1118| 0| return (totext_filter_proc)(target, oused); 1119| 0| } 1120| | 1121| 10| return ISC_R_SUCCESS; 1122| | 1123| 0|cleanup: 1124| 0| return result; 1125| 10|} dns_name_downcase: 1243| 369|dns_name_downcase(const dns_name_t *source, dns_name_t *name) { 1244| | /* 1245| | * Downcase 'source'. 1246| | */ 1247| | 1248| 369| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 369|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 738| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 369, False: 0] | | | | | Branch (42:11): [True: 369, False: 0] | | | | ------------------ | | | | 43| 369| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1249| 369| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 369|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 738| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 369, False: 0] | | | | | Branch (42:11): [True: 369, False: 0] | | | | ------------------ | | | | 43| 369| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1250| | 1251| 369| if (source == name) { ------------------ | Branch (1251:6): [True: 367, False: 2] ------------------ 1252| 367| REQUIRE(!name->attributes.readonly); ------------------ | | 198| 367|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 367| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 367, False: 0] | | | | ------------------ | | | | 43| 367| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1253| 367| isc_ascii_lowercopy(name->ndata, source->ndata, source->length); 1254| 367| return ISC_R_SUCCESS; 1255| 367| } 1256| | 1257| 2| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1258| 2| REQUIRE(ISC_BUFFER_VALID(name->buffer)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1259| | 1260| 2| isc_buffer_clear(name->buffer); 1261| 2| name->ndata = (uint8_t *)name->buffer->base + name->buffer->used; 1262| | 1263| | /* label lengths are < 64 so tolower() does not affect them */ 1264| 2| isc_ascii_lowercopy(name->ndata, source->ndata, source->length); 1265| | 1266| 2| name->length = source->length; 1267| 2| name->attributes = (struct dns_name_attrs){ 1268| 2| .absolute = source->attributes.absolute 1269| 2| }; 1270| 2| isc_buffer_add(name->buffer, name->length); 1271| | 1272| 2| return ISC_R_SUCCESS; 1273| 369|} dns_name_fromwire: 1277| 5.56k| const dns_decompress_t dctx, isc_buffer_t *target) { 1278| | /* 1279| | * Copy the name at source into target, decompressing it. 1280| | * 1281| | * *** WARNING *** 1282| | * 1283| | * dns_name_fromwire() deals with raw network data. An error in this 1284| | * routine could result in the failure or hijacking of the server. 1285| | * 1286| | * The description of name compression in RFC 1035 section 4.1.4 is 1287| | * subtle wrt certain edge cases. The first important sentence is: 1288| | * 1289| | * > In this scheme, an entire domain name or a list of labels at the 1290| | * > end of a domain name is replaced with a pointer to a prior 1291| | * > occurrence of the same name. 1292| | * 1293| | * The key word is "prior". This says that compression pointers must 1294| | * point strictly earlier in the message (before our "marker" variable), 1295| | * which is enough to prevent DoS attacks due to compression loops. 1296| | * 1297| | * The next important sentence is: 1298| | * 1299| | * > If a domain name is contained in a part of the message subject to a 1300| | * > length field (such as the RDATA section of an RR), and compression 1301| | * > is used, the length of the compressed name is used in the length 1302| | * > calculation, rather than the length of the expanded name. 1303| | * 1304| | * When decompressing, this means that the amount of the source buffer 1305| | * that we consumed (which is checked wrt the container's length field) 1306| | * is the length of the compressed name. A compressed name is defined as 1307| | * a sequence of labels ending with the root label or a compression 1308| | * pointer, that is, the segment of the name that dns_name_fromwire() 1309| | * examines first. 1310| | * 1311| | * This matters when handling names that play dirty tricks, like: 1312| | * 1313| | * +---+---+---+---+---+---+ 1314| | * | 4 | 1 |'a'|192| 0 | 0 | 1315| | * +---+---+---+---+---+---+ 1316| | * 1317| | * We start at octet 1. There is an ordinary single character label "a", 1318| | * followed by a compression pointer that refers back to octet zero. 1319| | * Here there is a label of length 4, which weirdly re-uses the octets 1320| | * we already examined as the data for the label. It is followed by the 1321| | * root label, 1322| | * 1323| | * The specification says that the compressed name ends after the first 1324| | * zero octet (after the compression pointer) not the second zero octet, 1325| | * even though the second octet is later in the message. This shows the 1326| | * correct way to set our "consumed" variable. 1327| | */ 1328| | 1329| 5.56k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 5.56k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 11.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.56k, False: 0] | | | | | Branch (42:11): [True: 5.56k, False: 0] | | | | ------------------ | | | | 43| 5.56k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1330| 5.56k| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 198| 5.56k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 11.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.56k, False: 0] | | | | | Branch (42:11): [True: 5.56k, False: 0] | | | | ------------------ | | | | 43| 5.56k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1331| 5.56k| REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) || ------------------ | | 198| 5.56k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 28.2k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.37k, False: 0] | | | | | Branch (42:11): [True: 5.37k, False: 0] | | | | | Branch (42:11): [True: 5.37k, False: 197] | | | | | Branch (42:11): [True: 197, False: 0] | | | | | Branch (42:11): [True: 197, False: 0] | | | | | Branch (42:11): [True: 197, False: 0] | | | | ------------------ | | | | 43| 5.56k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1332| 5.56k| (target == NULL && ISC_BUFFER_VALID(name->buffer))); 1333| | 1334| 5.56k| if (target == NULL && name->buffer != NULL) { ------------------ | Branch (1334:6): [True: 197, False: 5.37k] | Branch (1334:24): [True: 197, False: 0] ------------------ 1335| 197| target = name->buffer; 1336| 197| isc_buffer_clear(target); 1337| 197| } 1338| | 1339| 5.56k| uint8_t *const name_buf = isc_buffer_used(target); ------------------ | | 149| 5.56k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1340| 5.56k| const uint32_t name_max = ISC_MIN(DNS_NAME_MAXWIRE, ------------------ | | 77| 5.56k|#define ISC_MIN(a, b) ((a) < (b) ? (a) : (b)) | | ------------------ | | | Branch (77:24): [True: 5.37k, False: 197] | | ------------------ ------------------ 1341| 5.56k| isc_buffer_availablelength(target)); 1342| 5.56k| uint32_t name_len = 0; 1343| | 1344| | /* 1345| | * After chasing a compression pointer, these variables refer to the 1346| | * source buffer as follows: 1347| | * 1348| | * sb --- mr --- cr --- st --- cd --- sm 1349| | * 1350| | * sb = source_buf (const) 1351| | * mr = marker 1352| | * cr = cursor 1353| | * st = start (const) 1354| | * cd = consumed 1355| | * sm = source_max (const) 1356| | * 1357| | * The marker hops backwards for each pointer. 1358| | * The cursor steps forwards for each label. 1359| | * The amount of the source we consumed is set once. 1360| | */ 1361| 5.56k| const uint8_t *const source_buf = isc_buffer_base(source); ------------------ | | 143| 5.56k|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 1362| 5.56k| const uint8_t *const source_max = isc_buffer_active(source); ------------------ | | 147| 5.56k| ((void *)((unsigned char *)(b)->base + (b)->active)) /*c*/ ------------------ 1363| 5.56k| const uint8_t *const start = isc_buffer_current(source); ------------------ | | 145| 5.56k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1364| 5.56k| const uint8_t *marker = start; 1365| 5.56k| const uint8_t *cursor = start; 1366| 5.56k| const uint8_t *consumed = NULL; 1367| | 1368| | /* 1369| | * One iteration per label. 1370| | */ 1371| 48.4k| while (cursor < source_max) { ------------------ | Branch (1371:9): [True: 48.4k, False: 29] ------------------ 1372| 48.4k| const uint8_t label_len = *cursor++; 1373| 48.4k| if (label_len <= DNS_NAME_LABELLEN) { ------------------ | | 192| 48.4k|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (1373:7): [True: 47.4k, False: 931] ------------------ 1374| | /* 1375| | * Normal label: record its offset, and check bounds on 1376| | * the name length, which also ensures we don't overrun 1377| | * the offsets array. Don't touch any source bytes yet! 1378| | * The source bounds check will happen when we loop. 1379| | */ 1380| | /* and then a step to the ri-i-i-i-i-ight */ 1381| 47.4k| cursor += label_len; 1382| 47.4k| name_len += label_len + 1; 1383| 47.4k| if (name_len > name_max) { ------------------ | Branch (1383:8): [True: 10, False: 47.4k] ------------------ 1384| 10| return name_max == DNS_NAME_MAXWIRE ------------------ | | 190| 10|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (1384:12): [True: 10, False: 0] ------------------ 1385| 10| ? DNS_R_NAMETOOLONG 1386| 10| : ISC_R_NOSPACE; 1387| 47.4k| } else if (label_len == 0) { ------------------ | Branch (1387:15): [True: 5.49k, False: 41.9k] ------------------ 1388| 5.49k| goto root_label; 1389| 5.49k| } 1390| 47.4k| } else if (label_len < 192) { ------------------ | Branch (1390:14): [True: 22, False: 909] ------------------ 1391| 22| return DNS_R_BADLABELTYPE; 1392| 909| } else if (!dns_decompress_getpermitted(dctx)) { ------------------ | Branch (1392:14): [True: 2, False: 907] ------------------ 1393| 2| return DNS_R_DISALLOWED; 1394| 907| } else if (cursor < source_max) { ------------------ | Branch (1394:14): [True: 903, False: 4] ------------------ 1395| | /* 1396| | * Compression pointer. Ensure it does not loop. 1397| | * 1398| | * Copy multiple labels in one go, to make the most of 1399| | * memmove() performance. Start at the marker and finish 1400| | * just before the pointer's hi+lo bytes, before the 1401| | * cursor. Bounds were already checked. 1402| | */ 1403| 903| const uint32_t hi = label_len & 0x3F; 1404| 903| const uint32_t lo = *cursor++; 1405| 903| const uint8_t *pointer = source_buf + (256 * hi + lo); 1406| 903| if (pointer >= marker) { ------------------ | Branch (1406:8): [True: 14, False: 889] ------------------ 1407| 14| return DNS_R_BADPOINTER; 1408| 14| } 1409| 889| const uint32_t copy_len = (cursor - 2) - marker; 1410| 889| uint8_t *const dest = name_buf + name_len - copy_len; 1411| 889| memmove(dest, marker, copy_len); 1412| 889| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1412:15): [True: 183, False: 706] ------------------ 1413| | /* it's just a jump to the left */ 1414| 889| cursor = marker = pointer; 1415| 889| } 1416| 48.4k| } 1417| 29| return ISC_R_UNEXPECTEDEND; 1418| 5.49k|root_label:; 1419| | /* 1420| | * Copy labels almost like we do for compression pointers, 1421| | * from the marker up to and including the root label. 1422| | */ 1423| 5.49k| const uint32_t copy_len = cursor - marker; 1424| 5.49k| memmove(name_buf + name_len - copy_len, marker, copy_len); 1425| 5.49k| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1425:13): [True: 684, False: 4.80k] ------------------ 1426| 5.49k| isc_buffer_forward(source, consumed - start); 1427| | 1428| 5.49k| name->attributes.absolute = true; 1429| 5.49k| name->ndata = name_buf; 1430| 5.49k| name->length = name_len; 1431| 5.49k| isc_buffer_add(target, name_len); 1432| | 1433| 5.49k| return ISC_R_SUCCESS; 1434| 5.56k|} dns_name_towire: 1438| 6| isc_buffer_t *target) { 1439| 6| bool compress, multi; 1440| 6| unsigned int here; 1441| 6| unsigned int prefix_length; 1442| 6| unsigned int suffix_coff; 1443| | 1444| | /* 1445| | * Convert 'name' into wire format, compressing it as specified by the 1446| | * compression context 'cctx' (or without compressing if 'cctx' 1447| | * is NULL), and storing the result in 'target'. 1448| | */ 1449| | 1450| 6| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1451| 6| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1452| | 1453| 6| if (cctx == NULL) { ------------------ | Branch (1453:6): [True: 6, False: 0] ------------------ 1454| 6| if (isc_buffer_availablelength(target) < name->length) { ------------------ | | 161| 6|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1454:7): [True: 0, False: 6] ------------------ 1455| 0| return ISC_R_NOSPACE; 1456| 0| } 1457| 6| memmove(isc_buffer_used(target), name->ndata, name->length); ------------------ | | 149| 6| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1458| 6| isc_buffer_add(target, name->length); 1459| 6| return ISC_R_SUCCESS; 1460| 6| } 1461| | 1462| 0| compress = !name->attributes.nocompress && ------------------ | Branch (1462:13): [True: 0, False: 0] ------------------ 1463| 0| dns_compress_getpermitted(cctx); ------------------ | Branch (1463:6): [True: 0, False: 0] ------------------ 1464| 0| multi = compress && dns_compress_getmultiuse(cctx); ------------------ | Branch (1464:10): [True: 0, False: 0] | Branch (1464:22): [True: 0, False: 0] ------------------ 1465| | 1466| | /* 1467| | * Write a compression pointer directly if the caller passed us 1468| | * a pointer to this name's offset that we saved previously. 1469| | */ 1470| 0| if (multi && cctx->coff < 0x4000) { ------------------ | Branch (1470:6): [True: 0, False: 0] | Branch (1470:15): [True: 0, False: 0] ------------------ 1471| 0| if (isc_buffer_availablelength(target) < 2) { ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1471:7): [True: 0, False: 0] ------------------ 1472| 0| return ISC_R_NOSPACE; 1473| 0| } 1474| 0| isc_buffer_putuint16(target, cctx->coff | 0xc000); 1475| 0| return ISC_R_SUCCESS; 1476| 0| } 1477| | 1478| | /* 1479| | * Always add the name to the compression context; if compression 1480| | * is off, reset the return values before writing the name. 1481| | */ 1482| 0| prefix_length = name->length; 1483| 0| suffix_coff = 0; 1484| 0| dns_compress_name(cctx, target, name, &prefix_length, &suffix_coff); 1485| 0| if (!compress) { ------------------ | Branch (1485:6): [True: 0, False: 0] ------------------ 1486| 0| prefix_length = name->length; 1487| 0| suffix_coff = 0; 1488| 0| } 1489| | 1490| | /* 1491| | * Return this name's compression offset for use next time, provided 1492| | * it isn't too short for compression to help (i.e. it's the root) 1493| | */ 1494| 0| here = isc_buffer_usedlength(target); ------------------ | | 157| 0|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1495| 0| if (multi && here < 0x4000 && prefix_length > 1) { ------------------ | Branch (1495:6): [True: 0, False: 0] | Branch (1495:15): [True: 0, False: 0] | Branch (1495:32): [True: 0, False: 0] ------------------ 1496| 0| cctx->coff = (uint16_t)here; 1497| 0| } 1498| | 1499| 0| if (prefix_length > 0) { ------------------ | Branch (1499:6): [True: 0, False: 0] ------------------ 1500| 0| if (isc_buffer_availablelength(target) < prefix_length) { ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1500:7): [True: 0, False: 0] ------------------ 1501| 0| return ISC_R_NOSPACE; 1502| 0| } 1503| 0| memmove(isc_buffer_used(target), name->ndata, prefix_length); ------------------ | | 149| 0| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1504| 0| isc_buffer_add(target, prefix_length); 1505| 0| } 1506| | 1507| 0| if (suffix_coff > 0) { ------------------ | Branch (1507:6): [True: 0, False: 0] ------------------ 1508| 0| if (multi && prefix_length == 0) { ------------------ | Branch (1508:7): [True: 0, False: 0] | Branch (1508:16): [True: 0, False: 0] ------------------ 1509| 0| cctx->coff = suffix_coff; 1510| 0| } 1511| 0| if (isc_buffer_availablelength(target) < 2) { ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1511:7): [True: 0, False: 0] ------------------ 1512| 0| return ISC_R_NOSPACE; 1513| 0| } 1514| 0| isc_buffer_putuint16(target, suffix_coff | 0xc000); 1515| 0| } 1516| | 1517| 0| return ISC_R_SUCCESS; 1518| 0|} dns_name_dup: 1607| 105|dns_name_dup(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) { 1608| | /* 1609| | * Make 'target' a dynamically allocated copy of 'source'. 1610| | */ 1611| | 1612| 105| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 105|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 210| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 105, False: 0] | | | | | Branch (42:11): [True: 105, False: 0] | | | | ------------------ | | | | 43| 105| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1613| 105| REQUIRE(source->length > 0); ------------------ | | 198| 105|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 105| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 105, False: 0] | | | | ------------------ | | | | 43| 105| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1614| 105| REQUIRE(DNS_NAME_VALID(target)); ------------------ | | 198| 105|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 210| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 105, False: 0] | | | | | Branch (42:11): [True: 105, False: 0] | | | | ------------------ | | | | 43| 105| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1615| 105| REQUIRE(DNS_NAME_BINDABLE(target)); ------------------ | | 198| 105|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 210| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 105, False: 0] | | | | | Branch (42:11): [True: 105, False: 0] | | | | ------------------ | | | | 43| 105| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1616| | 1617| 105| target->ndata = isc_mem_get(mctx, source->length); ------------------ | | 144| 105|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1618| | 1619| 105| memmove(target->ndata, source->ndata, source->length); 1620| | 1621| 105| target->length = source->length; 1622| | target->attributes = (struct dns_name_attrs){ .dynamic = true }; 1623| 105| target->attributes.absolute = source->attributes.absolute; 1624| 105|} dns_name_free: 1627| 91|dns_name_free(dns_name_t *name, isc_mem_t *mctx) { 1628| 91| size_t size; 1629| | 1630| | /* 1631| | * Free 'name'. 1632| | */ 1633| | 1634| 91| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 91, False: 0] | | | | | Branch (42:11): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1635| 91| REQUIRE(name->attributes.dynamic); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1636| | 1637| 91| size = name->length; 1638| | isc_mem_put(mctx, name->ndata, size); ------------------ | | 171| 91| do { \ | | 172| 91| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 91| (p) = NULL; \ | | 174| 91| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 91] | | ------------------ ------------------ 1639| 91| dns_name_invalidate(name); 1640| 91|} dns_name_dynamic: 1677| 3.36k|dns_name_dynamic(const dns_name_t *name) { 1678| 3.36k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 3.36k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.73k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.36k, False: 0] | | | | | Branch (42:11): [True: 3.36k, False: 0] | | | | ------------------ | | | | 43| 3.36k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1679| | 1680| | /* 1681| | * Returns whether there is dynamic memory associated with this name. 1682| | */ 1683| | 1684| 3.36k| return name->attributes.dynamic; 1685| 3.36k|} dns_name_fromstring: 1774| 4| isc_mem_t *mctx) { 1775| 4| isc_buffer_t buf; 1776| 4| dns_fixedname_t fn; 1777| 4| dns_name_t *name; 1778| | 1779| 4| REQUIRE(src != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1780| | 1781| 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] | | ------------------ ------------------ 1782| 4| isc_buffer_add(&buf, strlen(src)); 1783| 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 (1783:35): [True: 4, False: 0] ------------------ 1784| 4| name = target; 1785| 4| } else { 1786| 0| name = dns_fixedname_initname(&fn); 1787| 0| } 1788| | 1789| 4| RETERR(dns_name_fromtext(name, &buf, origin, options)); ------------------ | | 276| 4| { \ | | 277| 4| isc_result_t _r = (x); \ | | 278| 4| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 4] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 4| } ------------------ 1790| | 1791| 4| if (name != target) { ------------------ | Branch (1791:6): [True: 0, False: 4] ------------------ 1792| 0| dns_name_dup(name, mctx, target); 1793| 0| } 1794| | 1795| 4| return ISC_R_SUCCESS; 1796| 4|} dns_name_copy: 1799| 567|dns_name_copy(const dns_name_t *source, dns_name_t *dest) { 1800| 567| isc_buffer_t *target = NULL; 1801| 567| unsigned char *ndata = NULL; 1802| | 1803| 567| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 567|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.13k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 567, False: 0] | | | | | Branch (42:11): [True: 567, False: 0] | | | | ------------------ | | | | 43| 567| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1804| 567| REQUIRE(DNS_NAME_VALID(dest)); ------------------ | | 198| 567|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.13k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 567, False: 0] | | | | | Branch (42:11): [True: 567, False: 0] | | | | ------------------ | | | | 43| 567| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1805| 567| REQUIRE(DNS_NAME_BINDABLE(dest)); ------------------ | | 198| 567|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.13k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 567, False: 0] | | | | | Branch (42:11): [True: 567, False: 0] | | | | ------------------ | | | | 43| 567| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1806| | 1807| 567| target = dest->buffer; 1808| | 1809| 567| REQUIRE(target != NULL); ------------------ | | 198| 567|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 567| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 567, False: 0] | | | | ------------------ | | | | 43| 567| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1810| 567| REQUIRE(target->length >= source->length); ------------------ | | 198| 567|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 567| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 567, False: 0] | | | | ------------------ | | | | 43| 567| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1811| | 1812| 567| isc_buffer_clear(target); 1813| | 1814| 567| ndata = (unsigned char *)target->base; 1815| 567| dest->ndata = target->base; 1816| | 1817| 567| if (source->length != 0) { ------------------ | Branch (1817:6): [True: 567, False: 0] ------------------ 1818| 567| memmove(ndata, source->ndata, source->length); 1819| 567| } 1820| | 1821| 567| dest->ndata = ndata; 1822| 567| dest->length = source->length; 1823| 567| dest->attributes.absolute = source->attributes.absolute; 1824| | 1825| 567| isc_buffer_add(target, dest->length); 1826| 567|} dns_name_offsets: 2098| 1.52k|dns_name_offsets(const dns_name_t *name, dns_offsets_t offsets) { 2099| 1.52k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 1.52k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.05k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.52k, False: 0] | | | | | Branch (42:11): [True: 1.52k, False: 0] | | | | ------------------ | | | | 43| 1.52k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2100| 1.52k| unsigned int offset, count, length, nlabels; 2101| 1.52k| unsigned char *ndata; 2102| | 2103| 1.52k| ndata = name->ndata; 2104| 1.52k| length = name->length; 2105| 1.52k| offset = 0; 2106| 1.52k| nlabels = 0; 2107| 18.4k| while (offset != length) { ------------------ | Branch (2107:9): [True: 18.4k, False: 0] ------------------ 2108| 18.4k| INSIST(nlabels < DNS_NAME_MAXLABELS); ------------------ | | 202| 18.4k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 18.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 18.4k, False: 0] | | | | ------------------ | | | | 55| 18.4k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2109| 18.4k| if (offsets != NULL) { ------------------ | Branch (2109:7): [True: 18.4k, False: 44] ------------------ 2110| 18.4k| offsets[nlabels] = offset; 2111| 18.4k| } 2112| 18.4k| nlabels++; 2113| 18.4k| count = *ndata; 2114| 18.4k| INSIST(count <= DNS_NAME_LABELLEN); ------------------ | | 202| 18.4k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 18.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 18.4k, False: 0] | | | | ------------------ | | | | 55| 18.4k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2115| 18.4k| offset += count + 1; 2116| 18.4k| ndata += count + 1; 2117| 18.4k| INSIST(offset <= length); ------------------ | | 202| 18.4k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 18.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 18.4k, False: 0] | | | | ------------------ | | | | 55| 18.4k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2118| 18.4k| if (count == 0) { ------------------ | Branch (2118:7): [True: 1.52k, False: 16.9k] ------------------ 2119| | /* Final root label */ 2120| 1.52k| break; 2121| 1.52k| } 2122| 18.4k| } 2123| 1.52k| INSIST(offset == name->length); ------------------ | | 202| 1.52k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.52k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.52k, False: 0] | | | | ------------------ | | | | 55| 1.52k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2124| | 2125| 1.52k| return nlabels; 2126| 1.52k|} 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 202| 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); ------------------ | | 74| 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); ------------------ | | 220| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 74| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 198| 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)); ------------------ | | 144| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 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); ------------------ | | 202| 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(); ------------------ | | 206| 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)); ------------------ | | 144| 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| 91|dst__openssl_keypair_destroy(dst_key_t *key) { 149| 91| if (key->keydata.pkeypair.priv != key->keydata.pkeypair.pub) { ------------------ | Branch (149:6): [True: 91, False: 0] ------------------ 150| 91| EVP_PKEY_free(key->keydata.pkeypair.priv); 151| 91| } 152| 91| EVP_PKEY_free(key->keydata.pkeypair.pub); 153| 91| key->keydata.pkeypair.pub = NULL; 154| | key->keydata.pkeypair.priv = NULL; 155| 91|} dst__opensslecdsa_init: 668| 4|dst__opensslecdsa_init(dst_func_t **funcp) { 669| 4| REQUIRE(funcp != NULL); ------------------ | | 198| 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: 642| 4|dst__openssleddsa_init(dst_func_t **funcp, unsigned char algorithm) { 643| 4| REQUIRE(funcp != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 644| | 645| 4| if (*funcp == NULL) { ------------------ | Branch (645:6): [True: 4, False: 0] ------------------ 646| 4| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (646:7): [True: 4, False: 0] ------------------ 647| 4| *funcp = &openssleddsa_functions; 648| 4| } 649| 4| } 650| 4|} openssleddsa_link.c:check_algorithm: 582| 4|check_algorithm(unsigned char algorithm) { 583| 4| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 584| 4| EVP_PKEY *pkey = NULL; 585| 4| const eddsa_alginfo_t *alginfo = NULL; 586| 4| const unsigned char *key = NULL; 587| 4| const unsigned char *sig = NULL; 588| 4| const unsigned char test[] = "test"; 589| 4| isc_result_t result = ISC_R_SUCCESS; 590| 4| size_t key_len, sig_len; 591| | 592| 4| if (evp_md_ctx == NULL) { ------------------ | Branch (592:6): [True: 0, False: 4] ------------------ 593| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 594| 0| } 595| | 596| 4| switch (algorithm) { 597| 0|#if HAVE_OPENSSL_ED448 598| 2| case DST_ALG_ED448: ------------------ | Branch (598:2): [True: 2, False: 2] ------------------ 599| 2| sig = ed448_sig; 600| 2| sig_len = sizeof(ed448_sig) - 1; 601| 2| key = ed448_pub; 602| 2| key_len = sizeof(ed448_pub) - 1; 603| 2| alginfo = openssleddsa_alg_info(algorithm); 604| 2| break; 605| 0|#endif /* HAVE_OPENSSL_ED448 */ 606| 2| case DST_ALG_ED25519: ------------------ | Branch (606:2): [True: 2, False: 2] ------------------ 607| 2| sig = ed25519_sig; 608| 2| sig_len = sizeof(ed25519_sig) - 1; 609| 2| key = ed25519_pub; 610| 2| key_len = sizeof(ed25519_pub) - 1; 611| 2| alginfo = openssleddsa_alg_info(algorithm); 612| 2| break; 613| 0| default: ------------------ | Branch (613:2): [True: 0, False: 4] ------------------ 614| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 615| 4| } 616| | 617| 4| INSIST(alginfo != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 618| 4| CHECK(raw_key_to_ossl(alginfo, 0, key, key_len, &pkey)); ------------------ | | 255| 4| { \ | | 256| 4| result = (r); \ | | 257| 4| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 4] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 4| } ------------------ 619| | 620| | /* 621| | * Check that we can verify the signature. 622| | */ 623| 4| if (EVP_DigestVerifyInit(evp_md_ctx, NULL, NULL, NULL, pkey) != 1 || ------------------ | Branch (623:6): [True: 0, False: 4] ------------------ 624| 4| EVP_DigestVerify(evp_md_ctx, sig, sig_len, test, ------------------ | Branch (624:6): [True: 0, False: 4] ------------------ 625| 4| sizeof(test) - 1) != 1) 626| 0| { 627| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 628| 0| } 629| | 630| 4|cleanup: 631| 4| if (pkey != NULL) { ------------------ | Branch (631:6): [True: 4, False: 0] ------------------ 632| 4| EVP_PKEY_free(pkey); 633| 4| } 634| 4| if (evp_md_ctx != NULL) { ------------------ | Branch (634:6): [True: 4, False: 0] ------------------ 635| | EVP_MD_CTX_destroy(evp_md_ctx); 636| 4| } 637| 4| ERR_clear_error(); 638| 4| return result; 639| 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| return ISC_R_SUCCESS; 100| 4|} dst__opensslrsa_init: 963| 12|dst__opensslrsa_init(dst_func_t **funcp, unsigned short algorithm) { 964| 12| REQUIRE(funcp != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 965| | 966| 12| if (*funcp == NULL) { ------------------ | Branch (966:6): [True: 12, False: 0] ------------------ 967| 12| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (967:7): [True: 12, False: 0] ------------------ 968| 12| *funcp = &opensslrsa_functions; 969| 12| } 970| 12| } 971| | 972| 12| if (rsa_exponent_min == NULL) { ------------------ | Branch (972:6): [True: 2, False: 10] ------------------ 973| 2| rsa_exponent_min = BN_new(); 974| 2| INSIST(rsa_exponent_min != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 975| | 976| 2| RUNTIME_CHECK(BN_set_word(rsa_exponent_min, 3) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 977| 2| } 978| | 979| 12| if (rsa_exponent_max == NULL) { ------------------ | Branch (979:6): [True: 2, False: 10] ------------------ 980| 2| rsa_exponent_max = BN_new(); 981| 2| INSIST(rsa_exponent_max != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 982| | 983| 2| RUNTIME_CHECK(BN_set_bit(rsa_exponent_max, 0) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 984| 2| RUNTIME_CHECK(BN_set_bit(rsa_exponent_max, 32) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 985| 2| } 986| 12|} opensslrsa_link.c:check_algorithm: 903| 12|check_algorithm(unsigned short algorithm) { 904| 12| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 905| 12| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 906| 12| EVP_PKEY *pkey = NULL; 907| 12| const EVP_MD *type = NULL; 908| 12| const unsigned char *sig = NULL; 909| 12| isc_result_t result = ISC_R_SUCCESS; 910| 12| size_t len; 911| | 912| 12| switch (algorithm) { 913| 2| case DST_ALG_RSASHA1: ------------------ | Branch (913:2): [True: 2, False: 10] ------------------ 914| 4| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (914:2): [True: 2, False: 10] ------------------ 915| 4| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 916| 4| sig = sha1_sig; 917| 4| len = sizeof(sha1_sig) - 1; 918| 4| break; 919| 2| case DST_ALG_RSASHA256: ------------------ | Branch (919:2): [True: 2, False: 10] ------------------ 920| 4| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (920:2): [True: 2, False: 10] ------------------ 921| 4| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 922| 4| sig = sha256_sig; 923| 4| len = sizeof(sha256_sig) - 1; 924| 4| break; 925| 2| case DST_ALG_RSASHA512: ------------------ | Branch (925:2): [True: 2, False: 10] ------------------ 926| 4| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (926:2): [True: 2, False: 10] ------------------ 927| 4| type = isc__crypto_md[ISC_MD_SHA512]; 928| 4| sig = sha512_sig; 929| 4| len = sizeof(sha512_sig) - 1; 930| 4| break; 931| 0| default: ------------------ | Branch (931:2): [True: 0, False: 12] ------------------ 932| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 933| 12| } 934| | 935| | /* 936| | * Construct pkey. 937| | */ 938| 12| c.e = BN_bin2bn(e_bytes, sizeof(e_bytes) - 1, NULL); 939| 12| c.n = BN_bin2bn(n_bytes, sizeof(n_bytes) - 1, NULL); 940| | 941| 12| result = isc_ossl_wrap_load_rsa_public_from_components(&c, &pkey); 942| 12| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 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))) | | ------------------ ------------------ 943| | 944| | /* 945| | * Check that we can verify the signature. 946| | */ 947| 12| if (EVP_DigestInit_ex(evp_md_ctx, type, NULL) != 1 || ------------------ | Branch (947:6): [True: 0, False: 12] ------------------ 948| 12| EVP_DigestUpdate(evp_md_ctx, "test", 4) != 1 || ------------------ | Branch (948:6): [True: 0, False: 12] ------------------ 949| 12| EVP_VerifyFinal(evp_md_ctx, sig, len, pkey) != 1) ------------------ | Branch (949:6): [True: 0, False: 12] ------------------ 950| 0| { 951| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 952| 0| } 953| | 954| 12|cleanup: 955| 12| isc_ossl_wrap_rsa_components_cleanup(&c); 956| 12| EVP_PKEY_free(pkey); 957| | EVP_MD_CTX_destroy(evp_md_ctx); 958| 12| ERR_clear_error(); 959| 12| return result; 960| 12|} opensslrsa_link.c:opensslrsa_createctx: 89| 9|opensslrsa_createctx(dst_key_t *key, dst_context_t *dctx) { 90| 9| EVP_MD_CTX *evp_md_ctx; 91| 9| const EVP_MD *type = NULL; 92| | 93| 9| UNUSED(key); ------------------ | | 69| 9|#define UNUSED(x) (void)(x) ------------------ 94| 9| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 18| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 9, False: 0] | | | | | Branch (42:11): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 95| 9| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 96| | 97| | /* 98| | * Reject incorrect RSA key lengths. 99| | */ 100| 9| switch (dctx->key->key_alg) { 101| 0| case DST_ALG_RSASHA1: ------------------ | Branch (101:2): [True: 0, False: 9] ------------------ 102| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (102:2): [True: 0, False: 9] ------------------ 103| | /* From RFC 3110 */ 104| 0| if (dctx->key->key_size > 4096) { ------------------ | Branch (104:7): [True: 0, False: 0] ------------------ 105| 0| return ISC_R_FAILURE; 106| 0| } 107| 0| break; 108| 9| case DST_ALG_RSASHA256: ------------------ | Branch (108:2): [True: 9, False: 0] ------------------ 109| 9| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (109:2): [True: 0, False: 9] ------------------ 110| | /* From RFC 5702 */ 111| 9| if (dctx->key->key_size < 512 || dctx->key->key_size > 4096) { ------------------ | Branch (111:7): [True: 0, False: 9] | Branch (111:36): [True: 0, False: 9] ------------------ 112| 0| return ISC_R_FAILURE; 113| 0| } 114| 9| break; 115| 9| case DST_ALG_RSASHA512: ------------------ | Branch (115:2): [True: 0, False: 9] ------------------ 116| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (116:2): [True: 0, False: 9] ------------------ 117| | /* From RFC 5702 */ 118| 0| if (dctx->key->key_size < 1024 || dctx->key->key_size > 4096) { ------------------ | Branch (118:7): [True: 0, False: 0] | Branch (118:37): [True: 0, False: 0] ------------------ 119| 0| return ISC_R_FAILURE; 120| 0| } 121| 0| break; 122| 0| default: ------------------ | Branch (122:2): [True: 0, False: 9] ------------------ 123| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 124| 9| } 125| | 126| 9| evp_md_ctx = EVP_MD_CTX_create(); 127| 9| if (evp_md_ctx == NULL) { ------------------ | Branch (127:6): [True: 0, False: 9] ------------------ 128| 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__) ------------------ 129| 0| } 130| | 131| 9| switch (dctx->key->key_alg) { 132| 0| case DST_ALG_RSASHA1: ------------------ | Branch (132:2): [True: 0, False: 9] ------------------ 133| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (133:2): [True: 0, False: 9] ------------------ 134| 0| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 135| 0| break; 136| 9| case DST_ALG_RSASHA256: ------------------ | Branch (136:2): [True: 9, False: 0] ------------------ 137| 9| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (137:2): [True: 0, False: 9] ------------------ 138| 9| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 139| 9| break; 140| 0| case DST_ALG_RSASHA512: ------------------ | Branch (140:2): [True: 0, False: 9] ------------------ 141| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (141:2): [True: 0, False: 9] ------------------ 142| 0| type = isc__crypto_md[ISC_MD_SHA512]; 143| 0| break; 144| 0| default: ------------------ | Branch (144:2): [True: 0, False: 9] ------------------ 145| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 146| 9| } 147| | 148| 9| if (!EVP_DigestInit_ex(evp_md_ctx, type, NULL)) { ------------------ | Branch (148:6): [True: 0, False: 9] ------------------ 149| 0| EVP_MD_CTX_destroy(evp_md_ctx); 150| 0| return dst__openssl_toresult3( ------------------ | | 36| 0| isc__ossl_wrap_logged_toresult(category, DNS_LOGMODULE_CRYPTO, \ | | 37| 0| funcname, fallback, __FILE__, __LINE__) ------------------ 151| 0| dctx->category, "EVP_DigestInit_ex", ISC_R_FAILURE); 152| 0| } 153| 9| dctx->ctxdata.evp_md_ctx = evp_md_ctx; 154| | 155| 9| return ISC_R_SUCCESS; 156| 9|} opensslrsa_link.c:opensslrsa_valid_key_alg: 74| 145|opensslrsa_valid_key_alg(unsigned int key_alg) { 75| 145| switch (key_alg) { 76| 0| case DST_ALG_RSASHA1: ------------------ | Branch (76:2): [True: 0, False: 145] ------------------ 77| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (77:2): [True: 0, False: 145] ------------------ 78| 145| case DST_ALG_RSASHA256: ------------------ | Branch (78:2): [True: 145, False: 0] ------------------ 79| 145| case DST_ALG_RSASHA512: ------------------ | Branch (79:2): [True: 0, False: 145] ------------------ 80| 145| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (80:2): [True: 0, False: 145] ------------------ 81| 145| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (81:2): [True: 0, False: 145] ------------------ 82| 145| return true; 83| 0| default: ------------------ | Branch (83:2): [True: 0, False: 145] ------------------ 84| | return false; 85| 145| } 86| 145|} opensslrsa_link.c:opensslrsa_destroyctx: 159| 9|opensslrsa_destroyctx(dst_context_t *dctx) { 160| 9| EVP_MD_CTX *evp_md_ctx = NULL; 161| | 162| 9| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 18| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 9, False: 0] | | | | | Branch (42:11): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 163| 9| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 164| | 165| 9| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 166| | 167| 9| if (evp_md_ctx != NULL) { ------------------ | Branch (167:6): [True: 9, False: 0] ------------------ 168| 9| EVP_MD_CTX_destroy(evp_md_ctx); 169| | dctx->ctxdata.evp_md_ctx = NULL; 170| 9| } 171| 9|} opensslrsa_link.c:opensslrsa_adddata: 174| 27|opensslrsa_adddata(dst_context_t *dctx, const isc_region_t *data) { 175| 27| EVP_MD_CTX *evp_md_ctx = NULL; 176| | 177| 27| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 27|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 54| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 27, False: 0] | | | | | Branch (42:11): [True: 27, False: 0] | | | | ------------------ | | | | 43| 27| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 178| 27| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 27|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 27| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 27, False: 0] | | | | ------------------ | | | | 43| 27| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 179| | 180| 27| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 181| | 182| 27| if (!EVP_DigestUpdate(evp_md_ctx, data->base, data->length)) { ------------------ | Branch (182:6): [True: 0, False: 27] ------------------ 183| 0| return dst__openssl_toresult3( ------------------ | | 36| 0| isc__ossl_wrap_logged_toresult(category, DNS_LOGMODULE_CRYPTO, \ | | 37| 0| funcname, fallback, __FILE__, __LINE__) ------------------ 184| 0| dctx->category, "EVP_DigestUpdate", ISC_R_FAILURE); 185| 0| } 186| 27| return ISC_R_SUCCESS; 187| 27|} opensslrsa_link.c:opensslrsa_verify: 247| 9|opensslrsa_verify(dst_context_t *dctx, const isc_region_t *sig) { 248| 9| dst_key_t *key = NULL; 249| 9| int status = 0; 250| 9| EVP_MD_CTX *evp_md_ctx = NULL; 251| 9| EVP_PKEY *pkey = NULL; 252| 9| const unsigned char *base = sig->base; 253| 9| unsigned int length = sig->length; 254| | 255| 9| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 18| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 9, False: 0] | | | | | Branch (42:11): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 256| 9| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 257| | 258| 9| key = dctx->key; 259| 9| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 260| 9| pkey = key->keydata.pkeypair.pub; 261| | 262| 9| if (!isc_ossl_wrap_rsa_modulus_bits_in_range(pkey, rsa_min_modulus_bits, ------------------ | Branch (262:6): [True: 0, False: 9] ------------------ 263| 9| rsa_max_modulus_bits) || 264| 9| !isc_ossl_wrap_rsa_exponent_is_allowed(pkey)) ------------------ | Branch (264:6): [True: 0, False: 9] ------------------ 265| 0| { 266| 0| return DST_R_VERIFYFAILURE; 267| 0| } 268| | 269| | /* 270| | * Check identifying OID in front of public key material. 271| | */ 272| 9| switch (key->key_alg) { ------------------ | Branch (272:10): [True: 0, False: 9] ------------------ 273| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (273:2): [True: 0, False: 9] ------------------ 274| 0| if (length < sizeof(oid_rsasha256) || ------------------ | Branch (274:7): [True: 0, False: 0] ------------------ 275| 0| memcmp(base, oid_rsasha256, sizeof(oid_rsasha256)) != 0) ------------------ | Branch (275:7): [True: 0, False: 0] ------------------ 276| 0| { 277| 0| return DST_R_VERIFYFAILURE; 278| 0| } 279| 0| base += sizeof(oid_rsasha256); 280| 0| length -= sizeof(oid_rsasha256); 281| 0| break; 282| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (282:2): [True: 0, False: 9] ------------------ 283| 0| if (length < sizeof(oid_rsasha512) || ------------------ | Branch (283:7): [True: 0, False: 0] ------------------ 284| 0| memcmp(base, oid_rsasha512, sizeof(oid_rsasha512)) != 0) ------------------ | Branch (284:7): [True: 0, False: 0] ------------------ 285| 0| { 286| 0| return DST_R_VERIFYFAILURE; 287| 0| } 288| 0| base += sizeof(oid_rsasha512); 289| 0| length -= sizeof(oid_rsasha512); 290| 0| break; 291| 9| } 292| | 293| 9| status = EVP_VerifyFinal(evp_md_ctx, base, length, pkey); 294| 9| switch (status) { 295| 1| case 1: ------------------ | Branch (295:2): [True: 1, False: 8] ------------------ 296| 1| return ISC_R_SUCCESS; 297| 8| case 0: ------------------ | Branch (297:2): [True: 8, False: 1] ------------------ 298| 8| return dst__openssl_toresult(DST_R_VERIFYFAILURE); ------------------ | | 28| 8| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 8| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 8| __FILE__, __LINE__) ------------------ 299| 0| default: ------------------ | Branch (299:2): [True: 0, False: 9] ------------------ 300| 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__) ------------------ 301| 9| DST_R_VERIFYFAILURE); 302| 9| } 303| 9|} opensslrsa_link.c:opensslrsa_fromdns: 429| 91|opensslrsa_fromdns(dst_key_t *key, isc_buffer_t *data) { 430| 91| isc_result_t result; 431| 91| isc_region_t r; 432| 91| unsigned int e_bytes; 433| 91| unsigned int length; 434| 91| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 435| | 436| 91| REQUIRE(opensslrsa_valid_key_alg(key->key_alg)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 437| | 438| 91| isc_buffer_remainingregion(data, &r); 439| 91| if (r.length == 0) { ------------------ | Branch (439:6): [True: 0, False: 91] ------------------ 440| 0| CLEANUP(ISC_R_SUCCESS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 441| 0| } 442| | 443| | /* 444| | * Check identifying OID in front of public key material. 445| | */ 446| 91| switch (key->key_alg) { ------------------ | Branch (446:10): [True: 0, False: 91] ------------------ 447| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (447:2): [True: 0, False: 91] ------------------ 448| 0| if (r.length < sizeof(oid_rsasha256) || ------------------ | Branch (448:7): [True: 0, False: 0] ------------------ 449| 0| memcmp(r.base, oid_rsasha256, sizeof(oid_rsasha256)) != 0) ------------------ | Branch (449:7): [True: 0, False: 0] ------------------ 450| 0| { 451| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 452| 0| } 453| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 454| 0| isc_buffer_forward(data, sizeof(oid_rsasha256)); 455| 0| break; 456| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (456:2): [True: 0, False: 91] ------------------ 457| 0| if (r.length < sizeof(oid_rsasha512) || ------------------ | Branch (457:7): [True: 0, False: 0] ------------------ 458| 0| memcmp(r.base, oid_rsasha512, sizeof(oid_rsasha512)) != 0) ------------------ | Branch (458:7): [True: 0, False: 0] ------------------ 459| 0| { 460| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 461| 0| } 462| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 463| 0| isc_buffer_forward(data, sizeof(oid_rsasha512)); 464| 0| break; 465| 91| } 466| | 467| 91| length = r.length; 468| 91| if (r.length < 1) { ------------------ | Branch (468:6): [True: 0, False: 91] ------------------ 469| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 470| 0| } 471| | 472| 91| e_bytes = *r.base; 473| 91| isc_region_consume(&r, 1); ------------------ | | 50| 91| do { \ | | 51| 91| isc_region_t *_r = (r); \ | | 52| 91| unsigned int _l = (l); \ | | 53| 91| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 91| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 91, False: 0] | | | | | | ------------------ | | | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 91| _r->base += _l; \ | | 55| 91| _r->length -= _l; \ | | 56| 91| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 91] | | ------------------ ------------------ 474| | 475| 91| if (e_bytes == 0) { ------------------ | Branch (475:6): [True: 0, False: 91] ------------------ 476| 0| if (r.length < 2) { ------------------ | Branch (476:7): [True: 0, False: 0] ------------------ 477| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 478| 0| } 479| 0| e_bytes = (*r.base) << 8; 480| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 481| 0| e_bytes += *r.base; 482| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 483| 0| } 484| | 485| 91| if (r.length < e_bytes) { ------------------ | Branch (485:6): [True: 0, False: 91] ------------------ 486| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 487| 0| } 488| 91| if (e_bytes > rsa_max_exponent_bytes || ------------------ | Branch (488:6): [True: 0, False: 91] ------------------ 489| 91| r.length - e_bytes > rsa_max_modulus_bytes) ------------------ | Branch (489:6): [True: 0, False: 91] ------------------ 490| 0| { 491| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 492| 0| } 493| 91| c.e = BN_bin2bn(r.base, e_bytes, NULL); 494| 91| isc_region_consume(&r, e_bytes); ------------------ | | 50| 91| do { \ | | 51| 91| isc_region_t *_r = (r); \ | | 52| 91| unsigned int _l = (l); \ | | 53| 91| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 91| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 91, False: 0] | | | | | | ------------------ | | | | | | 55| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 91| _r->base += _l; \ | | 55| 91| _r->length -= _l; \ | | 56| 91| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 91] | | ------------------ ------------------ 495| 91| c.n = BN_bin2bn(r.base, r.length, NULL); 496| 91| if (c.e == NULL || c.n == NULL) { ------------------ | Branch (496:6): [True: 0, False: 91] | Branch (496:21): [True: 0, False: 91] ------------------ 497| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 498| 0| } 499| 91| if (BN_num_bits(c.n) < rsa_min_modulus_bits || ------------------ | Branch (499:6): [True: 0, False: 91] ------------------ 500| 91| BN_num_bits(c.n) > rsa_max_modulus_bits) ------------------ | Branch (500:6): [True: 0, False: 91] ------------------ 501| 0| { 502| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 503| 0| } 504| 91| if (!rsa_exponent_in_range(c.e)) { ------------------ | Branch (504:6): [True: 0, False: 91] ------------------ 505| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 506| 0| } 507| 91| isc_buffer_forward(data, length); 508| | 509| 91| key->key_size = BN_num_bits(c.n); 510| 91| result = isc_ossl_wrap_load_rsa_public_from_components( 511| 91| &c, &key->keydata.pkeypair.pub); 512| | 513| 91|cleanup: 514| 91| isc_ossl_wrap_rsa_components_cleanup(&c); 515| 91| return result; 516| 91|} opensslrsa_link.c:rsa_exponent_in_range: 49| 91|rsa_exponent_in_range(const BIGNUM *e) { 50| 91| if (!BN_is_odd(e)) { ------------------ | Branch (50:6): [True: 0, False: 91] ------------------ 51| 0| return false; 52| 0| } 53| | 54| 91| if (BN_cmp(e, rsa_exponent_min) < 0) { ------------------ | Branch (54:6): [True: 0, False: 91] ------------------ 55| 0| return false; 56| 0| } 57| | 58| 91| if (BN_cmp(e, rsa_exponent_max) > 0) { ------------------ | Branch (58:6): [True: 0, False: 91] ------------------ 59| 0| return false; 60| 0| } 61| | 62| 91| return true; 63| 91|} 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); ------------------ | | 198| 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)); ------------------ | | 144| 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); ------------------ | | 198| 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)); ------------------ | | 144| 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); ------------------ | | 202| 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); ------------------ | | 200| 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.48k| dns_namespace_t space) { 244| 1.48k| REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); ------------------ | | 198| 1.48k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.97k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.48k, False: 0] | | | | | Branch (42:11): [True: 1.48k, False: 0] | | | | ------------------ | | | | 43| 1.48k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 245| | 246| 1.48k| dns_offsets_t offsets; 247| 1.48k| size_t labels = dns_name_offsets(name, offsets); 248| 1.48k| size_t len = 0; 249| | 250| | /* namespace */ 251| 1.48k| key[len++] = ENCODE_NAMESPACE(space); ------------------ | | 124| 1.48k|#define ENCODE_NAMESPACE(c) dns_qp_bits_for_byte[(c) + (uint8_t)'0'] ------------------ 252| | /* name */ 253| 1.48k| if (labels == 0) { ------------------ | Branch (253:6): [True: 0, False: 1.48k] ------------------ 254| 0| key[len] = SHIFT_NOBYTE; 255| 0| return len; 256| 0| } 257| | 258| 1.48k| size_t label = labels; 259| 19.8k| while (label-- > 0) { ------------------ | Branch (259:9): [True: 18.4k, False: 1.48k] ------------------ 260| 18.4k| const uint8_t *ldata = name->ndata + offsets[label]; 261| 18.4k| size_t label_len = *ldata++; 262| 62.7k| while (label_len-- > 0) { ------------------ | Branch (262:10): [True: 44.3k, False: 18.4k] ------------------ 263| 44.3k| uint16_t bits = dns_qp_bits_for_byte[*ldata++]; 264| 44.3k| key[len++] = bits & 0xFF; /* bit_one */ 265| 44.3k| if ((bits >> 8) != 0) { /* escape? */ ------------------ | Branch (265:8): [True: 32.6k, False: 11.7k] ------------------ 266| 32.6k| key[len++] = bits >> 8; /* bit_two */ 267| 32.6k| } 268| 44.3k| } 269| | /* label terminator */ 270| 18.4k| key[len++] = SHIFT_NOBYTE; 271| 18.4k| } 272| | /* mark end with a double NOBYTE */ 273| 1.48k| key[len] = SHIFT_NOBYTE; 274| 1.48k| ENSURE(len < sizeof(dns_qpkey_t)); ------------------ | | 200| 1.48k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.48k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.48k, False: 0] | | | | ------------------ | | | | 49| 1.48k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 275| 1.48k| return len; 276| 1.48k|} dns_qp_compact: 1020| 6|dns_qp_compact(dns_qp_t *qp, dns_qpgc_t mode) { 1021| 6| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); \ | | | | | | ------------------ | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 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)); ------------------ | | 202| 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); \ | | | | | | ------------------ | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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 || ------------------ | | 198| 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); ------------------ | | 202| 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); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200: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); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1276| 0| } 1277| 0| isc_mem_free(qp->mctx, multi->rollback); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 1278| 0| } 1279| 8| INSIST(multi->rollback == NULL); ------------------ | | 202| 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)); ------------------ | | 202| 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); \ | | ------------------ | | | | 202| 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); \ | | | | | | ------------------ | | | | | | | | 288| 8| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 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| 630|dns_qpmulti_query(dns_qpmulti_t *multi, dns_qpread_t *qp) { 1398| 630| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 630, False: 0] | | | | | Branch (42:11): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1399| 630| REQUIRE(qp != NULL); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 630| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1400| | 1401| 630| qp->tid = isc_tid(); 1402| 630| rcu_read_lock(); 1403| | 1404| 630| dns_qpmulti_t *whence = reader_open(multi, qp); 1405| 630| INSIST(whence == multi); ------------------ | | 202| 630|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 630| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 630, False: 0] | | | | ------------------ | | | | 55| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1406| 630|} dns_qpread_destroy: 1409| 630|dns_qpread_destroy(dns_qpmulti_t *multi, dns_qpread_t *qp) { 1410| 630| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 630, False: 0] | | | | | Branch (42:11): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1411| 630| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 630, False: 0] | | | | | Branch (42:11): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1412| 630| REQUIRE(qp->tid == isc_tid()); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 630| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1413| 630| *qp = (dns_qpread_t){}; 1414| | rcu_read_unlock(); 1415| 630|} dns_qpmulti_create: 1511| 8| dns_qpmulti_t **qpmp) { 1512| 8| REQUIRE(qpmp != NULL && *qpmp == NULL); ------------------ | | 198| 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)); ------------------ | | 144| 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); \ | | | | ------------------ | | | | | | 288| 8| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 8] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 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)); ------------------ | | 198| 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)); ------------------ | | 202| 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)); ------------------ | | 202| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 104| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 0] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 1807| 0| SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 104| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 0] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 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); ------------------ | | 202| 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)); ------------------ | | 202| 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); ------------------ | | 202| 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| 624|dns_qpchain_init(dns_qpreadable_t qpr, dns_qpchain_t *chain) { 1862| 624| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 624|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1863| 624| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 624|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 624, False: 0] | | | | | Branch (42:11): [True: 624, False: 0] | | | | ------------------ | | | | 43| 624| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1864| 624| REQUIRE(chain != NULL); ------------------ | | 198| 624|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 624| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 624, False: 0] | | | | ------------------ | | | | 43| 624| ((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| 624| chain->magic = QPCHAIN_MAGIC; ------------------ | | 369| 624|#define QPCHAIN_MAGIC ISC_MAGIC('q', 'p', 'c', 'h') | | ------------------ | | | | 31| 624|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1872| 624| chain->qp = qp; 1873| 624| chain->len = 0; 1874| 624|} dns_qpchain_length: 1877| 200|dns_qpchain_length(dns_qpchain_t *chain) { 1878| 200| REQUIRE(QPCHAIN_VALID(chain)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1879| | 1880| 200| return chain->len; 1881| 200|} dns_qpchain_node: 1885| 77| uint32_t *ival_r) { 1886| 77| dns_qpnode_t *node = NULL; 1887| | 1888| 77| REQUIRE(QPCHAIN_VALID(chain)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 104| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 77, False: 0] | | ------------------ | | 105| 77| *(obj) = (val); \ | | 106| 77| } ------------------ 1893| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 104| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 77] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 1894| 77|} dns_qpiter_init: 1901| 701|dns_qpiter_init(dns_qpreadable_t qpr, dns_qpiter_t *qpi) { 1902| 701| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 701|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1903| 701| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 701|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.40k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 701, False: 0] | | | | | Branch (42:11): [True: 701, False: 0] | | | | ------------------ | | | | 43| 701| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1904| 701| REQUIRE(qpi != NULL); ------------------ | | 198| 701|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 701| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 701, False: 0] | | | | ------------------ | | | | 43| 701| ((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| 701| qpi->qp = qp; 1912| 701| qpi->sp = 0; 1913| 701| qpi->magic = QPITER_MAGIC; ------------------ | | 368| 701|#define QPITER_MAGIC ISC_MAGIC('q', 'p', 'i', 't') | | ------------------ | | | | 31| 701|#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| 701|} 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)); ------------------ | | 198| 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)); ------------------ | | 104| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 77, False: 0] | | ------------------ | | 105| 77| *(obj) = (val); \ | | 106| 77| } ------------------ 2044| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 104| 77| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 77] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 104| 12| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 12, False: 0] | | ------------------ | | 105| 12| *(obj) = (val); \ | | 106| 12| } ------------------ 2087| | SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 104| 12| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 12] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 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| 624| void **pval_r, uint32_t *ival_r) { 2273| 624| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 624|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 2274| 624| dns_qpkey_t search, found; 2275| 624| size_t searchlen, foundlen; 2276| 624| size_t offset = 0; 2277| 624| dns_qpnode_t *n = NULL; 2278| 624| dns_qpshift_t bit = SHIFT_NOBYTE; 2279| 624| dns_qpchain_t oc; 2280| 624| dns_qpiter_t it; 2281| 624| bool matched = false; 2282| 624| bool setiter = true; 2283| | 2284| 624| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 624|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 624, False: 0] | | | | | Branch (42:11): [True: 624, False: 0] | | | | ------------------ | | | | 43| 624| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2285| | 2286| 624| searchlen = dns_qpkey_fromname(search, name, space); 2287| | 2288| 624| if (chain == NULL) { ------------------ | Branch (2288:6): [True: 0, False: 624] ------------------ 2289| 0| chain = &oc; 2290| 0| } 2291| 624| if (iter == NULL) { ------------------ | Branch (2291:6): [True: 424, False: 200] ------------------ 2292| 424| iter = ⁢ 2293| 424| setiter = false; 2294| 424| } 2295| 624| dns_qpchain_init(qp, chain); 2296| 624| dns_qpiter_init(qp, iter); 2297| | 2298| 624| n = get_root(qp); 2299| 624| if (n == NULL) { ------------------ | Branch (2299:6): [True: 0, False: 624] ------------------ 2300| 0| return ISC_R_NOTFOUND; 2301| 0| } 2302| 624| 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| 824| while (is_branch(n)) { ------------------ | Branch (2311:9): [True: 200, False: 624] ------------------ 2312| 200| prefetch_twigs(qp, n); 2313| | 2314| 200| offset = branch_key_offset(n); 2315| 200| bit = qpkey_bit(search, searchlen, offset); 2316| 200| 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| 200| if (bit != SHIFT_NOBYTE && branch_has_twig(n, SHIFT_NOBYTE) && ------------------ | Branch (2332:7): [True: 200, False: 0] | Branch (2332:30): [True: 0, False: 200] ------------------ 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| 200| matched = branch_has_twig(n, bit); 2340| 200| if (matched) { ------------------ | Branch (2340:7): [True: 200, 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| 200| n = branch_twig_ptr(qp, n, bit); 2347| 200| } 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| 200| iter->stack[++iter->sp] = n; 2357| 200| } 2358| | 2359| 624| if (setiter) { ------------------ | Branch (2359:6): [True: 200, False: 424] ------------------ 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| 200| fix_iterator(qp, iter, search, searchlen); 2366| 200| n = iter->stack[iter->sp]; 2367| 200| } 2368| | 2369| | /* at this point, n can only be a leaf node */ 2370| 624| INSIST(!is_branch(n)); ------------------ | | 202| 624|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 624| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 624, False: 0] | | | | ------------------ | | | | 55| 624| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2371| | 2372| 624| foundlen = leaf_qpkey(qp, n, found); 2373| 624| offset = qpkey_compare(search, searchlen, found, foundlen); 2374| | 2375| | /* the search ended with an exact or partial match */ 2376| 624| if (offset == QPKEY_EQUAL || offset == foundlen) { ------------------ | | 364| 1.24k|#define QPKEY_EQUAL (~(size_t)0) ------------------ | Branch (2376:6): [True: 246, False: 378] | Branch (2376:31): [True: 154, False: 224] ------------------ 2377| 400| isc_result_t result = ISC_R_SUCCESS; 2378| | 2379| 400| if (offset == foundlen) { ------------------ | Branch (2379:7): [True: 154, False: 246] ------------------ 2380| 154| fix_chain(chain, offset); 2381| 154| result = DNS_R_PARTIALMATCH; 2382| 154| } 2383| 400| add_link(chain, n, offset); 2384| | 2385| 400| SET_IF_NOT_NULL(pval_r, leaf_pval(n)); ------------------ | | 104| 400| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 400, False: 0] | | ------------------ | | 105| 400| *(obj) = (val); \ | | 106| 400| } ------------------ 2386| 400| SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 104| 400| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 400] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 2387| 400| return result; 2388| 400| } 2389| | 2390| | /* 2391| | * the requested name was not found, but if an ancestor 2392| | * was, we can retrieve that from the chain. 2393| | */ 2394| 224| int len = chain->len; 2395| 224| while (len-- > 0) { ------------------ | Branch (2395:9): [True: 0, False: 224] ------------------ 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)); ------------------ | | 104| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 0] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 2399| 0| SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 104| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 0] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 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| 224| return ISC_R_NOTFOUND; 2413| 224|} 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); ------------------ | | 200| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 81| 6|#define ISC_MAX3(a, b, c) ISC_MAX(ISC_MAX((a), (b)), (c)) | | ------------------ | | | | 76| 12|#define ISC_MAX(a, b) ((a) > (b) ? (a) : (b)) | | | | ------------------ | | | | | Branch (76:24): [True: 0, False: 6] | | | | | Branch (76:25): [True: 0, False: 6] | | | | | Branch (76:37): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 501| 6| uint32_t log2 = 32U - stdc_leading_zeros(size - 1U); ------------------ | | 40| 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); ------------------ | | 79| 6|#define ISC_CLAMP(v, x, y) ((v) < (x) ? (x) : ((v) > (y) ? (y) : (v))) | | ------------------ | | | Branch (79:29): [True: 6, False: 0] | | | Branch (79: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); ------------------ | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 0, False: 0] | | ------------------ ------------------ 421| 0| return ptr; 422| 6| } else { 423| 6| return isc_mem_allocate(qp->mctx, len); ------------------ | | 157| 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); ------------------ | | 114| 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); ------------------ | | 164| 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); ------------------ | | 157| 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); ------------------ | | 164| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); \ | | | | | | ------------------ | | | | | | | | 288| 8| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 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)); ------------------ | | 202| 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); ------------------ | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245: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); ------------------ | | 200| 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); ------------------ | | 200| 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); ------------------ | | 200| 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)); ------------------ | | 144| 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| 630|reader_open(dns_qpmulti_t *multi, dns_qpreadable_t qpr) { 1382| 630| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 630|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1383| 630| dns_qpnode_t *reader = rcu_dereference(multi->reader); 1384| 630| if (reader == NULL) { ------------------ | Branch (1384:6): [True: 0, False: 630] ------------------ 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| 630| } else { 1387| 630| multi = unpack_reader(qp, reader); 1388| 630| } 1389| 630| return multi; 1390| 630|} 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| 840| const dns_qpkey_t key_b, const size_t keylen_b) { 382| 840| size_t keylen = ISC_MAX(keylen_a, keylen_b); ------------------ | | 76| 840|#define ISC_MAX(a, b) ((a) > (b) ? (a) : (b)) | | ------------------ | | | Branch (76:24): [True: 386, False: 454] | | ------------------ ------------------ 383| 7.55k| for (size_t offset = 0; offset < keylen; offset++) { ------------------ | Branch (383:26): [True: 7.17k, False: 381] ------------------ 384| 7.17k| if (qpkey_bit(key_a, keylen_a, offset) != ------------------ | Branch (384:7): [True: 459, False: 6.71k] ------------------ 385| 7.17k| qpkey_bit(key_b, keylen_b, offset)) 386| 459| { 387| 459| return offset; 388| 459| } 389| 7.17k| } 390| 381| return QPKEY_EQUAL; ------------------ | | 364| 381|#define QPKEY_EQUAL (~(size_t)0) ------------------ 391| 840|} 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 202| 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)); ------------------ | | 104| 154| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 77, False: 77] | | ------------------ | | 105| 77| *(obj) = (val); \ | | 106| 77| } ------------------ 2018| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 104| 154| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 154] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 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| 400|add_link(dns_qpchain_t *chain, dns_qpnode_t *node, size_t offset) { 2101| | /* prevent duplication */ 2102| 400| if (chain->len != 0 && chain->chain[chain->len - 1].node == node) { ------------------ | Branch (2102:6): [True: 0, False: 400] | Branch (2102:25): [True: 0, False: 0] ------------------ 2103| 0| return; 2104| 0| } 2105| 400| chain->chain[chain->len].node = node; 2106| 400| chain->chain[chain->len].offset = offset; 2107| 400| chain->len++; 2108| 400| INSIST(chain->len <= DNS_NAME_MAXLABELS); ------------------ | | 202| 400|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 400, False: 0] | | | | ------------------ | | | | 55| 400| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 2109| 400|} qp.c:fix_iterator: 2164| 200| size_t len) { 2165| 200| dns_qpnode_t *n = it->stack[it->sp]; 2166| | 2167| 200| REQUIRE(!is_branch(n)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2168| | 2169| 200| dns_qpkey_t found; 2170| 200| size_t foundlen = leaf_qpkey(qp, n, found); 2171| 200| 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| 200| if (to == QPKEY_EQUAL) { ------------------ | | 364| 200|#define QPKEY_EQUAL (~(size_t)0) ------------------ | Branch (2174:6): [True: 123, False: 77] ------------------ 2175| 123| return; 2176| 123| } 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)); ------------------ | | 202| 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.7k|qpkey_bit(const dns_qpkey_t key, size_t len, size_t offset) { 672| 14.7k| if (offset < len) { ------------------ | Branch (672:6): [True: 14.4k, False: 369] ------------------ 673| 14.4k| return key[offset]; 674| 14.4k| } else { 675| 369| return SHIFT_NOBYTE; 676| 369| } 677| 14.7k|} 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.92k|ref_chunk(dns_qpref_t ref) { 216| 1.92k| return ref / QP_CHUNK_SIZE; ------------------ | | 159| 1.92k|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 148| 1.92k|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 217| 1.92k|} qp.c:ref_cell: 220| 1.92k|ref_cell(dns_qpref_t ref) { 221| 1.92k| return ref % QP_CHUNK_SIZE; ------------------ | | 159| 1.92k|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 148| 1.92k|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 222| 1.92k|} 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.91k|ref_ptr(dns_qpreadable_t qpr, dns_qpref_t ref) { 358| 1.91k| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 1.91k|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 359| 1.91k| return qp->base->ptr[ref_chunk(ref)] + ref_cell(ref); 360| 1.91k|} 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.27k|node_tag(dns_qpnode_t *n) { 603| 1.27k| return n->biglo & TAG_MASK; 604| 1.27k|} qp.c:node_pointer: 594| 2.76k|node_pointer(dns_qpnode_t *n) { 595| 2.76k| return (void *)(uintptr_t)(node64(n) & ~TAG_MASK); 596| 2.76k|} qp.c:node64: 563| 4.23k|node64(dns_qpnode_t *n) { 564| 4.23k| uint64_t lo = n->biglo; 565| 4.23k| uint64_t hi = n->bighi; 566| 4.23k| return lo | (hi << 32); 567| 4.23k|} qp.c:reader_valid: 854| 630|reader_valid(dns_qpnode_t *reader) { 855| 630| return reader != NULL && // ------------------ | Branch (855:9): [True: 630, False: 0] ------------------ 856| 630| node_tag(&reader[0]) == READER_TAG && ------------------ | Branch (856:9): [True: 630, False: 0] ------------------ 857| 630| node_tag(&reader[1]) == READER_TAG && ------------------ | Branch (857:9): [True: 630, False: 0] ------------------ 858| 630| node32(&reader[0]) == QPREADER_MAGIC; ------------------ | | 371| 630|#define QPREADER_MAGIC ISC_MAGIC('q', 'p', 'r', 'x') | | ------------------ | | | | 31| 1.26k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ | Branch (858:9): [True: 630, False: 0] ------------------ 859| 630|} qp.c:node32: 573| 3.13k|node32(dns_qpnode_t *n) { 574| 3.13k| return n->small; 575| 3.13k|} qp.c:unpack_reader: 866| 630|unpack_reader(dns_qpreader_t *qp, dns_qpnode_t *reader) { 867| 630| INSIST(reader_valid(reader)); ------------------ | | 202| 630|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 630| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 630, False: 0] | | | | ------------------ | | | | 55| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 868| 630| dns_qpmulti_t *multi = node_pointer(&reader[0]); 869| 630| dns_qpbase_t *base = node_pointer(&reader[1]); 870| 630| INSIST(QPMULTI_VALID(multi)); ------------------ | | 202| 630|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 630, False: 0] | | | | | Branch (54:11): [True: 630, False: 0] | | | | ------------------ | | | | 55| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 871| 630| INSIST(QPBASE_VALID(base)); ------------------ | | 202| 630|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 630, False: 0] | | | | | Branch (54:11): [True: 630, False: 0] | | | | ------------------ | | | | 55| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 872| 630| *qp = (dns_qpreader_t){ 873| 630| .magic = QP_MAGIC, ------------------ | | 367| 630|#define QP_MAGIC ISC_MAGIC('t', 'r', 'i', 'e') | | ------------------ | | | | 31| 630|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 874| 630| .uctx = multi->writer.uctx, 875| 630| .methods = multi->writer.methods, 876| 630| .root_ref = node32(&reader[1]), 877| 630| .base = base, 878| 630| }; 879| 630| return multi; 880| 630|} 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); ------------------ | | 198| 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| 850|leaf_qpkey(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpkey_t key) { 901| 850| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 850|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 902| 850| size_t len = qp->methods->makekey(key, qp->uctx, leaf_pval(n), 903| 850| leaf_ival(n)); 904| 850| INSIST(len < sizeof(dns_qpkey_t)); ------------------ | | 202| 850|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 850| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 850, False: 0] | | | | ------------------ | | | | 55| 850| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 905| 850| return len; 906| 850|} 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.37k|is_branch(dns_qpnode_t *n) { 611| 2.37k| return n->biglo & BRANCH_TAG; 612| 2.37k|} qp.c:prefetch_twigs: 708| 293|prefetch_twigs(dns_qpreadable_t qpr, dns_qpnode_t *n) { 709| 293| __builtin_prefetch(ref_ptr(qpr, branch_twigs_ref(n))); 710| 293|} qp.c:branch_twigs_ref: 662| 1.01k|branch_twigs_ref(dns_qpnode_t *n) { 663| 1.01k| return node32(n); 664| 1.01k|} 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| 493|branch_has_twig(dns_qpnode_t *n, dns_qpshift_t bit) { 791| 493| return branch_index(n) & (1ULL << bit); 792| 493|} qp.c:branch_twig_pos: 774| 291|branch_twig_pos(dns_qpnode_t *n, dns_qpshift_t bit) { 775| 291| return branch_count_bitmap_before(n, bit); 776| 291|} qp.c:branch_count_bitmap_before: 753| 524|branch_count_bitmap_before(dns_qpnode_t *n, dns_qpshift_t bit) { 754| 524| uint64_t mask = (1ULL << bit) - 1 - TAG_MASK; 755| 524| uint64_t bitmap = branch_index(n) & mask; 756| 524| return (dns_qpweight_t)stdc_count_ones(bitmap); ------------------ | | 30| 524|#define stdc_count_ones(x) __builtin_popcountg(x) ------------------ 757| 524|} qp.c:branch_key_offset: 683| 449|branch_key_offset(dns_qpnode_t *n) { 684| 449| return (size_t)(branch_index(n) >> SHIFT_OFFSET); 685| 449|} qp.c:branch_twig_ptr: 782| 212|branch_twig_ptr(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpshift_t bit) { 783| 212| return ref_ptr(qpr, branch_twigs_ref(n) + branch_twig_pos(n, bit)); 784| 212|} 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.46k|branch_index(dns_qpnode_t *n) { 655| 1.46k| return node64(n); 656| 1.46k|} 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| 869|get_root(dns_qpreadable_t qpr) { 719| 869| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 869|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 720| 869| if (qp->root_ref == INVALID_REF) { ------------------ | | 229| 869|#define INVALID_REF ((dns_qpref_t)~0UL) ------------------ | Branch (720:6): [True: 2, False: 867] ------------------ 721| 2| return NULL; 722| 867| } else { 723| 867| return ref_ptr(qp, qp->root_ref); 724| 867| } 725| 869|} qp.c:leaf_pval: 620| 1.50k|leaf_pval(dns_qpnode_t *n) { 621| 1.50k| return node_pointer(n); 622| 1.50k|} qp.c:leaf_ival: 628| 860|leaf_ival(dns_qpnode_t *n) { 629| 860| return node32(n); 630| 860|} qp.c:branch_twigs: 700| 277|branch_twigs(dns_qpreadable_t qpr, dns_qpnode_t *n) { 701| 277| return ref_ptr(qpr, branch_twigs_ref(n)); 702| 277|} dns__qpzone_initialize: 470| 2|dns__qpzone_initialize(void) { 471| 2.05k| for (size_t idx = 0; idx < ARRAY_SIZE(qpzone_buckets_g); ++idx) { ------------------ | | 98| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (471:23): [True: 2.04k, False: 2] ------------------ 472| 2.04k| NODE_INITLOCK(&qpzone_buckets_g[idx].lock); ------------------ | | 28| 2.04k|#define NODE_INITLOCK(l) isc_rwlock_init((l)) ------------------ 473| 2.04k| } 474| 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)); ------------------ | | 144| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); ------------------ | | 202| 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; ------------------ | | 185| 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)); ------------------ | | 144| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 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: 5686| 6| uint32_t ival ISC_ATTR_UNUSED) { 5687| 6| qpznode_t *data = pval; 5688| 6| qpznode_ref(data); 5689| 6|} qpzone.c:qp_makekey: 5700| 422| uint32_t ival ISC_ATTR_UNUSED) { 5701| 422| qpznode_t *data = pval; 5702| 422| return dns_qpkey_fromname(key, &data->name, data->nspace); 5703| 422|} qpzone.c:allocate_version: 840| 2| bool writer) { 841| 2| qpz_version_t *version = isc_mem_get(mctx, sizeof(*version)); ------------------ | | 144| 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)); ------------------ | | 144| 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: 489| 6|qpzone_get_locknum(void) { 490| 6| return isc_random_uniform(ARRAY_SIZE(qpzone_buckets_g)); ------------------ | | 98| 6|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ 491| 6|} qpzone.c:qpznode_acquire: 982| 8|qpznode_acquire(qpznode_t *node DNS__DB_FLARG) { 983| 8| qpznode_ref(node); 984| 8| qpznode_erefs_increment(node DNS__DB_FLARG_PASS); 985| 8|} qpzone.c:qpznode_erefs_increment: 971| 8|qpznode_erefs_increment(qpznode_t *node DNS__DB_FLARG) { 972| 8| uint_fast32_t refs = isc_refcount_increment0(&node->erefs); ------------------ | | 68| 8| ({ \ | | 69| 8| uint_fast32_t __v; \ | | 70| 8| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 8| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 71| 8| INSIST(__v < UINT32_MAX); \ | | ------------------ | | | | 202| 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))) | | | | ------------------ | | ------------------ | | 72| 8| __v; \ | | 73| 8| }) ------------------ 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| |#else 977| 8| UNUSED(refs); ------------------ | | 69| 8|#define UNUSED(x) (void)(x) ------------------ 978| 8|#endif 979| 8|} qpzone.c:qpzone_detachnode: 3978| 8|qpzone_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) { 3979| 8| qpznode_t *node = NULL; 3980| 8| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 3981| 8| isc_rwlock_t *nlock = NULL; 3982| | 3983| 8| REQUIRE(nodep != NULL && *nodep != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 3984| | 3985| 8| node = (qpznode_t *)(*nodep); 3986| | 3987| 8| *nodep = NULL; 3988| 8| nlock = qpzone_get_lock(node); 3989| | 3990| | /* 3991| | * qpzone_destroy() uses call_rcu() API to destroy the node locks, so it 3992| | * is safe to call it in the middle of NODE_LOCK, but we need to acquire 3993| | * the database reference to prevent destroying the database while the 3994| | * NODE_LOCK is locked. 3995| | */ 3996| | 3997| 8| rcu_read_lock(); 3998| 8| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 8|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 8| { \ | | | | 32| 8| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 8| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 8| { \ | | | | | | 31| 8| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 8| (t), __FILE__, __LINE__)); \ | | | | | | 33| 8| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 8| { \ | | | | | | | | 253| 8| switch (type) { \ | | | | | | | | 254| 8| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 8| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 8| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 8| } \ | | | | | | | | 263| 8| } | | | | | | ------------------ | | | | | | 34| 8| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 8| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 8| } | | | | ------------------ | | | | 34| 8| *tp = t; \ | | | | 35| 8| } | | ------------------ ------------------ 3999| 8| (void)qpznode_release(node DNS__DB_FLARG_PASS); 4000| 8| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 8| { \ | | 38| 8| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 8| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 8| { \ | | | | 39| 8| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 8| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 8| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 8| { \ | | | | | | 283| 8| switch (type) { \ | | | | | | 284| 8| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 8, False: 0] | | | | | | ------------------ | | | | | | 285| 8| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 8| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 8] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 8] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 8| } \ | | | | | | 293| 8| } | | | | ------------------ | | | | 42| 8| } | | ------------------ | | 40| 8| *tp = isc_rwlocktype_none; \ | | 41| 8| } ------------------ 4001| | rcu_read_unlock(); 4002| 8|} qpzone.c:qpzone_get_lock: 484| 382|qpzone_get_lock(qpznode_t *node) { 485| 382| return &qpzone_buckets_g[node->locknum].lock; 486| 382|} qpzone.c:qpznode_release: 1143| 8|qpznode_release(qpznode_t *node DNS__DB_FLARG) { 1144| 8| bool has_erefs = false; 1145| | 1146| 8| if (!qpznode_erefs_decrement(node DNS__DB_FLARG_PASS)) { ------------------ | Branch (1146:6): [True: 0, False: 8] ------------------ 1147| 0| has_erefs = true; 1148| 0| goto unref; 1149| 0| } 1150| | 1151| | /* Handle easy and typical case first. */ 1152| 8| if (!node->dirty && !ISC_SLIST_EMPTY(node->next_type)) { ------------------ | | 45| 8|#define ISC_SLIST_EMPTY(list) ((list).head == NULL) ------------------ | Branch (1152:6): [True: 8, False: 0] | Branch (1152:22): [True: 8, False: 0] ------------------ 1153| 8| has_erefs = true; 1154| 8| goto unref; 1155| 8| } 1156| | 1157| 8|unref: 1158| 8| qpznode_unref(node); 1159| 8| return has_erefs; 1160| 8|} qpzone.c:qpznode_erefs_decrement: 1116| 8|qpznode_erefs_decrement(qpznode_t *node DNS__DB_FLARG) { 1117| 8| uint_fast32_t refs = isc_refcount_decrement(&node->erefs); ------------------ | | 94| 8| ({ \ | | 95| 8| uint_fast32_t __v; \ | | 96| 8| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 8| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 8| INSIST(__v > 0); \ | | ------------------ | | | | 202| 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))) | | | | ------------------ | | ------------------ | | 98| 8| __v; \ | | 99| 8| }) ------------------ 1118| | 1119| |#if DNS_DB_NODETRACE 1120| | fprintf(stderr, "decr:node:%s:%s:%u:%p->erefs = %" PRIuFAST32 "\n", 1121| | func, file, line, node, refs - 1); 1122| |#endif 1123| 8| if (refs > 1) { ------------------ | Branch (1123:6): [True: 0, False: 8] ------------------ 1124| 0| return false; 1125| 0| } 1126| | 1127| 8| return true; 1128| 8|} qpzone.c:beginload: 2308| 2|beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 2309| 2| qpz_load_t *loadctx = NULL; 2310| 2| qpzonedb_t *qpdb = NULL; 2311| 2| qpdb = (qpzonedb_t *)db; 2312| | 2313| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2314| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2315| | 2316| 2| loadctx = isc_mem_get(qpdb->common.mctx, sizeof(*loadctx)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 2317| 2| *loadctx = (qpz_load_t){ .db = db }; 2318| | 2319| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 2320| | 2321| 2| REQUIRE((qpdb->attributes & (QPDB_ATTR_LOADED | QPDB_ATTR_LOADING)) == ------------------ | | 198| 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))) | | ------------------ ------------------ 2322| 2| 0); 2323| 2| qpdb->attributes |= QPDB_ATTR_LOADING; ------------------ | | 71| 2|#define QPDB_ATTR_LOADING 0x02 ------------------ 2324| | 2325| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 2326| | 2327| 2| callbacks->update = loading_addrdataset; 2328| 2| callbacks->setup = loading_setup; 2329| 2| callbacks->commit = loading_commit; 2330| 2| callbacks->add_private = loadctx; 2331| | 2332| 2| return ISC_R_SUCCESS; 2333| 2|} qpzone.c:loading_addrdataset: 2202| 6| dns_diffop_t op ISC_ATTR_UNUSED DNS__DB_FLARG) { 2203| 6| qpz_load_t *loadctx = arg; 2204| 6| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2205| 6| qpznode_t *node = NULL; 2206| 6| isc_result_t result = ISC_R_SUCCESS; 2207| 6| isc_region_t region; 2208| 6| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 2209| 6| isc_rwlock_t *nlock = NULL; 2210| | 2211| 6| REQUIRE(rdataset->rdclass == qpdb->common.rdclass); ------------------ | | 198| 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))) | | ------------------ ------------------ 2212| | 2213| | /* 2214| | * SOA records are only allowed at top of zone. 2215| | */ 2216| 6| if (rdataset->type == dns_rdatatype_soa && ------------------ | | 120| 12|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (2216:6): [True: 2, False: 4] ------------------ 2217| 2| !dns_name_equal(name, &qpdb->common.origin)) ------------------ | Branch (2217:6): [True: 0, False: 2] ------------------ 2218| 0| { 2219| 0| return DNS_R_NOTZONETOP; 2220| 0| } 2221| | 2222| 6| if (rdataset->type != dns_rdatatype_nsec3 && ------------------ | | 164| 12|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2222:6): [True: 6, False: 0] ------------------ 2223| 6| rdataset->covers != dns_rdatatype_nsec3) ------------------ | | 164| 6|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2223:6): [True: 6, False: 0] ------------------ 2224| 6| { 2225| 6| addwildcards(qpdb, loadctx->tree, name, DNS_DBNAMESPACE_NORMAL); 2226| 6| } 2227| | 2228| 6| if (dns_name_iswildcard(name)) { ------------------ | Branch (2228:6): [True: 0, False: 6] ------------------ 2229| 0| if (rdataset->type == dns_rdatatype_ns) { ------------------ | | 116| 0|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (2229:7): [True: 0, False: 0] ------------------ 2230| | /* 2231| | * NS owners cannot legally be wild cards. 2232| | */ 2233| 0| return DNS_R_INVALIDNS; 2234| 0| } 2235| | 2236| 0| if (rdataset->type == dns_rdatatype_nsec3) { ------------------ | | 164| 0|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2236:7): [True: 0, False: 0] ------------------ 2237| | /* 2238| | * NSEC3 owners cannot legally be wild cards. 2239| | */ 2240| 0| return DNS_R_INVALIDNSEC3; 2241| 0| } 2242| | 2243| 0| wildcardmagic(qpdb, loadctx->tree, name, 2244| 0| DNS_DBNAMESPACE_NORMAL); 2245| 0| } 2246| | 2247| 6| loading_addnode(loadctx, name, rdataset->type, rdataset->covers, &node); 2248| 6| result = dns_rdatavec_fromrdataset(rdataset, node->mctx, ®ion, 2249| 6| qpdb->maxrrperset); 2250| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2250:6): [True: 0, False: 6] ------------------ 2251| 0| if (result == DNS_R_TOOMANYRECORDS) { ------------------ | Branch (2251:7): [True: 0, False: 0] ------------------ 2252| 0| dns__db_logtoomanyrecords((dns_db_t *)qpdb, name, 2253| 0| rdataset->type, "adding", 2254| 0| qpdb->maxrrperset); 2255| 0| } 2256| 0| return result; 2257| 0| } 2258| | 2259| 6| dns_vecheader_t *newheader = (dns_vecheader_t *)region.base; 2260| 6| newheader->ttl = rdataset->ttl; 2261| 6| newheader->serial = 1; 2262| 6| atomic_store_release(&newheader->trust, rdataset->trust); ------------------ | | 49| 6| atomic_store_explicit((o), (v), memory_order_release) ------------------ 2263| | 2264| 6| dns_vecheader_setownercase(newheader, name); 2265| | 2266| 6| if (rdataset->attributes.resign) { ------------------ | Branch (2266:6): [True: 0, False: 6] ------------------ 2267| 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) | | ------------------ ------------------ 2268| 0| newheader->resign = dns_time64_from32(rdataset->resign); 2269| 0| } 2270| | 2271| 6| nlock = qpzone_get_lock(node); 2272| 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(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 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| } | | ------------------ ------------------ 2273| 6| result = add(qpdb, node, name, qpdb->current_version, newheader, 2274| 6| DNS_DBADD_MERGE, true, NULL, 0 DNS__DB_FLARG_PASS); ------------------ | | 297| 6|#define DNS_DBADD_MERGE 0x01 ------------------ 2275| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 2276| | 2277| 6| if (result == ISC_R_SUCCESS && ------------------ | Branch (2277:6): [True: 6, False: 0] ------------------ 2278| 6| delegating_type(qpdb, node, rdataset->type)) ------------------ | Branch (2278:6): [True: 0, False: 6] ------------------ 2279| 0| { 2280| 0| node->delegating = true; 2281| 6| } else if (result == DNS_R_UNCHANGED) { ------------------ | Branch (2281:13): [True: 0, False: 6] ------------------ 2282| 0| result = ISC_R_SUCCESS; 2283| 0| } 2284| | 2285| 6| return result; 2286| 6|} qpzone.c:addwildcards: 2182| 6| dns_namespace_t nspace) { 2183| 6| dns_name_t foundname; 2184| 6| unsigned int n, l, i; 2185| | 2186| 6| dns_name_init(&foundname); 2187| 6| n = dns_name_countlabels(name); 2188| 6| l = dns_name_countlabels(&qpdb->common.origin); 2189| 6| i = l + 1; 2190| 6| while (i < n) { ------------------ | Branch (2190:9): [True: 0, False: 6] ------------------ 2191| 0| dns_name_getlabelsequence(name, n - i, i, &foundname); 2192| 0| if (dns_name_iswildcard(&foundname)) { ------------------ | Branch (2192:7): [True: 0, False: 0] ------------------ 2193| 0| wildcardmagic(qpdb, qp, &foundname, nspace); 2194| 0| } 2195| | 2196| 0| i++; 2197| 0| } 2198| 6|} qpzone.c:loading_addnode: 1759| 6| qpznode_t **nodep) { 1760| 6| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 1761| 6| isc_result_t result; 1762| 6| qpznode_t *node = NULL, *nsecnode = NULL; 1763| | 1764| 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 (1764:6): [True: 0, False: 6] | Branch (1764:37): [True: 0, False: 6] ------------------ 1765| 0| result = dns_qp_getname(loadctx->tree, name, 1766| 0| DNS_DBNAMESPACE_NSEC3, (void **)&node, 1767| 0| NULL); 1768| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1768:7): [True: 0, False: 0] ------------------ 1769| 0| *nodep = node; 1770| 0| } else { 1771| 0| node = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NSEC3); 1772| 0| result = dns_qp_insert(loadctx->tree, node, 0); 1773| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 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))) | | ------------------ ------------------ 1774| 0| *nodep = node; 1775| 0| qpznode_detach(&node); 1776| 0| } 1777| 0| return; 1778| 0| } 1779| | 1780| 6| result = dns_qp_getname(loadctx->tree, name, DNS_DBNAMESPACE_NORMAL, 1781| 6| (void **)&node, NULL); 1782| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1782:6): [True: 6, False: 0] ------------------ 1783| 6| if (type == dns_rdatatype_nsec && node->havensec) { ------------------ | | 161| 12|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1783:7): [True: 0, False: 6] | Branch (1783:37): [True: 0, False: 0] ------------------ 1784| 0| goto done; 1785| 0| } 1786| 6| } else { 1787| 0| INSIST(node == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 1788| 0| node = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NORMAL); 1789| 0| result = dns_qp_insert(loadctx->tree, node, 0); 1790| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 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))) | | ------------------ ------------------ 1791| 0| qpznode_unref(node); 1792| 0| } 1793| 6| if (type != dns_rdatatype_nsec) { ------------------ | | 161| 6|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1793:6): [True: 6, False: 0] ------------------ 1794| 6| goto done; 1795| 6| } 1796| | 1797| | /* 1798| | * We're adding an NSEC record, so create a node in the nsec tree 1799| | * too. This tree speeds searches for closest NSECs that would 1800| | * otherwise need to examine many irrelevant nodes in large TLDs. 1801| | * If dns_qp_insert() fails, it means there's already an NSEC 1802| | * node there, so we can just detach the new one we created and 1803| | * move on. 1804| | */ 1805| 0| node->havensec = true; 1806| 0| nsecnode = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NSEC); 1807| 0| (void)dns_qp_insert(loadctx->tree, nsecnode, 0); 1808| 0| qpznode_detach(&nsecnode); 1809| | 1810| 6|done: 1811| 6| *nodep = node; 1812| 6|} qpzone.c:add: 1897| 6| isc_stdtime_t now ISC_ATTR_UNUSED DNS__DB_FLARG) { 1898| 6| qpz_changed_t *changed = NULL; 1899| 6| dns_vectop_t *foundtop = NULL; 1900| 6| dns_vectop_t *priotop = NULL; 1901| 6| dns_vecheader_t *merged = NULL; 1902| 6| isc_result_t result; 1903| 6| bool merge = false; 1904| 6| uint32_t ntypes; 1905| | 1906| 6| if ((options & DNS_DBADD_MERGE) != 0) { ------------------ | | 297| 6|#define DNS_DBADD_MERGE 0x01 ------------------ | Branch (1906:6): [True: 6, False: 0] ------------------ 1907| 6| REQUIRE(version != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1908| 6| merge = true; 1909| 6| } 1910| | 1911| 6| if (!loading) { ------------------ | Branch (1911:6): [True: 0, False: 6] ------------------ 1912| | /* 1913| | * We always add a changed record, even if no changes end up 1914| | * being made to this node, because it's harmless and 1915| | * simplifies the code. 1916| | */ 1917| 0| changed = add_changed(qpdb, node, version DNS__DB_FLARG_PASS); 1918| 0| } 1919| | 1920| 6| ntypes = 0; 1921| 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] | | | | ------------------ | | ------------------ ------------------ 1922| 6| ++ntypes; 1923| 6| if (prio_type(top->typepair)) { ------------------ | Branch (1923:7): [True: 2, False: 4] ------------------ 1924| 2| priotop = top; 1925| 2| } 1926| 6| if (top->typepair == newheader->typepair) { ------------------ | Branch (1926:7): [True: 0, False: 6] ------------------ 1927| 0| foundtop = top; 1928| 0| break; 1929| 0| } 1930| 6| } 1931| | 1932| | /* 1933| | * If topheader isn't NULL, we've found the right type. There may be 1934| | * IGNORE rdatasets between the top of the chain and the first real 1935| | * data. We skip over them. 1936| | */ 1937| 6| dns_vecheader_t **header_p = NULL; 1938| 6| dns_vecheader_t *header = NULL; 1939| 6| if (foundtop != NULL) { ------------------ | Branch (1939:6): [True: 0, False: 6] ------------------ 1940| 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] | | ------------------ ------------------ 1941| 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 (1941:8): [True: 0, False: 0] ------------------ 1942| 0| header_p = p; 1943| 0| header = *p; 1944| 0| break; 1945| 0| } 1946| 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) | | ------------------ ------------------ 1947| 0| } 1948| 0| } 1949| | 1950| 6| if (header != NULL) { ------------------ | Branch (1950:6): [True: 0, False: 6] ------------------ 1951| | /* 1952| | * If 'merge' is true and header isn't empty/nonexistent, 1953| | * we'll try to create a new rdataset that is the union 1954| | * of 'newheader' and 'header'. 1955| | */ 1956| 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 (1956:7): [True: 0, False: 0] ------------------ 1957| 0| unsigned int flags = 0; 1958| 0| INSIST(version->serial >= header->serial); ------------------ | | 202| 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))) | | ------------------ ------------------ 1959| 0| merged = NULL; 1960| 0| result = ISC_R_SUCCESS; 1961| | 1962| 0| if ((options & DNS_DBADD_EXACT) != 0) { ------------------ | | 299| 0|#define DNS_DBADD_EXACT 0x04 ------------------ | Branch (1962:8): [True: 0, False: 0] ------------------ 1963| 0| flags |= DNS_RDATAVEC_EXACT; ------------------ | | 57| 0|#define DNS_RDATAVEC_EXACT 0x2 ------------------ 1964| 0| } 1965| 0| if ((options & DNS_DBADD_EXACTTTL) != 0 && ------------------ | | 300| 0|#define DNS_DBADD_EXACTTTL 0x08 ------------------ | Branch (1965:8): [True: 0, False: 0] ------------------ 1966| 0| newheader->ttl != header->ttl) ------------------ | Branch (1966:8): [True: 0, False: 0] ------------------ 1967| 0| { 1968| 0| result = DNS_R_NOTEXACT; 1969| 0| } else if (newheader->ttl != header->ttl) { ------------------ | Branch (1969:15): [True: 0, False: 0] ------------------ 1970| 0| flags |= DNS_RDATAVEC_FORCE; ------------------ | | 56| 0|#define DNS_RDATAVEC_FORCE 0x1 ------------------ 1971| 0| } 1972| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1972:8): [True: 0, False: 0] ------------------ 1973| 0| result = dns_rdatavec_merge( 1974| 0| header, newheader, qpdb->common.mctx, 1975| 0| qpdb->common.rdclass, 1976| 0| DNS_TYPEPAIR_TYPE(header->typepair), ------------------ | | 29| 0| ({ \ | | 30| 0| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 31| 0| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 32| 0| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 0|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 33| 0| __base; \ | | 34| 0| }) ------------------ 1977| 0| flags, qpdb->maxrrperset, &merged); 1978| 0| } 1979| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1979:8): [True: 0, False: 0] ------------------ 1980| | /* 1981| | * If 'header' has the same serial number as 1982| | * we do, we could clean it up now if we knew 1983| | * that our caller had no references to it. 1984| | * We don't know this, however, so we leave it 1985| | * alone. It will get cleaned up when 1986| | * clean_zone_node() runs. 1987| | */ 1988| 0| dns_vecheader_unref(newheader); 1989| 0| newheader = merged; 1990| | /* 1991| | * dns_rdatavec_subtract takes the header from 1992| | * the first argument, so it preserves the case 1993| | */ 1994| 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 (1994:9): [True: 0, False: 0] ------------------ 1995| 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) ------------------ 1996| 0| resign_sooner_values(header->resign, ------------------ | Branch (1996:9): [True: 0, False: 0] ------------------ 1997| 0| header->typepair, 1998| 0| newheader->resign, 1999| 0| newheader->typepair)) 2000| 0| { 2001| 0| newheader->resign = header->resign; 2002| 0| } 2003| 0| } else { 2004| 0| if (result == DNS_R_TOOMANYRECORDS) { ------------------ | Branch (2004:9): [True: 0, False: 0] ------------------ 2005| 0| dns__db_logtoomanyrecords( 2006| 0| (dns_db_t *)qpdb, nodename, 2007| 0| DNS_TYPEPAIR_TYPE( ------------------ | | 29| 0| ({ \ | | 30| 0| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 31| 0| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 32| 0| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 0|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 33| 0| __base; \ | | 34| 0| }) ------------------ 2008| 0| header->typepair), 2009| 0| "updating", qpdb->maxrrperset); 2010| 0| } 2011| 0| dns_vecheader_unref(newheader); 2012| 0| return result; 2013| 0| } 2014| 0| } 2015| | 2016| 0| INSIST(version->serial >= header->serial); ------------------ | | 202| 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))) | | ------------------ ------------------ 2017| 0| INSIST(foundtop->typepair == newheader->typepair); ------------------ | | 202| 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))) | | ------------------ ------------------ 2018| | 2019| 0| if (loading) { ------------------ | Branch (2019:7): [True: 0, False: 0] ------------------ 2020| 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) ------------------ 2021| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2022| 0| resign_register(qpdb->heap, node, newheader); 2023| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2024| | /* resigndelete not needed here */ 2025| 0| } 2026| | 2027| | /* 2028| | * There are no other references to 'header' when 2029| | * loading, so we MAY clean up 'header' now. 2030| | * Since we don't generate changed records when 2031| | * loading, we MUST clean up 'header' now. 2032| | */ 2033| 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) | | ------------------ ------------------ 2034| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2035| 0| next_header); 2036| 0| maybe_update_recordsandsize(false, version, header, 2037| 0| nodename->length); 2038| | 2039| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2040| 0| resign_unregister(qpdb->heap, node, header); 2041| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2042| 0| dns_vecheader_unref(header); 2043| 0| } else { 2044| 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) ------------------ 2045| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2046| 0| resign_register(qpdb->heap, node, newheader); 2047| 0| resign_unregister(qpdb->heap, node, header); 2048| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2049| 0| resign_rollback(qpdb, node, version, 2050| 0| header DNS__DB_FLARG_PASS); 2051| 0| } 2052| | 2053| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2054| 0| next_header); 2055| | 2056| 0| node->dirty = true; 2057| 0| if (changed != NULL) { ------------------ | Branch (2057:8): [True: 0, False: 0] ------------------ 2058| 0| changed->dirty = true; 2059| 0| } 2060| 0| maybe_update_recordsandsize(false, version, header, 2061| 0| nodename->length); 2062| 0| } 2063| 6| } else { 2064| | /* 2065| | * No non-IGNORED rdatasets of the given type exist at 2066| | * this node. 2067| | * 2068| | * If we're trying to delete the type, don't bother. 2069| | */ 2070| 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 (2070:7): [True: 0, False: 6] ------------------ 2071| 0| dns_vecheader_unref(newheader); 2072| 0| return DNS_R_UNCHANGED; 2073| 0| } 2074| | 2075| 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) ------------------ 2076| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2077| 0| resign_register(qpdb->heap, node, newheader); 2078| 0| resign_unregister(qpdb->heap, node, header); 2079| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2080| 0| resign_rollback(qpdb, node, version, 2081| 0| header DNS__DB_FLARG_PASS); 2082| 0| } 2083| | 2084| 6| if (foundtop != NULL) { ------------------ | Branch (2084:7): [True: 0, False: 6] ------------------ 2085| | /* 2086| | * We have a list of rdatasets of the given type, 2087| | * but they're all marked IGNORE. We simply insert 2088| | * the new rdataset at the head of the list. 2089| | * 2090| | * Ignored rdatasets cannot occur during loading, so 2091| | * we INSIST on it. 2092| | */ 2093| 0| INSIST(!loading); ------------------ | | 202| 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))) | | ------------------ ------------------ 2094| | 2095| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2096| 0| next_header); 2097| | 2098| 0| if (changed != NULL) { ------------------ | Branch (2098:8): [True: 0, False: 0] ------------------ 2099| 0| changed->dirty = true; 2100| 0| } 2101| 0| node->dirty = true; 2102| 6| } else { 2103| | /* 2104| | * No rdatasets of the given type exist at the node. 2105| | */ 2106| | 2107| 6| if (qpdb->maxtypepername > 0 && ------------------ | Branch (2107:8): [True: 0, False: 6] ------------------ 2108| 0| ntypes >= qpdb->maxtypepername) ------------------ | Branch (2108:8): [True: 0, False: 0] ------------------ 2109| 0| { 2110| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 2111| 0| resign_unregister(qpdb->heap, node, newheader); 2112| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 2113| 0| dns_vecheader_unref(newheader); 2114| 0| return DNS_R_TOOMANYRECORDS; 2115| 0| } 2116| | 2117| 6| dns_vectop_t *newtop = 2118| 6| dns_vectop_new(node->mctx, newheader->typepair); 2119| | 2120| 6| ISC_SLIST_PREPEND(newtop->headers, newheader, ------------------ | | 48| 6| ({ \ | | 49| 6| (elt)->link.next = (list).head; \ | | 50| 6| (list).head = (elt); \ | | 51| 6| }) ------------------ 2121| 6| next_header); 2122| | 2123| 6| if (prio_type(newheader->typepair)) { ------------------ | Branch (2123:8): [True: 4, False: 2] ------------------ 2124| | /* This is a priority type, prepend it */ 2125| 4| ISC_SLIST_PREPEND(node->next_type, newtop, ------------------ | | 48| 4| ({ \ | | 49| 4| (elt)->link.next = (list).head; \ | | 50| 4| (list).head = (elt); \ | | 51| 4| }) ------------------ 2126| 4| next_type); 2127| 4| } else if (priotop != NULL) { ------------------ | Branch (2127:15): [True: 0, False: 2] ------------------ 2128| | /* Append after the priority headers */ 2129| 0| ISC_SLIST_INSERTAFTER(priotop, newtop, ------------------ | | 54| 0| ({ \ | | 55| 0| (elt)->link.next = (after)->link.next; \ | | 56| 0| (after)->link.next = (elt); \ | | 57| 0| }) ------------------ 2130| 0| next_type); 2131| 2| } else { 2132| | /* There were no priority headers */ 2133| 2| ISC_SLIST_PREPEND(node->next_type, newtop, ------------------ | | 48| 2| ({ \ | | 49| 2| (elt)->link.next = (list).head; \ | | 50| 2| (list).head = (elt); \ | | 51| 2| }) ------------------ 2134| 2| next_type); 2135| 2| } 2136| 6| } 2137| 6| } 2138| | 2139| 6| maybe_update_recordsandsize(true, version, newheader, nodename->length); 2140| | 2141| | /* 2142| | * Check if the node now contains CNAME and other data. 2143| | */ 2144| 6| if (cname_and_other(node, version->serial)) { ------------------ | Branch (2144:6): [True: 0, False: 6] ------------------ 2145| 0| return DNS_R_CNAMEANDOTHER; 2146| 0| } 2147| | 2148| 6| bindrdataset(qpdb, newheader, addedrdataset DNS__DB_FLARG_PASS); 2149| | 2150| 6| return ISC_R_SUCCESS; 2151| 6|} qpzone.c:maybe_update_recordsandsize: 1877| 6| dns_vecheader_t *header, unsigned int namelen) { 1878| 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 (1878:6): [True: 0, False: 6] ------------------ 1879| 0| return; 1880| 0| } 1881| | 1882| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1883| 12| if (add) { ------------------ | Branch (1883:6): [True: 6, False: 0] ------------------ 1884| 6| version->records += dns_rdatavec_count(header); 1885| 6| version->xfrsize += recordsize(header, namelen); 1886| 6| } else { 1887| 0| version->records -= dns_rdatavec_count(header); 1888| 0| version->xfrsize -= recordsize(header, namelen); 1889| 0| } 1890| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1891| 6|} qpzone.c:recordsize: 1870| 6|recordsize(dns_vecheader_t *header, unsigned int namelen) { 1871| 6| return dns_rdatavec_size(header) + sizeof(dns_ttl_t) + 1872| 6| sizeof(dns_rdatatype_t) + sizeof(dns_rdataclass_t) + namelen; 1873| 6|} qpzone.c:cname_and_other: 1815| 6|cname_and_other(qpznode_t *node, uint32_t serial) { 1816| 6| bool cname = false, other = false; 1817| | 1818| | /* 1819| | * Look for CNAME and "other data" rdatasets active in our version. 1820| | * ("Other data" is any rdataset whose type is not KEY, NSEC, SIG 1821| | * or RRSIG. 1822| | */ 1823| 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] | | | | ------------------ | | ------------------ ------------------ 1824| 12| dns_rdatatype_t rdtype = DNS_TYPEPAIR_TYPE(top->typepair); ------------------ | | 29| 12| ({ \ | | 30| 12| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 31| 12| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 32| 12| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 12|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 33| 12| __base; \ | | 34| 12| }) ------------------ 1825| 12| if (rdtype == dns_rdatatype_cname) { ------------------ | | 119| 12|#define dns_rdatatype_cname ((dns_rdatatype_t)dns_rdatatype_cname) ------------------ | Branch (1825:7): [True: 0, False: 12] ------------------ 1826| 0| if (first_existing_header(top, serial) != NULL) { ------------------ | Branch (1826:8): [True: 0, False: 0] ------------------ 1827| 0| cname = true; 1828| 0| } 1829| 12| } else if (rdtype != dns_rdatatype_nsec && ------------------ | | 161| 24|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1829:14): [True: 12, False: 0] ------------------ 1830| 12| rdtype != dns_rdatatype_rrsig) ------------------ | | 160| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1830:7): [True: 12, False: 0] ------------------ 1831| 12| { 1832| 12| if (first_existing_header(top, serial) != NULL) { ------------------ | Branch (1832:8): [True: 12, False: 0] ------------------ 1833| 12| if (!prio_type(rdtype)) { ------------------ | Branch (1833:9): [True: 6, False: 6] ------------------ 1834| | /* 1835| | * CNAME is in the priority list, so if 1836| | * we are done with priority types, we 1837| | * know there will not be a CNAME, and 1838| | * are safe to skip the rest. 1839| | */ 1840| 6| return cname; 1841| 6| } 1842| 6| other = true; 1843| 6| } 1844| 12| } 1845| | 1846| 6| if (cname && other) { ------------------ | Branch (1846:7): [True: 0, False: 6] | Branch (1846:16): [True: 0, False: 0] ------------------ 1847| 0| return true; 1848| 0| } 1849| 6| } 1850| | 1851| 0| return false; 1852| 6|} qpzone.c:first_existing_header: 993| 500|first_existing_header(dns_vectop_t *top, uint32_t serial) { 994| 500| ISC_SLIST_FOREACH(header, top->headers, next_header) { ------------------ | | 70| 500| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 500| for (typeof(first) elt = first, \ | | | | 64| 500| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 500|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 500, False: 0] | | | | ------------------ | | | | 65| 500| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 500, False: 0] | | | | ------------------ | | | | 66| 500| 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] | | | | ------------------ | | ------------------ ------------------ 995| 500| if (header->serial <= serial && !IGNORE(header)) { ------------------ | | 30| 500| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 500|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 31| 500| DNS_VECHEADERATTR_IGNORE) != 0) ------------------ | Branch (995:7): [True: 500, False: 0] | Branch (995:35): [True: 500, False: 0] ------------------ 996| 500| if (EXISTS(header)) { ------------------ | | 27| 500| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 500|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (27:2): [True: 500, False: 0] | | ------------------ | | 28| 500| DNS_VECHEADERATTR_NONEXISTENT) == 0) ------------------ 997| 500| return header; 998| 500| } 999| 0| break; 1000| 500| } 1001| 500| } 1002| 0| return NULL; 1003| 500|} qpzone.c:bindrdataset: 1164| 133| dns_rdataset_t *rdataset DNS__DB_FLARG) { 1165| 133| if (rdataset == NULL) { ------------------ | Branch (1165:6): [True: 6, False: 127] ------------------ 1166| 6| return; 1167| 6| } 1168| | 1169| 127| INSIST(rdataset->methods == NULL); /* We must be disassociated. */ ------------------ | | 202| 127|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 127| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 127, False: 0] | | | | ------------------ | | | | 55| 127| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1170| | 1171| 127| rdataset->methods = &dns_rdatavec_rdatasetmethods; 1172| 127| rdataset->rdclass = qpdb->common.rdclass; 1173| 127| rdataset->type = DNS_TYPEPAIR_TYPE(header->typepair); ------------------ | | 29| 127| ({ \ | | 30| 127| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 31| 127| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 32| 127| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 127|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 33| 127| __base; \ | | 34| 127| }) ------------------ 1174| 127| rdataset->covers = DNS_TYPEPAIR_COVERS(header->typepair); ------------------ | | 36| 127| ({ \ | | 37| 127| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 38| 127| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 39| 127| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 127|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 40| 127| __covers; \ | | 41| 127| }) ------------------ 1175| 127| rdataset->ttl = header->ttl; 1176| 127| rdataset->trust = atomic_load_acquire(&header->trust); ------------------ | | 50| 127|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 1177| | 1178| 127| if (OPTOUT(header)) { ------------------ | | 33| 127| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 127|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 127] | | ------------------ | | 34| 127| DNS_VECHEADERATTR_OPTOUT) != 0) ------------------ 1179| 0| rdataset->attributes.optout = true; 1180| 0| } 1181| | 1182| 127| rdataset->vec.header = header; 1183| 127| dns_vecheader_ref(header); 1184| 127| rdataset->vec.iter.iter_pos = NULL; 1185| 127| rdataset->vec.iter.iter_count = 0; 1186| | 1187| | /* 1188| | * Add noqname proof. 1189| | */ 1190| | 1191| | /* 1192| | * Copy out re-signing information. 1193| | */ 1194| 127| if (RESIGN(header)) { ------------------ | | 36| 127| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 127|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (36:2): [True: 0, False: 127] | | ------------------ | | 37| 127| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 1195| 0| rdataset->attributes.resign = true; 1196| 0| rdataset->resign = header->resign; 1197| 127| } else { 1198| 127| rdataset->resign = 0; 1199| 127| } 1200| 127|} qpzone.c:delegating_type: 1750| 6|delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t typepair) { 1751| 6| return typepair == DNS_TYPEPAIR(dns_rdatatype_dname) || ------------------ | | 51| 6|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (1751:9): [True: 0, False: 6] ------------------ 1752| 6| (typepair == DNS_TYPEPAIR(dns_rdatatype_ns) && ------------------ | | 51| 6|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 12| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 12| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (1752:10): [True: 2, False: 4] ------------------ 1753| 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 (1753:4): [True: 0, False: 2] ------------------ 1754| 6|} qpzone.c:loading_setup: 2289| 2|loading_setup(void *arg) { 2290| 2| qpz_load_t *loadctx = arg; 2291| 2| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2292| | 2293| 2| dns_qpmulti_write(qpdb->tree, &loadctx->tree); 2294| 2|} qpzone.c:loading_commit: 2297| 2|loading_commit(void *arg) { 2298| 2| qpz_load_t *loadctx = arg; 2299| 2| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2300| | 2301| 2| if (loadctx->tree != NULL) { ------------------ | Branch (2301:6): [True: 2, False: 0] ------------------ 2302| 2| dns_qp_compact(loadctx->tree, DNS_QPGC_MAYBE); 2303| 2| dns_qpmulti_commit(qpdb->tree, &loadctx->tree); 2304| 2| } 2305| 2|} qpzone.c:endload: 2336| 2|endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 2337| 2| qpz_load_t *loadctx = NULL; 2338| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2339| | 2340| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2341| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2342| 2| loadctx = callbacks->add_private; 2343| 2| REQUIRE(loadctx != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 2344| 2| REQUIRE(loadctx->db == db); ------------------ | | 198| 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))) | | ------------------ ------------------ 2345| | 2346| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 2347| | 2348| 2| REQUIRE((qpdb->attributes & QPDB_ATTR_LOADING) != 0); ------------------ | | 198| 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))) | | ------------------ ------------------ 2349| 2| REQUIRE((qpdb->attributes & QPDB_ATTR_LOADED) == 0); ------------------ | | 198| 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))) | | ------------------ ------------------ 2350| | 2351| 2| qpdb->attributes &= ~QPDB_ATTR_LOADING; ------------------ | | 71| 2|#define QPDB_ATTR_LOADING 0x02 ------------------ 2352| 2| qpdb->attributes |= QPDB_ATTR_LOADED; ------------------ | | 70| 2|#define QPDB_ATTR_LOADED 0x01 ------------------ 2353| | 2354| 2| if (qpdb->origin != NULL) { ------------------ | Branch (2354:6): [True: 2, False: 0] ------------------ 2355| 2| qpz_version_t *version = qpdb->current_version; 2356| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 2357| 2| setsecure(db, version, (dns_dbnode_t *)qpdb->origin); 2358| 2| } else { 2359| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 2360| 0| } 2361| | 2362| 2| callbacks->update = NULL; 2363| 2| callbacks->setup = NULL; 2364| 2| callbacks->commit = NULL; 2365| 2| callbacks->add_private = NULL; 2366| | 2367| 2| isc_mem_put(qpdb->common.mctx, loadctx, sizeof(*loadctx)); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 2] | | ------------------ ------------------ 2368| | 2369| 2| return ISC_R_SUCCESS; 2370| 2|} qpzone.c:setsecure: 1290| 2|setsecure(dns_db_t *db, qpz_version_t *version, dns_dbnode_t *origin) { 1291| 2| dns_rdataset_t keyset; 1292| 2| dns_rdataset_t nsecset, signsecset; 1293| 2| bool haszonekey = false; 1294| 2| bool hasnsec = false; 1295| 2| isc_result_t result; 1296| | 1297| 2| version->secure = false; 1298| 2| version->havensec3 = false; 1299| | 1300| 2| dns_rdataset_init(&keyset); 1301| 2| result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version, ------------------ | | 1119| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 2| sigrdataset DNS__DB_FILELINE) ------------------ 1302| 2| dns_rdatatype_dnskey, 0, 0, &keyset, NULL); 1303| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1303:6): [True: 0, False: 2] ------------------ 1304| 0| haszonekey = dns_dnssec_haszonekey(&keyset); 1305| 0| dns_rdataset_disassociate(&keyset); ------------------ | | 301| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1306| 0| } 1307| 2| if (!haszonekey) { ------------------ | Branch (1307:6): [True: 2, False: 0] ------------------ 1308| 2| return; 1309| 2| } 1310| | 1311| 0| dns_rdataset_init(&nsecset); 1312| 0| dns_rdataset_init(&signsecset); 1313| 0| result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version, ------------------ | | 1119| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 0| sigrdataset DNS__DB_FILELINE) ------------------ 1314| 0| dns_rdatatype_nsec, 0, 0, &nsecset, 1315| 0| &signsecset); 1316| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1316:6): [True: 0, False: 0] ------------------ 1317| 0| if (dns_rdataset_isassociated(&signsecset)) { ------------------ | Branch (1317:7): [True: 0, False: 0] ------------------ 1318| 0| hasnsec = true; 1319| 0| dns_rdataset_disassociate(&signsecset); ------------------ | | 301| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1320| 0| } 1321| 0| dns_rdataset_disassociate(&nsecset); ------------------ | | 301| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1322| 0| } 1323| | 1324| 0| setnsec3parameters(db, version); 1325| | 1326| | /* 1327| | * If we don't have a valid NSEC/NSEC3 chain, 1328| | * clear the secure flag. 1329| | */ 1330| 0| if (version->havensec3 || hasnsec) { ------------------ | Branch (1330:6): [True: 0, False: 0] | Branch (1330:28): [True: 0, False: 0] ------------------ 1331| | version->secure = true; 1332| 0| } 1333| 0|} qpzone.c:begin_transaction: 2580| 6|begin_transaction(qpzonedb_t *qpdb, dns_qpread_t *qprp, bool create) { 2581| 6| dns_qp_t *qp = NULL; 2582| | 2583| 6| if (create) { ------------------ | Branch (2583:6): [True: 0, False: 6] ------------------ 2584| 0| dns_qpmulti_write(qpdb->tree, &qp); 2585| 6| } else { 2586| 6| dns_qpmulti_query(qpdb->tree, qprp); 2587| 6| qp = (dns_qp_t *)qprp; 2588| 6| } 2589| | 2590| 6| return qp; 2591| 6|} qpzone.c:findnodeintree: 2606| 6| bool create, bool nsec3, dns_dbnode_t **nodep DNS__DB_FLARG) { 2607| 6| isc_result_t result; 2608| 6| qpznode_t *node = NULL; 2609| 6| dns_namespace_t nspace = nsec3 ? DNS_DBNAMESPACE_NSEC3 ------------------ | Branch (2609:27): [True: 0, False: 6] ------------------ 2610| 6| : DNS_DBNAMESPACE_NORMAL; 2611| | /* 2612| | * findnodeintree is a wrapper around dns_qp_getname that does some 2613| | * qpzone-specific bookkeeping before returning the lookup result to the 2614| | * caller. 2615| | * 2616| | * First, we do a lookup ... 2617| | */ 2618| 6| result = dns_qp_getname(qp, name, nspace, (void **)&node, NULL); 2619| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (2619:6): [True: 6, False: 0] ------------------ 2620| | /* 2621| | * ... if the lookup is successful, we need to increase both the 2622| | * internal and external reference count before returning to 2623| | * the caller. qpznode_acquire takes care of that. 2624| | */ 2625| 6| qpznode_acquire(node DNS__DB_FLARG_PASS); 2626| | 2627| 6| INSIST(node->nspace == DNS_DBNAMESPACE_NSEC3 || !nsec3); ------------------ | | 202| 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))) | | ------------------ ------------------ 2628| 6| } else if (result != ISC_R_SUCCESS && create) { ------------------ | Branch (2628:13): [True: 0, False: 0] | Branch (2628:40): [True: 0, False: 0] ------------------ 2629| | /* 2630| | * ... if the lookup is unsuccessful, but the caller asked us to 2631| | * create a new node, create one and insert it into the tree. 2632| | */ 2633| 0| node = new_qpznode(qpdb, name, nspace); 2634| 0| result = dns_qp_insert(qp, node, 0); 2635| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 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))) | | ------------------ ------------------ 2636| | 2637| | /* 2638| | * The new node now has two internal references: 2639| | * - One from new_qpznode, that initializes references at 1. 2640| | * - One from attach_leaf, that increases the reference by 2641| | * one at insertion in the qp-tree. 2642| | * We want the node to have two internal and one external 2643| | * reference: 2644| | * - One internal reference from the qp-tree. 2645| | * - One internal and one external reference from the caller. 2646| | * 2647| | * So we increase the external reference count by one. 2648| | */ 2649| 0| qpznode_erefs_increment(node DNS__DB_FLARG_PASS); 2650| | 2651| 0| if (!nsec3) { ------------------ | Branch (2651:7): [True: 0, False: 0] ------------------ 2652| | /* 2653| | * Add empty non-terminal nodes to help with wildcards. 2654| | */ 2655| 0| addwildcards(qpdb, qp, name, nspace); 2656| 0| if (dns_name_iswildcard(name)) { ------------------ | Branch (2656:8): [True: 0, False: 0] ------------------ 2657| 0| wildcardmagic(qpdb, qp, name, nspace); 2658| 0| } 2659| 0| } 2660| | 2661| 0| INSIST(node->nspace == DNS_DBNAMESPACE_NSEC3 || !nsec3); ------------------ | | 202| 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))) | | ------------------ ------------------ 2662| 0| } 2663| | /* 2664| | * ... if the lookup is unsuccessful, and the caller didn't ask us 2665| | * to create a new node, there is nothing to do. Return the result 2666| | * of the lookup to the caller, and set *nodep to NULL 2667| | */ 2668| | 2669| 6| *nodep = (dns_dbnode_t *)node; 2670| | 2671| 6| return result; 2672| 6|} qpzone.c:end_transaction: 2594| 6|end_transaction(qpzonedb_t *qpdb, dns_qp_t *qp, bool create) { 2595| 6| if (create) { ------------------ | Branch (2595:6): [True: 0, False: 6] ------------------ 2596| 0| dns_qp_compact(qp, DNS_QPGC_MAYBE); 2597| 0| dns_qpmulti_commit(qpdb->tree, &qp); 2598| 6| } else { 2599| 6| dns_qpread_t *qprp = (dns_qpread_t *)qp; 2600| 6| dns_qpread_destroy(qpdb->tree, qprp); 2601| 6| } 2602| 6|} qpzone.c:currentversion: 1336| 210|currentversion(dns_db_t *db, dns_dbversion_t **versionp) { 1337| 210| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1338| 210| qpz_version_t *version = NULL; 1339| | 1340| 210| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 210|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 420| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 210, False: 0] | | | | | Branch (42:11): [True: 210, False: 0] | | | | ------------------ | | | | 43| 210| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1341| | 1342| 210| RWLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 30| 210| { \ | | 31| 210| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 210| (t), __FILE__, __LINE__)); \ | | 33| 210| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 210| { \ | | | | 253| 210| switch (type) { \ | | | | 254| 210| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 210, False: 0] | | | | ------------------ | | | | 255| 210| isc_rwlock_rdlock(rwl); \ | | | | 256| 210| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 210] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 210] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 210| } \ | | | | 263| 210| } | | ------------------ | | 34| 210| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 210| (lp), (t), __FILE__, __LINE__)); \ | | 36| 210| } ------------------ 1343| 210| version = qpdb->current_version; 1344| 210| isc_refcount_increment(&version->references); ------------------ | | 81| 210| ({ \ | | 82| 210| uint_fast32_t __v; \ | | 83| 210| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 210| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 210| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 202| 210|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 420| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:11): [True: 210, False: 0] | | | | | | | Branch (54:11): [True: 210, False: 0] | | | | | | ------------------ | | | | | | 55| 210| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 210| __v; \ | | 86| 210| }) ------------------ 1345| 210| RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 38| 210| { \ | | 39| 210| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 210| (lp), (t), __FILE__, __LINE__)); \ | | 41| 210| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 210| { \ | | | | 283| 210| switch (type) { \ | | | | 284| 210| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 210, False: 0] | | | | ------------------ | | | | 285| 210| isc_rwlock_rdunlock(rwl); \ | | | | 286| 210| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 210] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 210] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 210| } \ | | | | 293| 210| } | | ------------------ | | 42| 210| } ------------------ 1346| | 1347| 210| *versionp = (dns_dbversion_t *)version; 1348| 210|} qpzone.c:closeversion: 1434| 210| bool commit DNS__DB_FLARG) { 1435| 210| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1436| 210| qpz_version_t *version = NULL, *cleanup_version = NULL; 1437| 210| qpz_version_t *least_greater = NULL; 1438| 210| qpznode_t *node = NULL; 1439| 210| bool rollback = false; 1440| 210| qpz_changedlist_t cleanup_list; 1441| 210| qpz_resignedlist_t resigned_list; 1442| 210| uint32_t serial, least_serial; 1443| | 1444| 210| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 210|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 420| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 210, False: 0] | | | | | Branch (42:11): [True: 210, False: 0] | | | | ------------------ | | | | 43| 210| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1445| 210| version = (qpz_version_t *)*versionp; 1446| 210| INSIST(version->qpdb == qpdb); ------------------ | | 202| 210|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 210| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 210, False: 0] | | | | ------------------ | | | | 55| 210| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1447| | 1448| 210| if (isc_refcount_decrement(&version->references) > 1) { ------------------ | | 94| 210| ({ \ | | 95| 210| uint_fast32_t __v; \ | | 96| 210| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 210| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 210| INSIST(__v > 0); \ | | ------------------ | | | | 202| 210|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 210| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 210, False: 0] | | | | | | ------------------ | | | | | | 55| 210| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 210| __v; \ | | 99| 210| }) ------------------ | Branch (1448:6): [True: 210, False: 0] ------------------ 1449| 210| *versionp = NULL; 1450| 210| return; 1451| 210| } 1452| | 1453| 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] | | ------------------ ------------------ 1454| 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] | | ------------------ ------------------ 1455| | 1456| | /* 1457| | * Update the zone's secure status in version before making 1458| | * it the current version. 1459| | */ 1460| 0| if (version->writer && commit) { ------------------ | Branch (1460:6): [True: 0, False: 0] | Branch (1460:25): [True: 0, False: 0] ------------------ 1461| 0| setsecure(db, version, (dns_dbnode_t *)qpdb->origin); 1462| 0| } 1463| | 1464| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1465| 0| serial = version->serial; 1466| 0| if (version->writer) { ------------------ | Branch (1466:6): [True: 0, False: 0] ------------------ 1467| 0| if (commit) { ------------------ | Branch (1467:7): [True: 0, False: 0] ------------------ 1468| 0| unsigned int cur_ref; 1469| 0| qpz_version_t *cur_version = NULL; 1470| | 1471| 0| INSIST(version == qpdb->future_version); ------------------ | | 202| 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))) | | ------------------ ------------------ 1472| | /* 1473| | * The current version is going to be replaced. 1474| | * Release the (likely last) reference to it from the 1475| | * DB itself and unlink it from the open list. 1476| | */ 1477| 0| cur_version = qpdb->current_version; 1478| 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); \ | | ------------------ | | | | 202| 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| }) ------------------ 1479| 0| &cur_version->references); 1480| 0| if (cur_ref == 1) { ------------------ | Branch (1480:8): [True: 0, False: 0] ------------------ 1481| 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) | | ------------------ ------------------ 1482| 0| &cur_version->references); 1483| 0| if (cur_version->serial == qpdb->least_serial) { ------------------ | Branch (1483:9): [True: 0, False: 0] ------------------ 1484| 0| INSIST(ISC_LIST_EMPTY( ------------------ | | 202| 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))) | | ------------------ ------------------ 1485| 0| cur_version->changed_list)); 1486| 0| } 1487| 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] | | | | ------------------ | | ------------------ ------------------ 1488| 0| cur_version, link); 1489| 0| } 1490| 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] | | ------------------ ------------------ 1491| | /* 1492| | * We're going to become the least open 1493| | * version. 1494| | */ 1495| 0| make_least_version(qpdb, version, 1496| 0| &cleanup_list); 1497| 0| } else { 1498| | /* 1499| | * Some other open version is the 1500| | * least version. We can't cleanup 1501| | * records that were changed in this 1502| | * version because the older versions 1503| | * may still be in use by an open 1504| | * version. 1505| | * 1506| | * We can, however, discard the 1507| | * changed records for things that 1508| | * we've added that didn't exist in 1509| | * prior versions. 1510| | */ 1511| 0| cleanup_nondirty(version, &cleanup_list); 1512| 0| } 1513| | /* 1514| | * If the (soon to be former) current version 1515| | * isn't being used by anyone, we can clean 1516| | * it up. 1517| | */ 1518| 0| if (cur_ref == 1) { ------------------ | Branch (1518:8): [True: 0, False: 0] ------------------ 1519| 0| cleanup_version = cur_version; 1520| 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] | | ------------------ ------------------ 1521| 0| version->changed_list, 1522| 0| cleanup_version->changed_list, link); 1523| 0| } 1524| | /* 1525| | * Become the current version. 1526| | */ 1527| 0| version->writer = false; 1528| 0| qpdb->current_version = version; 1529| 0| qpdb->current_serial = version->serial; 1530| 0| qpdb->future_version = NULL; 1531| | 1532| | /* 1533| | * Keep the current version in the open list, and 1534| | * gain a reference for the DB itself (see the DB 1535| | * creation function below). This must be the only 1536| | * case where we need to increment the counter from 1537| | * zero and need to use isc_refcount_increment0(). 1538| | */ 1539| 0| INSIST(isc_refcount_increment0(&version->references) == ------------------ | | 202| 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))) | | ------------------ ------------------ 1540| 0| 0); 1541| 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] | | ------------------ ------------------ 1542| 0| qpdb->current_version, link); 1543| 0| resigned_list = version->resigned_list; 1544| 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] | | ------------------ ------------------ 1545| 0| } else { 1546| | /* 1547| | * We're rolling back this transaction. 1548| | */ 1549| 0| cleanup_list = version->changed_list; 1550| 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] | | ------------------ ------------------ 1551| 0| resigned_list = version->resigned_list; 1552| 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] | | ------------------ ------------------ 1553| 0| rollback = true; 1554| 0| cleanup_version = version; 1555| 0| qpdb->future_version = NULL; 1556| 0| } 1557| 0| } else { 1558| 0| if (version != qpdb->current_version) { ------------------ | Branch (1558:7): [True: 0, False: 0] ------------------ 1559| | /* 1560| | * There are no external or internal references 1561| | * to this version and it can be cleaned up. 1562| | */ 1563| 0| cleanup_version = version; 1564| | 1565| | /* 1566| | * Find the version with the least serial 1567| | * number greater than ours. 1568| | */ 1569| 0| least_greater = ISC_LIST_PREV(version, link); ------------------ | | 139| 0|#define ISC_LIST_PREV(elt, link) ((elt)->link.prev) ------------------ 1570| 0| if (least_greater == NULL) { ------------------ | Branch (1570:8): [True: 0, False: 0] ------------------ 1571| 0| least_greater = qpdb->current_version; 1572| 0| } 1573| | 1574| 0| INSIST(version->serial < least_greater->serial); ------------------ | | 202| 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))) | | ------------------ ------------------ 1575| | /* 1576| | * Is this the least open version? 1577| | */ 1578| 0| if (version->serial == qpdb->least_serial) { ------------------ | Branch (1578:8): [True: 0, False: 0] ------------------ 1579| | /* 1580| | * Yes. Install the new least open 1581| | * version. 1582| | */ 1583| 0| make_least_version(qpdb, least_greater, 1584| 0| &cleanup_list); 1585| 0| } else { 1586| | /* 1587| | * Add any unexecuted cleanups to 1588| | * those of the least greater version. 1589| | */ 1590| 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] | | ------------------ ------------------ 1591| 0| version->changed_list, 1592| 0| link); 1593| 0| } 1594| 0| } else if (version->serial == qpdb->least_serial) { ------------------ | Branch (1594:14): [True: 0, False: 0] ------------------ 1595| 0| INSIST(ISC_LIST_EMPTY(version->changed_list)); ------------------ | | 202| 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))) | | ------------------ ------------------ 1596| 0| } 1597| 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] | | | | ------------------ | | ------------------ ------------------ 1598| 0| } 1599| 0| least_serial = qpdb->least_serial; 1600| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1601| | 1602| 0| if (cleanup_version != NULL) { ------------------ | Branch (1602:6): [True: 0, False: 0] ------------------ 1603| 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))) | | ------------------ ------------------ 1604| 0| INSIST(ISC_LIST_EMPTY(cleanup_version->changed_list)); ------------------ | | 202| 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))) | | ------------------ ------------------ 1605| 0| cleanup_gluelists(&cleanup_version->glue_stack); 1606| 0| cds_wfs_destroy(&cleanup_version->glue_stack); 1607| 0| isc_rwlock_destroy(&cleanup_version->rwlock); 1608| 0| isc_mem_put(qpdb->common.mctx, cleanup_version, ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 1609| 0| sizeof(*cleanup_version)); 1610| 0| } 1611| | 1612| | /* 1613| | * Commit/rollback re-signed headers. 1614| | */ 1615| 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] | | ------------------ ------------------ 1616| 0| isc_rwlock_t *nlock = NULL; 1617| 0| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1618| 0| dns_vecheader_t *header = resigned->header; 1619| 0| qpznode_t *resigned_node = resigned->node; 1620| | 1621| 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] | | | | ------------------ | | ------------------ ------------------ 1622| | 1623| 0| nlock = qpzone_get_lock(resigned_node); 1624| 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(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 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| } | | ------------------ ------------------ 1625| 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 (1625:7): [True: 0, False: 0] | Branch (1625:19): [True: 0, False: 0] ------------------ 1626| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 0| } | | | | ------------------ | | ------------------ | | 30| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 0| __FILE__, __LINE__)); \ | | 32| 0| } ------------------ 1627| 0| resign_register(qpdb->heap, resigned_node, header); 1628| 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); \ | | | | | | ------------------ | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 0| } | | | | ------------------ | | ------------------ | | 36| 0| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 0| __FILE__, __LINE__)); \ | | 38| 0| } ------------------ 1629| 0| } 1630| 0| qpz_resigned_destroy(db->mctx, &resigned); 1631| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 1632| 0| } 1633| | 1634| 0| if (ISC_LIST_EMPTY(cleanup_list)) { ------------------ | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (64:30): [True: 0, False: 0] | | ------------------ ------------------ 1635| 0| *versionp = NULL; 1636| 0| return; 1637| 0| } 1638| | 1639| 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] | | ------------------ ------------------ 1640| 0| isc_rwlock_t *nlock = NULL; 1641| 0| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1642| | 1643| 0| node = changed->node; 1644| 0| nlock = qpzone_get_lock(node); 1645| | 1646| 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(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 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| } | | ------------------ ------------------ 1647| 0| if (rollback) { ------------------ | Branch (1647:7): [True: 0, False: 0] ------------------ 1648| 0| rollback_node(node, serial); 1649| 0| } 1650| 0| bool has_erefs = qpznode_release(node DNS__DB_FILELINE); 1651| 0| if (!has_erefs) { ------------------ | Branch (1651:7): [True: 0, False: 0] ------------------ 1652| 0| clean_zone_node(qpdb->heap, node, least_serial); 1653| 0| } 1654| | 1655| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 1656| | 1657| | /* 1658| | * The node reference is released separately above, so 1659| | * we just free the changed structure here. 1660| | */ 1661| 0| isc_mem_put(qpdb->common.mctx, changed, sizeof(*changed)); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 1662| 0| } 1663| | 1664| 0| *versionp = NULL; 1665| 0|} qpzone.c:qpzone_findrdataset: 1672| 14| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 1673| 14| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1674| 14| qpznode_t *node = (qpznode_t *)dbnode; 1675| 14| dns_vecheader_t *found = NULL, *foundsig = NULL; 1676| 14| uint32_t serial; 1677| 14| qpz_version_t *version = (qpz_version_t *)dbversion; 1678| 14| bool close_version = false; 1679| 14| dns_typepair_t typepair, sigpair; 1680| 14| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1681| 14| isc_rwlock_t *nlock = NULL; 1682| | 1683| 14| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1684| 14| REQUIRE(type != dns_rdatatype_any); ------------------ | | 198| 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))) | | ------------------ ------------------ 1685| 14| INSIST(version == NULL || version->qpdb == qpdb); ------------------ | | 202| 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))) | | ------------------ ------------------ 1686| | 1687| 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 (1687:6): [True: 0, False: 14] | Branch (1687:36): [True: 0, False: 0] ------------------ 1688| 0| return ISC_R_NOTFOUND; 1689| 0| } 1690| | 1691| 14| if (version == NULL) { ------------------ | Branch (1691:6): [True: 4, False: 10] ------------------ 1692| 4| currentversion(db, (dns_dbversion_t **)&version); 1693| 4| close_version = true; 1694| 4| } 1695| 14| serial = version->serial; 1696| | 1697| 14| nlock = qpzone_get_lock(node); 1698| 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(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 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| } | | ------------------ ------------------ 1699| | 1700| 14| typepair = DNS_TYPEPAIR_VALUE(type, covers); ------------------ | | 46| 14| ({ \ | | 47| 14| DNS__TYPEPAIR_CHECK(base, covers); \ | | ------------------ | | | | 25| 14|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 48| 14| DNS__TYPEPAIR_VALUE(base, covers); \ | | ------------------ | | | | 43| 14| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 14| (((uint32_t)base) & 0xffff)) | | ------------------ | | 49| 14| }) ------------------ 1701| 14| if (covers == dns_rdatatype_none) { ------------------ | | 114| 14|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1701:6): [True: 14, False: 0] ------------------ 1702| 14| sigpair = DNS_SIGTYPEPAIR(type); ------------------ | | 52| 14|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 14| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 14| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 1703| 14| } else { 1704| 0| sigpair = dns_typepair_none; 1705| 0| } 1706| | 1707| 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] | | | | ------------------ | | ------------------ ------------------ 1708| 42| dns_vecheader_t *header = first_existing_header(top, serial); 1709| 42| if (header != NULL) { ------------------ | Branch (1709:7): [True: 42, False: 0] ------------------ 1710| | /* 1711| | * We have an active, extant rdataset. If it's a 1712| | * type we're looking for, remember it. 1713| | */ 1714| 42| if (top->typepair == typepair) { ------------------ | Branch (1714:8): [True: 4, False: 38] ------------------ 1715| 4| found = header; 1716| 4| if (foundsig != NULL) { ------------------ | Branch (1716:9): [True: 0, False: 4] ------------------ 1717| 0| break; 1718| 0| } 1719| 38| } else if (top->typepair == sigpair) { ------------------ | Branch (1719:15): [True: 0, False: 38] ------------------ 1720| 0| foundsig = header; 1721| 0| if (found != NULL) { ------------------ | Branch (1721:9): [True: 0, False: 0] ------------------ 1722| 0| break; 1723| 0| } 1724| 0| } 1725| 42| } 1726| 42| } 1727| 14| if (found != NULL) { ------------------ | Branch (1727:6): [True: 4, False: 10] ------------------ 1728| 4| bindrdataset(qpdb, found, rdataset DNS__DB_FLARG_PASS); 1729| 4| if (foundsig != NULL) { ------------------ | Branch (1729:7): [True: 0, False: 4] ------------------ 1730| 0| bindrdataset(qpdb, foundsig, 1731| 0| sigrdataset DNS__DB_FLARG_PASS); 1732| 0| } 1733| 4| } 1734| | 1735| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 1736| | 1737| 14| if (close_version) { ------------------ | Branch (1737:6): [True: 4, False: 10] ------------------ 1738| 4| closeversion(db, (dns_dbversion_t **)&version, 1739| 4| false DNS__DB_FLARG_PASS); 1740| 4| } 1741| | 1742| 14| if (found == NULL) { ------------------ | Branch (1742:6): [True: 10, False: 4] ------------------ 1743| 10| return ISC_R_NOTFOUND; 1744| 10| } 1745| | 1746| 4| return ISC_R_SUCCESS; 1747| 14|} qpzone.c:issecure: 2373| 2|issecure(dns_db_t *db) { 2374| 2| qpzonedb_t *qpdb = NULL; 2375| 2| bool secure; 2376| | 2377| 2| qpdb = (qpzonedb_t *)db; 2378| | 2379| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2380| | 2381| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 2382| 2| secure = qpdb->current_version->secure; 2383| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 2384| | 2385| 2| return secure; 2386| 2|} qpzone.c:nodecount: 4005| 2|nodecount(dns_db_t *db) { 4006| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 4007| 2| dns_qp_memusage_t mu; 4008| | 4009| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 4010| | 4011| 2| mu = dns_qpmulti_memusage(qpdb->tree); 4012| | 4013| 2| return mu.leaves; 4014| 2|} qpzone.c:getoriginnode: 4017| 2|getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { 4018| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 4019| | 4020| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 4021| 2| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 4022| | 4023| | /* Note that the access to the origin node doesn't require a DB lock */ 4024| 2| INSIST(qpdb->origin != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 4025| 2| qpznode_acquire(qpdb->origin DNS__DB_FLARG_PASS); 4026| 2| *nodep = (dns_dbnode_t *)qpdb->origin; 4027| | 4028| 2| return ISC_R_SUCCESS; 4029| 2|} qpzone.c:qpzone_findnode: 2678| 6| dns_dbnode_t **nodep DNS__DB_FLARG) { 2679| 6| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2680| | 2681| 6| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2682| | 2683| 6| dns_qpread_t qpr = { 0 }; 2684| 6| dns_qp_t *qp = begin_transaction(qpdb, &qpr, create); 2685| | 2686| 6| isc_result_t result = findnodeintree(qpdb, qp, name, create, false, 2687| 6| nodep DNS__DB_FLARG_PASS); 2688| | 2689| 6| end_transaction(qpdb, qp, create); 2690| | 2691| 6| return result; 2692| 6|} qpzone.c:qpzone_find: 3449| 200| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 3450| 200| isc_result_t result; 3451| 200| qpzonedb_t *qpdb = (qpzonedb_t *)db; 3452| 200| qpznode_t *node = NULL; 3453| 200| bool cname_ok = true, close_version = false; 3454| 200| bool maybe_zonecut = false; 3455| 200| bool wild = false, empty_node = false; 3456| 200| bool nsec3 = false; 3457| 200| dns_vecheader_t *found = NULL, *nsecheader = NULL; 3458| 200| dns_vecheader_t *foundsig = NULL, *cnamesig = NULL, *nsecsig = NULL; 3459| 200| dns_typepair_t sigpair; 3460| 200| bool active; 3461| 200| isc_rwlock_t *nlock = NULL; 3462| 200| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 3463| | 3464| 200| REQUIRE(VALID_QPZONE((qpzonedb_t *)db)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 3465| 200| INSIST(version == NULL || ------------------ | | 202| 200|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 200, False: 0] | | | | | Branch (54:11): [True: 0, False: 0] | | | | ------------------ | | | | 55| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 3466| 200| ((qpz_version_t *)version)->qpdb == (qpzonedb_t *)db); 3467| | 3468| | /* 3469| | * If the caller didn't supply a version, attach to the current 3470| | * version. 3471| | */ 3472| 200| if (version == NULL) { ------------------ | Branch (3472:6): [True: 200, False: 0] ------------------ 3473| 200| currentversion(db, &version); 3474| 200| close_version = true; 3475| 200| } 3476| | 3477| 200| dns_namespace_t nspace; 3478| 200| qpz_search_t search; 3479| 200| qpz_search_init(&search, (qpzonedb_t *)db, (qpz_version_t *)version, 3480| 200| options); 3481| | 3482| 200| if ((options & DNS_DBFIND_FORCENSEC3) != 0) { ------------------ | Branch (3482:6): [True: 0, False: 200] ------------------ 3483| 0| nsec3 = true; 3484| 0| nspace = DNS_DBNAMESPACE_NSEC3; 3485| 200| } else { 3486| 200| nspace = DNS_DBNAMESPACE_NORMAL; 3487| 200| } 3488| 200| dns_qpmulti_query(qpdb->tree, &search.qpr); 3489| | 3490| | /* 3491| | * Search down from the root of the tree. 3492| | */ 3493| 200| result = dns_qp_lookup(&search.qpr, name, nspace, &search.iter, 3494| 200| &search.chain, (void **)&node, NULL); 3495| 200| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (3495:6): [True: 200, False: 0] ------------------ 3496| 200| dns_name_copy(&node->name, foundname); 3497| 200| } 3498| | 3499| | /* 3500| | * Check the QP chain to see if there's a node above us with a 3501| | * active DNAME or NS rdatasets. 3502| | * 3503| | * We're only interested in nodes above QNAME, so if the result 3504| | * was success, then we skip the last item in the chain. 3505| | */ 3506| 200| unsigned int clen = dns_qpchain_length(&search.chain); 3507| 200| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3507:6): [True: 123, False: 77] ------------------ 3508| 123| clen--; 3509| 123| } 3510| 277| for (unsigned int i = 0; i < clen && search.zonecut == NULL; i++) { ------------------ | Branch (3510:27): [True: 77, False: 200] | Branch (3510:39): [True: 77, False: 0] ------------------ 3511| 77| qpznode_t *n = NULL; 3512| 77| isc_result_t tresult; 3513| | 3514| 77| dns_qpchain_node(&search.chain, i, (void **)&n, NULL); 3515| 77| tresult = qpzone_check_zonecut(n, &search DNS__DB_FLARG_PASS); 3516| 77| if (tresult != DNS_R_CONTINUE) { ------------------ | Branch (3516:7): [True: 0, False: 77] ------------------ 3517| 0| result = tresult; 3518| 0| search.chain.len = i - 1; 3519| 0| dns_name_copy(&n->name, foundname); 3520| 0| node = n; 3521| 0| } 3522| 77| } 3523| | 3524| 200| if (result == DNS_R_PARTIALMATCH) { ------------------ | Branch (3524:6): [True: 77, False: 123] ------------------ 3525| 77| partial_match: 3526| 77| if (search.zonecut != NULL) { ------------------ | Branch (3526:7): [True: 0, False: 77] ------------------ 3527| 0| result = qpzone_setup_delegation( 3528| 0| &search, foundname, rdataset, 3529| 0| sigrdataset DNS__DB_FLARG_PASS); 3530| 0| goto tree_exit; 3531| 0| } 3532| | 3533| 77| if (search.wild) { ------------------ | Branch (3533:7): [True: 0, False: 77] ------------------ 3534| | /* 3535| | * At least one of the levels in the search chain 3536| | * potentially has a wildcard. For each such level, 3537| | * we must see if there's a matching wildcard active 3538| | * in the current version. 3539| | */ 3540| 0| result = find_wildcard(&search, &node, name, nspace); 3541| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3541:8): [True: 0, False: 0] ------------------ 3542| 0| dns_name_copy(&node->name, foundname); 3543| 0| wild = true; 3544| 0| goto found; 3545| 0| } else if (result != ISC_R_NOTFOUND) { ------------------ | Branch (3545:15): [True: 0, False: 0] ------------------ 3546| 0| goto tree_exit; 3547| 0| } 3548| 0| } 3549| | 3550| 77| active = false; 3551| 77| if (!nsec3) { ------------------ | Branch (3551:7): [True: 77, False: 0] ------------------ 3552| | /* 3553| | * The NSEC3 tree won't have empty nodes, 3554| | * so it isn't necessary to check for them. 3555| | */ 3556| 77| dns_qpiter_t iter = search.iter; 3557| 77| active = activeempty(&search, &iter, name); 3558| 77| } 3559| | 3560| | /* 3561| | * If we're here, then the name does not exist, is not 3562| | * beneath a zonecut, and there's no matching wildcard. 3563| | */ 3564| 77| if ((search.version->secure && !search.version->havensec3) || ------------------ | Branch (3564:8): [True: 0, False: 77] | Branch (3564:34): [True: 0, False: 0] ------------------ 3565| 77| nsec3) ------------------ | Branch (3565:7): [True: 0, False: 77] ------------------ 3566| 0| { 3567| 0| result = find_closest_nsec( 3568| 0| &search, foundname, rdataset, sigrdataset, 3569| 0| nsec3, 3570| 0| search.version->secure DNS__DB_FLARG_PASS); 3571| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3571:8): [True: 0, False: 0] ------------------ 3572| 0| result = active ? DNS_R_EMPTYNAME ------------------ | Branch (3572:14): [True: 0, False: 0] ------------------ 3573| 0| : DNS_R_NXDOMAIN; 3574| 0| } 3575| 77| } else { 3576| 77| result = active ? DNS_R_EMPTYNAME : DNS_R_NXDOMAIN; ------------------ | Branch (3576:13): [True: 0, False: 77] ------------------ 3577| 77| } 3578| 77| goto tree_exit; 3579| 123| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (3579:13): [True: 0, False: 123] ------------------ 3580| 0| goto tree_exit; 3581| 0| } 3582| | 3583| 123|found: 3584| | /* 3585| | * We have found a node whose name is the desired name, or we 3586| | * have matched a wildcard. 3587| | */ 3588| | 3589| 123| nlock = qpzone_get_lock(node); 3590| 123| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 123|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 123| { \ | | | | 32| 123| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 123| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 123| { \ | | | | | | 31| 123| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 123| (t), __FILE__, __LINE__)); \ | | | | | | 33| 123| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 123| { \ | | | | | | | | 253| 123| switch (type) { \ | | | | | | | | 254| 123| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 123, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 123| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 123| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 123] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 123] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 123| } \ | | | | | | | | 263| 123| } | | | | | | ------------------ | | | | | | 34| 123| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 123| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 123| } | | | | ------------------ | | | | 34| 123| *tp = t; \ | | | | 35| 123| } | | ------------------ ------------------ 3591| | 3592| 123| if (search.zonecut != NULL) { ------------------ | Branch (3592:6): [True: 0, False: 123] ------------------ 3593| | /* 3594| | * If we're beneath a zone cut, we don't want to look for 3595| | * CNAMEs because they're not legitimate zone glue. 3596| | */ 3597| 0| cname_ok = false; 3598| 123| } else { 3599| | /* 3600| | * The node may be a zone cut itself. If it might be one, 3601| | * make sure we check for it later. 3602| | * 3603| | * DS records live above the zone cut in ordinary zone so 3604| | * we want to ignore any referral. 3605| | * 3606| | * Stub zones don't have anything "above" the delegation so 3607| | * we always return a referral. 3608| | */ 3609| 123| if (node->delegating && ((node != search.qpdb->origin && ------------------ | Branch (3609:7): [True: 0, False: 123] | Branch (3609:29): [True: 0, False: 0] ------------------ 3610| 0| !dns_rdatatype_atparent(type)) || ------------------ | Branch (3610:8): [True: 0, False: 0] ------------------ 3611| 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] | | ------------------ ------------------ 3612| 0| { 3613| 0| maybe_zonecut = true; 3614| 0| } 3615| 123| } 3616| | 3617| | /* 3618| | * Certain DNSSEC types are not subject to CNAME matching 3619| | * (RFC4035, section 2.5). 3620| | * 3621| | * We don't check for RRSIG, because we don't store RRSIG records 3622| | * directly. 3623| | */ 3624| 123| if (type == dns_rdatatype_nsec) { ------------------ | | 161| 123|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (3624:6): [True: 0, False: 123] ------------------ 3625| 0| cname_ok = false; 3626| 0| } 3627| | 3628| | /* 3629| | * We now go looking for rdata... 3630| | */ 3631| | 3632| 123| sigpair = DNS_SIGTYPEPAIR(type); ------------------ | | 52| 123|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 123| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 123| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3633| 123| empty_node = true; 3634| 369| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 123| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 123| for (typeof(first) elt = first, \ | | | | 64| 123| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 123|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 123, False: 0] | | | | ------------------ | | | | 65| 492| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 369, False: 123] | | | | ------------------ | | | | 66| 369| elt = elt##_next, \ | | | | 67| 369| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 246|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 246, False: 123] | | | | ------------------ | | ------------------ ------------------ 3635| | /* 3636| | * Look for an active, extant rdataset. 3637| | */ 3638| 369| dns_vecheader_t *header = first_existing_header(top, 3639| 369| search.serial); 3640| 369| if (header != NULL) { ------------------ | Branch (3640:7): [True: 369, False: 0] ------------------ 3641| | /* 3642| | * We now know that there is at least one active 3643| | * rdataset at this node. 3644| | */ 3645| 369| empty_node = false; 3646| | 3647| | /* 3648| | * Do special zone cut handling, if requested. 3649| | */ 3650| 369| if (maybe_zonecut && ------------------ | Branch (3650:8): [True: 0, False: 369] ------------------ 3651| 0| top->typepair == DNS_TYPEPAIR(dns_rdatatype_ns)) ------------------ | | 51| 0|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 0| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 0| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3651:8): [True: 0, False: 0] ------------------ 3652| 0| { 3653| | /* 3654| | * We increment the reference count on node to 3655| | * ensure that search->zonecut_header will 3656| | * still be valid later. 3657| | */ 3658| 0| qpznode_acquire(node DNS__DB_FLARG_PASS); 3659| 0| search.zonecut = node; 3660| 0| search.zonecut_header = header; 3661| 0| search.zonecut_sigheader = NULL; 3662| 0| maybe_zonecut = false; 3663| | 3664| 0| if ((search.options & DNS_DBFIND_GLUEOK) == 0 && ------------------ | Branch (3664:9): [True: 0, False: 0] ------------------ 3665| 0| type != dns_rdatatype_nsec) ------------------ | | 161| 0|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (3665:9): [True: 0, False: 0] ------------------ 3666| 0| { 3667| | /* 3668| | * Glue is not OK, but any answer we 3669| | * could return would be glue. Return 3670| | * the delegation. 3671| | */ 3672| 0| found = NULL; 3673| 0| break; 3674| 0| } 3675| 0| if (found != NULL && foundsig != NULL) { ------------------ | Branch (3675:9): [True: 0, False: 0] | Branch (3675:26): [True: 0, False: 0] ------------------ 3676| 0| break; 3677| 0| } 3678| 0| } 3679| | 3680| | /* 3681| | * If the NSEC3 record doesn't match the chain 3682| | * we are using behave as if it isn't here. 3683| | */ 3684| 369| if (top->typepair == ------------------ | Branch (3684:8): [True: 0, False: 369] ------------------ 3685| 369| DNS_TYPEPAIR(dns_rdatatype_nsec3) && ------------------ | | 51| 369|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 738| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 738| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3686| 0| !matchparams(header, &search)) ------------------ | Branch (3686:8): [True: 0, False: 0] ------------------ 3687| 0| { 3688| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 3689| 0| goto partial_match; 3690| 0| } 3691| | /* 3692| | * If we found a type we were looking for, 3693| | * remember it. 3694| | */ 3695| 369| if (top->typepair == type || ------------------ | Branch (3695:8): [True: 123, False: 246] ------------------ 3696| 246| type == dns_rdatatype_any || ------------------ | | 205| 615|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3696:8): [True: 0, False: 246] ------------------ 3697| 246| (top->typepair == ------------------ | Branch (3697:9): [True: 0, False: 246] ------------------ 3698| 246| DNS_TYPEPAIR(dns_rdatatype_cname) && ------------------ | | 51| 246|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 492| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 492| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3699| 0| cname_ok)) ------------------ | Branch (3699:9): [True: 0, False: 0] ------------------ 3700| 123| { 3701| | /* 3702| | * We've found the answer! 3703| | */ 3704| 123| found = header; 3705| 123| if (top->typepair == ------------------ | Branch (3705:9): [True: 0, False: 123] ------------------ 3706| 123| DNS_TYPEPAIR(dns_rdatatype_cname) && ------------------ | | 51| 123|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 246| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 246| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3707| 0| cname_ok) ------------------ | Branch (3707:9): [True: 0, False: 0] ------------------ 3708| 0| { 3709| | /* 3710| | * We may be finding a CNAME instead 3711| | * of the desired type. 3712| | * 3713| | * If we've already got the CNAME RRSIG, 3714| | * use it, otherwise change sigtype 3715| | * so that we find it. 3716| | */ 3717| 0| if (cnamesig != NULL) { ------------------ | Branch (3717:10): [True: 0, False: 0] ------------------ 3718| 0| foundsig = cnamesig; 3719| 0| } else { 3720| 0| sigpair = DNS_SIGTYPEPAIR( ------------------ | | 52| 0|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 0| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 0| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3721| 0| dns_rdatatype_cname); 3722| 0| } 3723| 0| } 3724| | /* 3725| | * If we've got all we need, end the search. 3726| | */ 3727| 123| if (!maybe_zonecut && foundsig != NULL) { ------------------ | Branch (3727:9): [True: 123, False: 0] | Branch (3727:27): [True: 0, False: 123] ------------------ 3728| 0| break; 3729| 0| } 3730| 246| } else if (top->typepair == sigpair) { ------------------ | Branch (3730:15): [True: 0, False: 246] ------------------ 3731| | /* 3732| | * We've found the RRSIG rdataset for our 3733| | * target type. Remember it. 3734| | */ 3735| 0| foundsig = header; 3736| | /* 3737| | * If we've got all we need, end the search. 3738| | */ 3739| 0| if (!maybe_zonecut && found != NULL) { ------------------ | Branch (3739:9): [True: 0, False: 0] | Branch (3739:27): [True: 0, False: 0] ------------------ 3740| 0| break; 3741| 0| } 3742| 246| } else if (top->typepair == ------------------ | Branch (3742:15): [True: 0, False: 246] ------------------ 3743| 246| DNS_TYPEPAIR(dns_rdatatype_nsec) && ------------------ | | 51| 246|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 492| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 492| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3744| 0| !search.version->havensec3) ------------------ | Branch (3744:8): [True: 0, False: 0] ------------------ 3745| 0| { 3746| | /* 3747| | * Remember a NSEC rdataset even if we're 3748| | * not specifically looking for it, because 3749| | * we might need it later. 3750| | */ 3751| 0| nsecheader = header; 3752| 246| } else if (top->typepair == ------------------ | Branch (3752:15): [True: 0, False: 246] ------------------ 3753| 246| DNS_SIGTYPEPAIR( ------------------ | | 52| 246|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 492| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 492| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3754| 0| dns_rdatatype_nsec) && 3755| 0| !search.version->havensec3) ------------------ | Branch (3755:8): [True: 0, False: 0] ------------------ 3756| 0| { 3757| | /* 3758| | * If we need the NSEC rdataset, we'll also 3759| | * need its signature. 3760| | */ 3761| 0| nsecsig = header; 3762| 246| } else if (cname_ok && ------------------ | Branch (3762:15): [True: 246, False: 0] ------------------ 3763| 246| top->typepair == ------------------ | Branch (3763:8): [True: 0, False: 246] ------------------ 3764| 246| DNS_SIGTYPEPAIR(dns_rdatatype_cname)) ------------------ | | 52| 246|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 246| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 246| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3765| 0| { 3766| | /* 3767| | * If we get a CNAME match, we'll also need 3768| | * its signature. 3769| | */ 3770| 0| cnamesig = header; 3771| 0| } 3772| 369| } 3773| 369| } 3774| | 3775| 123| if (empty_node) { ------------------ | Branch (3775:6): [True: 0, False: 123] ------------------ 3776| | /* 3777| | * We have an exact match for the name, but there are no 3778| | * active rdatasets in the desired version. That means that 3779| | * this node doesn't exist in the desired version. 3780| | * If there's a node above this one, reassign the 3781| | * foundname to the parent and treat this as a partial 3782| | * match. 3783| | */ 3784| 0| if (!wild) { ------------------ | Branch (3784:7): [True: 0, False: 0] ------------------ 3785| 0| unsigned int len = search.chain.len - 1; 3786| 0| if (len > 0) { ------------------ | Branch (3786:8): [True: 0, False: 0] ------------------ 3787| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 3788| 0| dns_qpchain_node(&search.chain, len - 1, 3789| 0| (void **)&node, NULL); 3790| 0| dns_name_copy(&node->name, foundname); 3791| 0| goto partial_match; 3792| 0| } 3793| 0| } 3794| 0| } 3795| | 3796| | /* 3797| | * If we didn't find what we were looking for... 3798| | */ 3799| 123| if (found == NULL) { ------------------ | Branch (3799:6): [True: 0, False: 123] ------------------ 3800| 0| if (search.zonecut != NULL) { ------------------ | Branch (3800:7): [True: 0, False: 0] ------------------ 3801| | /* 3802| | * We were trying to find glue at a node beneath a 3803| | * zone cut, but didn't. 3804| | * 3805| | * Return the delegation. 3806| | */ 3807| 0| if (wild) { ------------------ | Branch (3807:8): [True: 0, False: 0] ------------------ 3808| 0| foundname->attributes.wildcard = true; 3809| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| result = qpzone_setup_delegation( 3812| 0| &search, foundname, rdataset, 3813| 0| sigrdataset DNS__DB_FLARG_PASS); 3814| 0| goto tree_exit; 3815| 0| } 3816| | /* 3817| | * The desired type doesn't exist. 3818| | */ 3819| 0| result = DNS_R_NXRRSET; 3820| 0| if (search.version->secure && !search.version->havensec3 && ------------------ | Branch (3820:7): [True: 0, False: 0] | Branch (3820:33): [True: 0, False: 0] ------------------ 3821| 0| (nsecheader == NULL || nsecsig == NULL)) ------------------ | Branch (3821:8): [True: 0, False: 0] | Branch (3821:30): [True: 0, False: 0] ------------------ 3822| 0| { 3823| | /* 3824| | * The zone is secure but there's no NSEC, 3825| | * or the NSEC has no signature! 3826| | */ 3827| 0| if (!wild) { ------------------ | Branch (3827:8): [True: 0, False: 0] ------------------ 3828| 0| result = DNS_R_BADDB; 3829| 0| goto node_exit; 3830| 0| } 3831| | 3832| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 3833| 0| result = find_closest_nsec( 3834| 0| &search, foundname, rdataset, sigrdataset, 3835| 0| false, 3836| 0| search.version->secure DNS__DB_FLARG_PASS); 3837| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3837:8): [True: 0, False: 0] ------------------ 3838| 0| result = DNS_R_EMPTYWILD; 3839| 0| } 3840| 0| goto tree_exit; 3841| 0| } 3842| 0| if (search.version->secure && !search.version->havensec3) { ------------------ | Branch (3842:7): [True: 0, False: 0] | Branch (3842:33): [True: 0, False: 0] ------------------ 3843| 0| bindrdataset(search.qpdb, nsecheader, 3844| 0| rdataset DNS__DB_FLARG_PASS); 3845| 0| if (nsecsig != NULL) { ------------------ | Branch (3845:8): [True: 0, False: 0] ------------------ 3846| 0| bindrdataset(search.qpdb, nsecsig, 3847| 0| sigrdataset DNS__DB_FLARG_PASS); 3848| 0| } 3849| 0| } 3850| 0| if (wild) { ------------------ | Branch (3850:7): [True: 0, False: 0] ------------------ 3851| 0| foundname->attributes.wildcard = true; 3852| 0| } 3853| 0| goto node_exit; 3854| 0| } 3855| | 3856| | /* 3857| | * We found what we were looking for, or we found a CNAME. 3858| | */ 3859| 123| if (type != found->typepair && type != dns_rdatatype_any && ------------------ | | 205| 123|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3859:6): [True: 0, False: 123] | Branch (3859:33): [True: 0, False: 0] ------------------ 3860| 0| found->typepair == DNS_TYPEPAIR(dns_rdatatype_cname)) ------------------ | | 51| 0|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 0| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 0| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3860:6): [True: 0, False: 0] ------------------ 3861| 0| { 3862| | /* 3863| | * We weren't doing an ANY query and we found a CNAME instead 3864| | * of the type we were looking for, so we need to indicate 3865| | * that result to the caller. 3866| | */ 3867| 0| result = DNS_R_CNAME; 3868| 123| } else if (search.zonecut != NULL) { ------------------ | Branch (3868:13): [True: 0, False: 123] ------------------ 3869| | /* 3870| | * If we're beneath a zone cut, we must indicate that the 3871| | * result is glue, unless we're actually at the zone cut 3872| | * and the type is NSEC. 3873| | */ 3874| 0| if (search.zonecut == node) { ------------------ | Branch (3874:7): [True: 0, False: 0] ------------------ 3875| 0| if (dns_rdatatype_isnsec(type)) { ------------------ | Branch (3875:8): [True: 0, False: 0] ------------------ 3876| 0| result = ISC_R_SUCCESS; 3877| 0| } else if (type == dns_rdatatype_any) { ------------------ | | 205| 0|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3877:15): [True: 0, False: 0] ------------------ 3878| 0| result = DNS_R_ZONECUT; 3879| 0| } else { 3880| 0| result = DNS_R_GLUE; 3881| 0| } 3882| 0| } else { 3883| 0| result = DNS_R_GLUE; 3884| 0| } 3885| 123| } else { 3886| | /* 3887| | * An ordinary successful query! 3888| | */ 3889| 123| result = ISC_R_SUCCESS; 3890| 123| } 3891| | 3892| 123| if (type != dns_rdatatype_any) { ------------------ | | 205| 123|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3892:6): [True: 123, False: 0] ------------------ 3893| 123| bindrdataset(search.qpdb, found, rdataset DNS__DB_FLARG_PASS); 3894| 123| if (foundsig != NULL) { ------------------ | Branch (3894:7): [True: 0, False: 123] ------------------ 3895| 0| bindrdataset(search.qpdb, foundsig, 3896| 0| sigrdataset DNS__DB_FLARG_PASS); 3897| 0| } 3898| 123| } 3899| | 3900| 123| if (wild) { ------------------ | Branch (3900:6): [True: 0, False: 123] ------------------ 3901| 0| foundname->attributes.wildcard = true; 3902| 0| } 3903| | 3904| 123|node_exit: 3905| 123| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 123| { \ | | 38| 123| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 123| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 123| { \ | | | | 39| 123| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 123| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 123| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 123| { \ | | | | | | 283| 123| switch (type) { \ | | | | | | 284| 123| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 123, False: 0] | | | | | | ------------------ | | | | | | 285| 123| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 123| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 123] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 123] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 123| } \ | | | | | | 293| 123| } | | | | ------------------ | | | | 42| 123| } | | ------------------ | | 40| 123| *tp = isc_rwlocktype_none; \ | | 41| 123| } ------------------ 3906| | 3907| 200|tree_exit: 3908| 200| dns_qpread_destroy(qpdb->tree, &search.qpr); 3909| | 3910| | /* 3911| | * If we found a zonecut but aren't going to use it, we have to 3912| | * let go of it. 3913| | */ 3914| 200| if (search.zonecut != NULL) { ------------------ | Branch (3914:6): [True: 0, False: 200] ------------------ 3915| 0| node = search.zonecut; 3916| 0| INSIST(node != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 3917| 0| nlock = qpzone_get_lock(node); 3918| | 3919| 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(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 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| } | | ------------------ ------------------ 3920| 0| (void)qpznode_release(node DNS__DB_FLARG_PASS); 3921| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 3922| 0| } 3923| | 3924| 200| if (close_version) { ------------------ | Branch (3924:6): [True: 200, False: 0] ------------------ 3925| 200| closeversion(db, &version, false DNS__DB_FLARG_PASS); 3926| 200| } 3927| | 3928| 200| return result; 3929| 200|} qpzone.c:qpz_search_init: 3417| 200| unsigned int options) { 3418| | /* 3419| | * qpz_search_t contains two structures with large buffers (dns_qpiter_t 3420| | * and dns_qpchain_t). Those two structures will be initialized later by 3421| | * dns_qp_lookup anyway. 3422| | * To avoid the overhead of zero initialization, we avoid designated 3423| | * initializers and initialize all "small" fields manually. 3424| | */ 3425| 200| search->qpdb = db; 3426| 200| search->version = version; 3427| 200| search->qpr = (dns_qpread_t){}; 3428| 200| search->serial = version->serial; 3429| 200| search->options = options; 3430| | /* 3431| | * qpch->in -- init in dns_qp_lookup 3432| | * qpiter -- init in dns_qp_lookup 3433| | */ 3434| 200| search->copy_name = false; 3435| 200| search->wild = false; 3436| 200| search->zonecut = NULL; 3437| 200| search->zonecut_header = NULL; 3438| | search->zonecut_sigheader = NULL; 3439| 200| dns_fixedname_init(&search->zonecut_name); 3440| 200|} qpzone.c:qpzone_check_zonecut: 3301| 77|qpzone_check_zonecut(qpznode_t *node, void *arg DNS__DB_FLARG) { 3302| 77| qpz_search_t *search = arg; 3303| 77| dns_vecheader_t *dname_header = NULL, *sigdname_header = NULL; 3304| 77| dns_vecheader_t *ns_header = NULL; 3305| 77| dns_vecheader_t *found = NULL; 3306| 77| isc_result_t result = DNS_R_CONTINUE; 3307| 77| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 3308| 77| isc_rwlock_t *nlock = qpzone_get_lock(node); 3309| | 3310| 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(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 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| } | | ------------------ ------------------ 3311| | 3312| | /* 3313| | * Look for an NS or DNAME rdataset active in our version. 3314| | */ 3315| 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] | | | | ------------------ | | ------------------ ------------------ 3316| 231| if (top->typepair == DNS_TYPEPAIR(dns_rdatatype_ns) || ------------------ | | 51| 231|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 462| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 462| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3316:7): [True: 77, False: 154] ------------------ 3317| 231| top->typepair == DNS_TYPEPAIR(dns_rdatatype_dname) || ------------------ | | 51| 154|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 385| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 385| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3317:7): [True: 0, False: 154] ------------------ 3318| 154| top->typepair == DNS_SIGTYPEPAIR(dns_rdatatype_dname)) ------------------ | | 52| 154|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 154| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 154| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3318:7): [True: 0, False: 154] ------------------ 3319| 77| { 3320| 77| dns_vecheader_t *header = 3321| 77| first_existing_header(top, search->serial); 3322| 77| if (header != NULL) { ------------------ | Branch (3322:8): [True: 77, False: 0] ------------------ 3323| 77| if (top->typepair == ------------------ | Branch (3323:9): [True: 0, False: 77] ------------------ 3324| 77| DNS_TYPEPAIR(dns_rdatatype_dname)) ------------------ | | 51| 77|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 77| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 77| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3325| 0| { 3326| 0| dname_header = header; 3327| 77| } else if (top->typepair == ------------------ | Branch (3327:16): [True: 0, False: 77] ------------------ 3328| 77| DNS_SIGTYPEPAIR(dns_rdatatype_dname)) ------------------ | | 52| 77|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 77| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 77| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3329| 0| { 3330| 0| sigdname_header = header; 3331| 77| } else if (node != search->qpdb->origin || ------------------ | Branch (3331:16): [True: 0, False: 77] ------------------ 3332| 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] | | ------------------ ------------------ 3333| 0| { 3334| | /* 3335| | * We've found an NS rdataset that 3336| | * isn't at the origin node. 3337| | */ 3338| 0| ns_header = header; 3339| 0| } 3340| 77| } 3341| 77| } 3342| 231| } 3343| | 3344| | /* 3345| | * Did we find anything? 3346| | */ 3347| 77| if (!IS_STUB(search->qpdb) && ns_header != NULL) { ------------------ | | 84| 154|#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0) ------------------ | Branch (3347:6): [True: 77, False: 0] | Branch (3347:32): [True: 0, False: 77] ------------------ 3348| | /* 3349| | * Note that NS has precedence over DNAME if both exist 3350| | * in a zone. Otherwise DNAME take precedence over NS. 3351| | */ 3352| 0| found = ns_header; 3353| 0| search->zonecut_sigheader = NULL; 3354| 77| } else if (dname_header != NULL) { ------------------ | Branch (3354:13): [True: 0, False: 77] ------------------ 3355| 0| found = dname_header; 3356| 0| search->zonecut_sigheader = sigdname_header; 3357| 77| } else if (ns_header != NULL) { ------------------ | Branch (3357:13): [True: 0, False: 77] ------------------ 3358| 0| found = ns_header; 3359| 0| search->zonecut_sigheader = NULL; 3360| 0| } 3361| | 3362| 77| if (found != NULL) { ------------------ | Branch (3362:6): [True: 0, False: 77] ------------------ 3363| | /* 3364| | * We increment the reference count on node to ensure that 3365| | * search->zonecut_header will still be valid later. 3366| | */ 3367| 0| qpznode_acquire(node DNS__DB_FLARG_PASS); 3368| 0| search->zonecut = node; 3369| 0| search->zonecut_header = found; 3370| | /* 3371| | * Since we've found a zonecut, anything beneath it is 3372| | * glue and is not subject to wildcard matching, so we 3373| | * may clear search->wild. 3374| | */ 3375| 0| search->wild = false; 3376| 0| if ((search->options & DNS_DBFIND_GLUEOK) == 0) { ------------------ | Branch (3376:7): [True: 0, False: 0] ------------------ 3377| | /* 3378| | * If the caller does not want to find glue, then 3379| | * this is the best answer and the search should 3380| | * stop now. 3381| | */ 3382| 0| result = DNS_R_PARTIALMATCH; 3383| 0| } else { 3384| 0| dns_name_t *zcname = NULL; 3385| | 3386| | /* 3387| | * The search will continue beneath the zone cut. 3388| | * This may or may not be the best match. In case it 3389| | * is, we need to remember the node name. 3390| | */ 3391| 0| zcname = dns_fixedname_name(&search->zonecut_name); 3392| 0| dns_name_copy(&node->name, zcname); 3393| 0| search->copy_name = true; 3394| 0| } 3395| 77| } else { 3396| | /* 3397| | * There is no zonecut at this node which is active in this 3398| | * version. 3399| | * 3400| | * If this is a "wild" node and the caller hasn't disabled 3401| | * wildcard matching, remember that we've seen a wild node 3402| | * in case we need to go searching for wildcard matches 3403| | * later on. 3404| | */ 3405| 77| if (node->wild && (search->options & DNS_DBFIND_NOWILD) == 0) { ------------------ | Branch (3405:7): [True: 0, False: 77] | Branch (3405:21): [True: 0, False: 0] ------------------ 3406| 0| search->wild = true; 3407| 0| } 3408| 77| } 3409| | 3410| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 3411| | 3412| 77| return result; 3413| 77|} qpzone.c:step: 2799| 77| qpznode_t **node_p) { 2800| 77| REQUIRE(node_p != NULL && *node_p == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 2801| | 2802| 77| qpznode_t *node = NULL, *previous_node = NULL; 2803| 77| isc_result_t result = ISC_R_SUCCESS; 2804| | 2805| 77| result = dns_qpiter_current(it, (void **)&node, NULL); 2806| 231| while (result == ISC_R_SUCCESS) { ------------------ | Branch (2806:9): [True: 154, False: 77] ------------------ 2807| 154| previous_node = node; 2808| | 2809| 154| isc_rwlock_t *nlock = qpzone_get_lock(node); 2810| 154| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 2811| 154| dns_vecheader_t *found = NULL; 2812| | 2813| 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(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 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| } | | ------------------ ------------------ 2814| 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] | | | | ------------------ | | ------------------ ------------------ 2815| 0| found = first_existing_header(top, search->serial); 2816| 0| } 2817| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } ------------------ 2818| 154| if (found != NULL) { ------------------ | Branch (2818:7): [True: 0, False: 154] ------------------ 2819| 0| break; 2820| 0| } 2821| | 2822| 154| if (direction == FORWARD) { ------------------ | Branch (2822:7): [True: 154, False: 0] ------------------ 2823| 154| result = dns_qpiter_next(it, (void **)&node, NULL); 2824| 154| } else { 2825| 0| result = dns_qpiter_prev(it, (void **)&node, NULL); 2826| 0| } 2827| 154| }; 2828| | 2829| 77| if (result == ISC_R_SUCCESS) { ------------------ | Branch (2829:6): [True: 0, False: 77] ------------------ 2830| 0| if (previous_node != NULL) { ------------------ | Branch (2830:7): [True: 0, False: 0] ------------------ 2831| 0| *node_p = previous_node; 2832| 0| } 2833| 0| return true; 2834| 0| } 2835| | 2836| 77| return false; 2837| 77|} qpzone.c:activeempty: 2840| 77|activeempty(qpz_search_t *search, dns_qpiter_t *it, const dns_name_t *current) { 2841| 77| qpznode_t *next_node = NULL; 2842| | 2843| | /* 2844| | * The iterator is currently pointed at the predecessor 2845| | * of the name we were searching for. Step the iterator 2846| | * forward, then step() will continue forward until it 2847| | * finds a node with active data. If that node is a 2848| | * subdomain of the one we were looking for, then we're 2849| | * at an active empty nonterminal node. 2850| | */ 2851| 77| isc_result_t result = dns_qpiter_next(it, NULL, NULL); 2852| 77| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2852:6): [True: 0, False: 77] ------------------ 2853| | /* An ENT at the end of the zone is impossible */ 2854| 0| return false; 2855| 0| } 2856| 77| return step(search, it, FORWARD, &next_node) && ------------------ | Branch (2856:9): [True: 0, False: 77] ------------------ 2857| 0| dns_name_issubdomain(&next_node->name, current); ------------------ | Branch (2857:9): [True: 0, False: 0] ------------------ 2858| 77|} qpzone.c:setgluecachestats: 2568| 2|setgluecachestats(dns_db_t *db, isc_stats_t *stats) { 2569| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2570| | 2571| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2572| 2| REQUIRE(!IS_STUB(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 2573| 2| REQUIRE(stats != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 2574| | 2575| 2| isc_stats_attach(stats, &qpdb->gluecachestats); 2576| 2| return ISC_R_SUCCESS; 2577| 2|} qpzone.c:setmaxrrperset: 5449| 2|setmaxrrperset(dns_db_t *db, uint32_t value) { 5450| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 5451| | 5452| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 5453| | 5454| 2| qpdb->maxrrperset = value; 5455| 2|} qpzone.c:setmaxtypepername: 5458| 2|setmaxtypepername(dns_db_t *db, uint32_t value) { 5459| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 5460| | 5461| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 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))) | | ------------------ ------------------ 5462| | 5463| 2| qpdb->maxtypepername = value; 5464| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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'); ------------------ | | 202| 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.88k|dns_rdata_init(dns_rdata_t *rdata) { 801| 1.88k| REQUIRE(rdata != NULL); ------------------ | | 198| 1.88k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.88k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.88k, False: 0] | | | | ------------------ | | | | 43| 1.88k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 802| | 803| 1.88k| rdata->data = NULL; 804| 1.88k| rdata->length = 0; 805| 1.88k| rdata->rdclass = 0; 806| 1.88k| rdata->type = dns_rdatatype_none; ------------------ | | 114| 1.88k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 807| 1.88k| rdata->flags = 0; 808| 1.88k| ISC_LINK_INIT(rdata, link); ------------------ | | 57| 1.88k|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 1.88k| do { \ | | | | 54| 1.88k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 1.88k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 1.88k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 1.88k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 1.88k| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 1.88k] | | | | ------------------ | | ------------------ ------------------ 809| | /* ISC_LIST_INIT(rdata->list); */ 810| 1.88k|} dns_rdata_reset: 813| 579|dns_rdata_reset(dns_rdata_t *rdata) { 814| 579| REQUIRE(rdata != NULL); ------------------ | | 198| 579|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 579| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 579, False: 0] | | | | ------------------ | | | | 43| 579| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 815| | 816| 579| REQUIRE(!ISC_LINK_LINKED(rdata, link)); ------------------ | | 198| 579|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 579| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 579, False: 0] | | | | ------------------ | | | | 43| 579| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 817| 579| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 579|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 579| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 579, False: 0] | | | | ------------------ | | | | 43| 579| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 818| | 819| 579| rdata->data = NULL; 820| 579| rdata->length = 0; 821| 579| rdata->rdclass = 0; 822| 579| rdata->type = dns_rdatatype_none; ------------------ | | 114| 579|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 823| 579| rdata->flags = 0; 824| 579|} dns_rdata_clone: 831| 1.27k|dns_rdata_clone(const dns_rdata_t *src, dns_rdata_t *target) { 832| 1.27k| REQUIRE(src != NULL); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 833| 1.27k| REQUIRE(target != NULL); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 834| | 835| 1.27k| REQUIRE(DNS_RDATA_INITIALIZED(target)); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | | Branch (42:11): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 836| | 837| 1.27k| REQUIRE(DNS_RDATA_VALIDFLAGS(src)); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 838| 1.27k| REQUIRE(DNS_RDATA_VALIDFLAGS(target)); ------------------ | | 198| 1.27k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.27k, False: 0] | | | | ------------------ | | | | 43| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 839| | 840| 1.27k| target->data = src->data; 841| 1.27k| target->length = src->length; 842| 1.27k| target->rdclass = src->rdclass; 843| 1.27k| target->type = src->type; 844| 1.27k| target->flags = src->flags; 845| 1.27k|} dns_rdata_fromregion: 923| 1.46k| dns_rdatatype_t type, isc_region_t *r) { 924| 1.46k| REQUIRE(rdata != NULL); ------------------ | | 198| 1.46k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.46k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.46k, False: 0] | | | | ------------------ | | | | 43| 1.46k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 925| 1.46k| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 198| 1.46k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 14.6k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.46k, False: 0] | | | | | Branch (42:11): [True: 1.46k, False: 0] | | | | | Branch (42:11): [True: 1.46k, False: 0] | | | | | Branch (42:11): [True: 1.46k, False: 0] | | | | | Branch (42:11): [True: 1.46k, False: 0] | | | | | Branch (42:11): [True: 1.46k, False: 0] | | | | ------------------ | | | | 43| 1.46k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 926| 1.46k| REQUIRE(r != NULL); ------------------ | | 198| 1.46k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.46k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.46k, False: 0] | | | | ------------------ | | | | 43| 1.46k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 927| | 928| 1.46k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 1.46k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.46k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.46k, False: 0] | | | | ------------------ | | | | 43| 1.46k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 929| | 930| 1.46k| rdata->data = r->base; 931| 1.46k| rdata->length = r->length; 932| 1.46k| rdata->rdclass = rdclass; 933| 1.46k| rdata->type = type; 934| 1.46k| rdata->flags = 0; 935| 1.46k|} dns_rdata_toregion: 938| 2.16k|dns_rdata_toregion(const dns_rdata_t *rdata, isc_region_t *r) { 939| 2.16k| REQUIRE(rdata != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 940| 2.16k| REQUIRE(r != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 941| 2.16k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 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))) | | ------------------ ------------------ 942| | 943| 2.16k| r->base = rdata->data; 944| 2.16k| r->length = rdata->length; 945| 2.16k|} dns_rdata_fromwire: 950| 2.03k| dns_decompress_t dctx, isc_buffer_t *target) { 951| 2.03k| isc_result_t result = ISC_R_NOTIMPLEMENTED; 952| 2.03k| isc_region_t region; 953| 2.03k| isc_buffer_t ss; 954| 2.03k| isc_buffer_t st; 955| 2.03k| bool use_default = false; 956| 2.03k| uint32_t activelength; 957| 2.03k| unsigned int length; 958| | 959| 2.03k| if (rdata != NULL) { ------------------ | Branch (959:6): [True: 2.03k, False: 0] ------------------ 960| 2.03k| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 198| 2.03k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20.3k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.03k, False: 0] | | | | | Branch (42:11): [True: 2.03k, False: 0] | | | | | Branch (42:11): [True: 2.03k, False: 0] | | | | | Branch (42:11): [True: 2.03k, False: 0] | | | | | Branch (42:11): [True: 2.03k, False: 0] | | | | | Branch (42:11): [True: 2.03k, False: 0] | | | | ------------------ | | | | 43| 2.03k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 961| 2.03k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 2.03k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.03k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.03k, False: 0] | | | | ------------------ | | | | 43| 2.03k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 962| 2.03k| } 963| 2.03k| REQUIRE(source != NULL); ------------------ | | 198| 2.03k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.03k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.03k, False: 0] | | | | ------------------ | | | | 43| 2.03k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 964| 2.03k| REQUIRE(target != NULL); ------------------ | | 198| 2.03k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.03k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.03k, False: 0] | | | | ------------------ | | | | 43| 2.03k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 965| | 966| 2.03k| if (type == dns_rdatatype_none) { ------------------ | | 114| 2.03k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (966:6): [True: 0, False: 2.03k] ------------------ 967| 0| return DNS_R_FORMERR; 968| 0| } 969| | 970| 2.03k| ss = *source; 971| 2.03k| st = *target; 972| | 973| 2.03k| activelength = isc_buffer_activelength(source); ------------------ | | 160| 2.03k|#define isc_buffer_activelength(b) ((b)->active - (b)->current) /* c-b */ ------------------ 974| 2.03k| INSIST(activelength < 65536); ------------------ | | 202| 2.03k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2.03k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2.03k, False: 0] | | | | ------------------ | | | | 55| 2.03k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 975| | 976| 2.03k| FROMWIRESWITCH ------------------ | | 438| 2.03k| switch (type) { \ | | 439| 0| case 1: switch (rdclass) { \ | | ------------------ | | | Branch (439:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 447| 0| case 3: result = fromwire_md(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (447:2): [True: 0, False: 2.03k] | | ------------------ | | 448| 0| case 4: result = fromwire_mf(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (448:2): [True: 0, False: 2.03k] | | ------------------ | | 449| 0| case 5: result = fromwire_cname(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (449:2): [True: 0, False: 2.03k] | | ------------------ | | 450| 0| case 6: result = fromwire_soa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (450:2): [True: 0, False: 2.03k] | | ------------------ | | 451| 0| case 7: result = fromwire_mb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (451:2): [True: 0, False: 2.03k] | | ------------------ | | 452| 0| case 8: result = fromwire_mg(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (452:2): [True: 0, False: 2.03k] | | ------------------ | | 453| 0| case 9: result = fromwire_mr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (453:2): [True: 0, False: 2.03k] | | ------------------ | | 454| 0| case 10: result = fromwire_null(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (454:2): [True: 0, False: 2.03k] | | ------------------ | | 455| 0| case 11: switch (rdclass) { \ | | ------------------ | | | Branch (455:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 461| 0| case 13: result = fromwire_hinfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (461:2): [True: 0, False: 2.03k] | | ------------------ | | 462| 0| case 14: result = fromwire_minfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (462:2): [True: 0, False: 2.03k] | | ------------------ | | 463| 0| case 15: result = fromwire_mx(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (463:2): [True: 0, False: 2.03k] | | ------------------ | | 464| 0| case 16: result = fromwire_txt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (464:2): [True: 0, False: 2.03k] | | ------------------ | | 465| 0| case 17: result = fromwire_rp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (465:2): [True: 0, False: 2.03k] | | ------------------ | | 466| 0| case 18: result = fromwire_afsdb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (466:2): [True: 0, False: 2.03k] | | ------------------ | | 467| 0| case 19: result = fromwire_x25(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (467:2): [True: 0, False: 2.03k] | | ------------------ | | 468| 0| case 20: result = fromwire_isdn(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (468:2): [True: 0, False: 2.03k] | | ------------------ | | 469| 0| case 21: result = fromwire_rt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (469:2): [True: 0, False: 2.03k] | | ------------------ | | 470| 0| case 22: switch (rdclass) { \ | | ------------------ | | | Branch (470:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 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| 851| case 24: result = fromwire_sig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (480:2): [True: 851, False: 1.18k] | | ------------------ | | 481| 0| case 25: result = fromwire_key(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (481:2): [True: 0, False: 2.03k] | | ------------------ | | 482| 0| case 26: switch (rdclass) { \ | | ------------------ | | | Branch (482:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 488| 0| case 28: switch (rdclass) { \ | | ------------------ | | | Branch (488:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 494| 0| case 30: result = fromwire_nxt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (494:2): [True: 0, False: 2.03k] | | ------------------ | | 495| 0| case 31: switch (rdclass) { \ | | ------------------ | | | Branch (495:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 516| 0| case 36: switch (rdclass) { \ | | ------------------ | | | Branch (516:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 522| 0| case 38: switch (rdclass) { \ | | ------------------ | | | Branch (522:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 528| 0| case 40: result = fromwire_sink(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (528:2): [True: 0, False: 2.03k] | | ------------------ | | 529| 0| case 41: result = fromwire_opt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (529:2): [True: 0, False: 2.03k] | | ------------------ | | 530| 0| case 42: switch (rdclass) { \ | | ------------------ | | | Branch (530:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 536| 0| case 44: result = fromwire_sshfp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (536:2): [True: 0, False: 2.03k] | | ------------------ | | 537| 0| case 45: result = fromwire_ipseckey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (537:2): [True: 0, False: 2.03k] | | ------------------ | | 538| 0| case 46: result = fromwire_rrsig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (538:2): [True: 0, False: 2.03k] | | ------------------ | | 539| 0| case 47: result = fromwire_nsec(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (539:2): [True: 0, False: 2.03k] | | ------------------ | | 540| 0| case 48: result = fromwire_dnskey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (540:2): [True: 0, False: 2.03k] | | ------------------ | | 541| 0| case 49: switch (rdclass) { \ | | ------------------ | | | Branch (541:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 547| 0| case 51: result = fromwire_nsec3param(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (547:2): [True: 0, False: 2.03k] | | ------------------ | | 548| 0| case 52: result = fromwire_tlsa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (548:2): [True: 0, False: 2.03k] | | ------------------ | | 549| 0| case 53: result = fromwire_smimea(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (549:2): [True: 0, False: 2.03k] | | ------------------ | | 550| 0| case 55: result = fromwire_hip(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (550:2): [True: 0, False: 2.03k] | | ------------------ | | 551| 0| case 56: result = fromwire_ninfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (551:2): [True: 0, False: 2.03k] | | ------------------ | | 552| 0| case 57: result = fromwire_rkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (552:2): [True: 0, False: 2.03k] | | ------------------ | | 553| 0| case 58: result = fromwire_talink(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (553:2): [True: 0, False: 2.03k] | | ------------------ | | 554| 0| case 59: result = fromwire_cds(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (554:2): [True: 0, False: 2.03k] | | ------------------ | | 555| 0| case 60: result = fromwire_cdnskey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (555:2): [True: 0, False: 2.03k] | | ------------------ | | 556| 0| case 61: result = fromwire_openpgpkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (556:2): [True: 0, False: 2.03k] | | ------------------ | | 557| 0| case 62: result = fromwire_csync(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (557:2): [True: 0, False: 2.03k] | | ------------------ | | 558| 0| case 63: result = fromwire_zonemd(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (558:2): [True: 0, False: 2.03k] | | ------------------ | | 559| 0| case 64: switch (rdclass) { \ | | ------------------ | | | Branch (559:2): [True: 0, False: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 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: 2.03k] | | ------------------ | | 570| 0| case 67: result = fromwire_hhit(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (570:2): [True: 0, False: 2.03k] | | ------------------ | | 571| 0| case 68: result = fromwire_brid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (571:2): [True: 0, False: 2.03k] | | ------------------ | | 572| 0| case 99: result = fromwire_spf(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (572:2): [True: 0, False: 2.03k] | | ------------------ | | 573| 0| case 104: result = fromwire_nid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (573:2): [True: 0, False: 2.03k] | | ------------------ | | 574| 0| case 105: result = fromwire_l32(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (574:2): [True: 0, False: 2.03k] | | ------------------ | | 575| 0| case 106: result = fromwire_l64(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (575:2): [True: 0, False: 2.03k] | | ------------------ | | 576| 0| case 107: result = fromwire_lp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (576:2): [True: 0, False: 2.03k] | | ------------------ | | 577| 0| case 108: result = fromwire_eui48(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (577:2): [True: 0, False: 2.03k] | | ------------------ | | 578| 0| case 109: result = fromwire_eui64(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (578:2): [True: 0, False: 2.03k] | | ------------------ | | 579| 0| case 249: result = fromwire_tkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (579:2): [True: 0, False: 2.03k] | | ------------------ | | 580| 1.18k| case 250: switch (rdclass) { \ | | ------------------ | | | Branch (580:2): [True: 1.18k, False: 851] | | ------------------ | | 581| 1.18k| case 255: result = fromwire_any_tsig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (581:3): [True: 1.18k, False: 0] | | ------------------ | | 582| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (582:3): [True: 0, False: 1.18k] | | ------------------ | | 583| 1.18k| } \ | | 584| 1.18k| break; \ | | 585| 1.18k| case 256: result = fromwire_uri(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (585:2): [True: 0, False: 2.03k] | | ------------------ | | 586| 1.18k| case 257: result = fromwire_caa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (586:2): [True: 0, False: 2.03k] | | ------------------ | | 587| 1.18k| case 258: result = fromwire_avc(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (587:2): [True: 0, False: 2.03k] | | ------------------ | | 588| 1.18k| case 259: result = fromwire_doa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (588:2): [True: 0, False: 2.03k] | | ------------------ | | 589| 1.18k| case 260: result = fromwire_amtrelay(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (589:2): [True: 0, False: 2.03k] | | ------------------ | | 590| 1.18k| case 261: result = fromwire_resinfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (590:2): [True: 0, False: 2.03k] | | ------------------ | | 591| 1.18k| case 262: result = fromwire_wallet(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (591:2): [True: 0, False: 2.03k] | | ------------------ | | 592| 1.18k| case 32768: result = fromwire_ta(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (592:2): [True: 0, False: 2.03k] | | ------------------ | | 593| 1.18k| case 32769: result = fromwire_dlv(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (593:2): [True: 0, False: 2.03k] | | ------------------ | | 594| 1.18k| case 65533: result = fromwire_keydata(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (594:2): [True: 0, False: 2.03k] | | ------------------ | | 595| 1.18k| default: use_default = true; break; \ | | ------------------ | | | Branch (595:2): [True: 0, False: 2.03k] | | ------------------ | | 596| 2.03k| } ------------------ 977| | 978| 2.03k| if (use_default) { ------------------ | Branch (978:6): [True: 0, False: 2.03k] ------------------ 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| 2.03k| length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 157| 2.03k|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 157| 2.03k|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 994| 2.03k| if (result == ISC_R_SUCCESS && length > DNS_RDATA_MAXLENGTH) { ------------------ | | 181| 1.25k|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (994:6): [True: 1.25k, False: 781] | Branch (994:33): [True: 8, False: 1.25k] ------------------ 995| 8| result = DNS_R_FORMERR; 996| 8| } 997| | 998| | /* 999| | * We should have consumed all of our buffer. 1000| | */ 1001| 2.03k| if (result == ISC_R_SUCCESS && !buffer_empty(source)) { ------------------ | Branch (1001:6): [True: 1.25k, False: 789] | Branch (1001:33): [True: 114, False: 1.13k] ------------------ 1002| 114| result = DNS_R_EXTRADATA; 1003| 114| } 1004| | 1005| 2.03k| if (rdata != NULL && result == ISC_R_SUCCESS) { ------------------ | Branch (1005:6): [True: 2.03k, False: 0] | Branch (1005:23): [True: 1.13k, False: 903] ------------------ 1006| 1.13k| region.base = isc_buffer_used(&st); ------------------ | | 149| 1.13k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1007| 1.13k| region.length = length; 1008| 1.13k| dns_rdata_fromregion(rdata, rdclass, type, ®ion); 1009| 1.13k| } 1010| | 1011| 2.03k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1011:6): [True: 903, False: 1.13k] ------------------ 1012| 903| *source = ss; 1013| 903| *target = st; 1014| 903| } 1015| 2.03k| return result; 1016| 2.03k|} 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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.39k|dns_rdata_tostruct(const dns_rdata_t *rdata, void *target, isc_mem_t *mctx) { 1415| 1.39k| isc_result_t result = ISC_R_NOTIMPLEMENTED; 1416| 1.39k| bool use_default = false; 1417| | 1418| 1.39k| REQUIRE(rdata != NULL); ------------------ | | 198| 1.39k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.39k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.39k, False: 0] | | | | ------------------ | | | | 43| 1.39k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1419| 1.39k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 1.39k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.39k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.39k, False: 0] | | | | ------------------ | | | | 43| 1.39k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1420| 1.39k| REQUIRE((rdata->flags & DNS_RDATA_UPDATE) == 0); ------------------ | | 198| 1.39k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.39k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.39k, False: 0] | | | | ------------------ | | | | 43| 1.39k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1421| | 1422| 1.39k| TOSTRUCTSWITCH ------------------ | | 1243| 1.39k| switch (rdata->type) { \ | | 1244| 0| case 1: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1244:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1252| 0| case 3: result = tostruct_md(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1252:2): [True: 0, False: 1.39k] | | ------------------ | | 1253| 0| case 4: result = tostruct_mf(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1253:2): [True: 0, False: 1.39k] | | ------------------ | | 1254| 0| case 5: result = tostruct_cname(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1254:2): [True: 0, False: 1.39k] | | ------------------ | | 1255| 2| case 6: result = tostruct_soa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1255:2): [True: 2, False: 1.39k] | | ------------------ | | 1256| 0| case 7: result = tostruct_mb(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1256:2): [True: 0, False: 1.39k] | | ------------------ | | 1257| 0| case 8: result = tostruct_mg(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1257:2): [True: 0, False: 1.39k] | | ------------------ | | 1258| 0| case 9: result = tostruct_mr(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1258:2): [True: 0, False: 1.39k] | | ------------------ | | 1259| 0| case 10: result = tostruct_null(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1259:2): [True: 0, False: 1.39k] | | ------------------ | | 1260| 0| case 11: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1260:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1266| 0| case 13: result = tostruct_hinfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1266:2): [True: 0, False: 1.39k] | | ------------------ | | 1267| 0| case 14: result = tostruct_minfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1267:2): [True: 0, False: 1.39k] | | ------------------ | | 1268| 0| case 15: result = tostruct_mx(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1268:2): [True: 0, False: 1.39k] | | ------------------ | | 1269| 0| case 16: result = tostruct_txt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1269:2): [True: 0, False: 1.39k] | | ------------------ | | 1270| 0| case 17: result = tostruct_rp(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1270:2): [True: 0, False: 1.39k] | | ------------------ | | 1271| 0| case 18: result = tostruct_afsdb(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1271:2): [True: 0, False: 1.39k] | | ------------------ | | 1272| 0| case 19: result = tostruct_x25(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1272:2): [True: 0, False: 1.39k] | | ------------------ | | 1273| 0| case 20: result = tostruct_isdn(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1273:2): [True: 0, False: 1.39k] | | ------------------ | | 1274| 0| case 21: result = tostruct_rt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1274:2): [True: 0, False: 1.39k] | | ------------------ | | 1275| 0| case 22: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1275:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 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| 542| case 24: result = tostruct_sig(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1285:2): [True: 542, False: 853] | | ------------------ | | 1286| 123| case 25: result = tostruct_key(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1286:2): [True: 123, False: 1.27k] | | ------------------ | | 1287| 0| case 26: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1287:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1293| 0| case 28: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1293:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1299| 0| case 30: result = tostruct_nxt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1299:2): [True: 0, False: 1.39k] | | ------------------ | | 1300| 0| case 31: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1300:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 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.39k] | | ------------------ | | 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.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1321| 0| case 36: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1321:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1327| 0| case 38: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1327:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1333| 0| case 40: result = tostruct_sink(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1333:2): [True: 0, False: 1.39k] | | ------------------ | | 1334| 0| case 41: result = tostruct_opt(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1334:2): [True: 0, False: 1.39k] | | ------------------ | | 1335| 0| case 42: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1335:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1341| 0| case 44: result = tostruct_sshfp(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1341:2): [True: 0, False: 1.39k] | | ------------------ | | 1342| 0| case 45: result = tostruct_ipseckey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1342:2): [True: 0, False: 1.39k] | | ------------------ | | 1343| 0| case 46: result = tostruct_rrsig(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1343:2): [True: 0, False: 1.39k] | | ------------------ | | 1344| 0| case 47: result = tostruct_nsec(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1344:2): [True: 0, False: 1.39k] | | ------------------ | | 1345| 0| case 48: result = tostruct_dnskey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1345:2): [True: 0, False: 1.39k] | | ------------------ | | 1346| 0| case 49: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1346:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1352| 0| case 51: result = tostruct_nsec3param(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1352:2): [True: 0, False: 1.39k] | | ------------------ | | 1353| 0| case 52: result = tostruct_tlsa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1353:2): [True: 0, False: 1.39k] | | ------------------ | | 1354| 0| case 53: result = tostruct_smimea(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1354:2): [True: 0, False: 1.39k] | | ------------------ | | 1355| 0| case 55: result = tostruct_hip(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1355:2): [True: 0, False: 1.39k] | | ------------------ | | 1356| 0| case 56: result = tostruct_ninfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1356:2): [True: 0, False: 1.39k] | | ------------------ | | 1357| 0| case 57: result = tostruct_rkey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1357:2): [True: 0, False: 1.39k] | | ------------------ | | 1358| 0| case 58: result = tostruct_talink(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1358:2): [True: 0, False: 1.39k] | | ------------------ | | 1359| 0| case 59: result = tostruct_cds(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1359:2): [True: 0, False: 1.39k] | | ------------------ | | 1360| 0| case 60: result = tostruct_cdnskey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1360:2): [True: 0, False: 1.39k] | | ------------------ | | 1361| 0| case 61: result = tostruct_openpgpkey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1361:2): [True: 0, False: 1.39k] | | ------------------ | | 1362| 0| case 62: result = tostruct_csync(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1362:2): [True: 0, False: 1.39k] | | ------------------ | | 1363| 0| case 63: result = tostruct_zonemd(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1363:2): [True: 0, False: 1.39k] | | ------------------ | | 1364| 0| case 64: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1364:2): [True: 0, False: 1.39k] | | ------------------ | | 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.39k] | | ------------------ | | 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.39k] | | ------------------ | | 1375| 0| case 67: result = tostruct_hhit(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1375:2): [True: 0, False: 1.39k] | | ------------------ | | 1376| 0| case 68: result = tostruct_brid(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1376:2): [True: 0, False: 1.39k] | | ------------------ | | 1377| 0| case 99: result = tostruct_spf(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1377:2): [True: 0, False: 1.39k] | | ------------------ | | 1378| 0| case 104: result = tostruct_nid(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1378:2): [True: 0, False: 1.39k] | | ------------------ | | 1379| 0| case 105: result = tostruct_l32(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1379:2): [True: 0, False: 1.39k] | | ------------------ | | 1380| 0| case 106: result = tostruct_l64(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1380:2): [True: 0, False: 1.39k] | | ------------------ | | 1381| 0| case 107: result = tostruct_lp(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1381:2): [True: 0, False: 1.39k] | | ------------------ | | 1382| 0| case 108: result = tostruct_eui48(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1382:2): [True: 0, False: 1.39k] | | ------------------ | | 1383| 0| case 109: result = tostruct_eui64(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1383:2): [True: 0, False: 1.39k] | | ------------------ | | 1384| 0| case 249: result = tostruct_tkey(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1384:2): [True: 0, False: 1.39k] | | ------------------ | | 1385| 726| case 250: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1385:2): [True: 726, False: 669] | | ------------------ | | 1386| 726| case 255: result = tostruct_any_tsig(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1386:3): [True: 726, False: 0] | | ------------------ | | 1387| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1387:3): [True: 0, False: 726] | | ------------------ | | 1388| 726| } \ | | 1389| 726| break; \ | | 1390| 726| case 256: result = tostruct_uri(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1390:2): [True: 0, False: 1.39k] | | ------------------ | | 1391| 726| case 257: result = tostruct_caa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1391:2): [True: 0, False: 1.39k] | | ------------------ | | 1392| 726| case 258: result = tostruct_avc(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1392:2): [True: 0, False: 1.39k] | | ------------------ | | 1393| 726| case 259: result = tostruct_doa(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1393:2): [True: 0, False: 1.39k] | | ------------------ | | 1394| 726| case 260: result = tostruct_amtrelay(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1394:2): [True: 0, False: 1.39k] | | ------------------ | | 1395| 726| case 261: result = tostruct_resinfo(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1395:2): [True: 0, False: 1.39k] | | ------------------ | | 1396| 726| case 262: result = tostruct_wallet(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1396:2): [True: 0, False: 1.39k] | | ------------------ | | 1397| 726| case 32768: result = tostruct_ta(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1397:2): [True: 0, False: 1.39k] | | ------------------ | | 1398| 726| case 32769: result = tostruct_dlv(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1398:2): [True: 0, False: 1.39k] | | ------------------ | | 1399| 726| case 65533: result = tostruct_keydata(rdata, target, mctx); break; \ | | ------------------ | | | Branch (1399:2): [True: 0, False: 1.39k] | | ------------------ | | 1400| 726| default: use_default = true; break; \ | | ------------------ | | | Branch (1400:2): [True: 0, False: 1.39k] | | ------------------ | | 1401| 1.39k| } ------------------ 1423| | 1424| 1.39k| if (use_default) { ------------------ | Branch (1424:6): [True: 0, False: 1.39k] ------------------ 1425| 0| (void)NULL; 1426| 0| } 1427| | 1428| 1.39k| return result; 1429| 1.39k|} dns_rdata_freestruct: 1432| 542|dns_rdata_freestruct(void *source) { 1433| 542| dns_rdatacommon_t *common = source; 1434| 542| REQUIRE(common != NULL); ------------------ | | 198| 542|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 542| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 542, False: 0] | | | | ------------------ | | | | 43| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1435| | 1436| 542| FREESTRUCTSWITCH ------------------ | | 1404| 542| switch (common->rdtype) { \ | | 1405| 0| case 1: switch (common->rdclass) { \ | | ------------------ | | | Branch (1405:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1413| 0| case 3: freestruct_md(source); break; \ | | ------------------ | | | Branch (1413:2): [True: 0, False: 542] | | ------------------ | | 1414| 0| case 4: freestruct_mf(source); break; \ | | ------------------ | | | Branch (1414:2): [True: 0, False: 542] | | ------------------ | | 1415| 0| case 5: freestruct_cname(source); break; \ | | ------------------ | | | Branch (1415:2): [True: 0, False: 542] | | ------------------ | | 1416| 0| case 6: freestruct_soa(source); break; \ | | ------------------ | | | Branch (1416:2): [True: 0, False: 542] | | ------------------ | | 1417| 0| case 7: freestruct_mb(source); break; \ | | ------------------ | | | Branch (1417:2): [True: 0, False: 542] | | ------------------ | | 1418| 0| case 8: freestruct_mg(source); break; \ | | ------------------ | | | Branch (1418:2): [True: 0, False: 542] | | ------------------ | | 1419| 0| case 9: freestruct_mr(source); break; \ | | ------------------ | | | Branch (1419:2): [True: 0, False: 542] | | ------------------ | | 1420| 0| case 10: freestruct_null(source); break; \ | | ------------------ | | | Branch (1420:2): [True: 0, False: 542] | | ------------------ | | 1421| 0| case 11: switch (common->rdclass) { \ | | ------------------ | | | Branch (1421:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1427| 0| case 13: freestruct_hinfo(source); break; \ | | ------------------ | | | Branch (1427:2): [True: 0, False: 542] | | ------------------ | | 1428| 0| case 14: freestruct_minfo(source); break; \ | | ------------------ | | | Branch (1428:2): [True: 0, False: 542] | | ------------------ | | 1429| 0| case 15: freestruct_mx(source); break; \ | | ------------------ | | | Branch (1429:2): [True: 0, False: 542] | | ------------------ | | 1430| 0| case 16: freestruct_txt(source); break; \ | | ------------------ | | | Branch (1430:2): [True: 0, False: 542] | | ------------------ | | 1431| 0| case 17: freestruct_rp(source); break; \ | | ------------------ | | | Branch (1431:2): [True: 0, False: 542] | | ------------------ | | 1432| 0| case 18: freestruct_afsdb(source); break; \ | | ------------------ | | | Branch (1432:2): [True: 0, False: 542] | | ------------------ | | 1433| 0| case 19: freestruct_x25(source); break; \ | | ------------------ | | | Branch (1433:2): [True: 0, False: 542] | | ------------------ | | 1434| 0| case 20: freestruct_isdn(source); break; \ | | ------------------ | | | Branch (1434:2): [True: 0, False: 542] | | ------------------ | | 1435| 0| case 21: freestruct_rt(source); break; \ | | ------------------ | | | Branch (1435:2): [True: 0, False: 542] | | ------------------ | | 1436| 0| case 22: switch (common->rdclass) { \ | | ------------------ | | | Branch (1436:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 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| 542| case 24: freestruct_sig(source); break; \ | | ------------------ | | | Branch (1446:2): [True: 542, False: 0] | | ------------------ | | 1447| 0| case 25: freestruct_key(source); break; \ | | ------------------ | | | Branch (1447:2): [True: 0, False: 542] | | ------------------ | | 1448| 0| case 26: switch (common->rdclass) { \ | | ------------------ | | | Branch (1448:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1454| 0| case 28: switch (common->rdclass) { \ | | ------------------ | | | Branch (1454:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1460| 0| case 30: freestruct_nxt(source); break; \ | | ------------------ | | | Branch (1460:2): [True: 0, False: 542] | | ------------------ | | 1461| 0| case 31: switch (common->rdclass) { \ | | ------------------ | | | Branch (1461:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 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: 542] | | ------------------ | | 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: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1482| 0| case 36: switch (common->rdclass) { \ | | ------------------ | | | Branch (1482:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1488| 0| case 38: switch (common->rdclass) { \ | | ------------------ | | | Branch (1488:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1494| 0| case 40: freestruct_sink(source); break; \ | | ------------------ | | | Branch (1494:2): [True: 0, False: 542] | | ------------------ | | 1495| 0| case 41: freestruct_opt(source); break; \ | | ------------------ | | | Branch (1495:2): [True: 0, False: 542] | | ------------------ | | 1496| 0| case 42: switch (common->rdclass) { \ | | ------------------ | | | Branch (1496:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1502| 0| case 44: freestruct_sshfp(source); break; \ | | ------------------ | | | Branch (1502:2): [True: 0, False: 542] | | ------------------ | | 1503| 0| case 45: freestruct_ipseckey(source); break; \ | | ------------------ | | | Branch (1503:2): [True: 0, False: 542] | | ------------------ | | 1504| 0| case 46: freestruct_rrsig(source); break; \ | | ------------------ | | | Branch (1504:2): [True: 0, False: 542] | | ------------------ | | 1505| 0| case 47: freestruct_nsec(source); break; \ | | ------------------ | | | Branch (1505:2): [True: 0, False: 542] | | ------------------ | | 1506| 0| case 48: freestruct_dnskey(source); break; \ | | ------------------ | | | Branch (1506:2): [True: 0, False: 542] | | ------------------ | | 1507| 0| case 49: switch (common->rdclass) { \ | | ------------------ | | | Branch (1507:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1513| 0| case 51: freestruct_nsec3param(source); break; \ | | ------------------ | | | Branch (1513:2): [True: 0, False: 542] | | ------------------ | | 1514| 0| case 52: freestruct_tlsa(source); break; \ | | ------------------ | | | Branch (1514:2): [True: 0, False: 542] | | ------------------ | | 1515| 0| case 53: freestruct_smimea(source); break; \ | | ------------------ | | | Branch (1515:2): [True: 0, False: 542] | | ------------------ | | 1516| 0| case 55: freestruct_hip(source); break; \ | | ------------------ | | | Branch (1516:2): [True: 0, False: 542] | | ------------------ | | 1517| 0| case 56: freestruct_ninfo(source); break; \ | | ------------------ | | | Branch (1517:2): [True: 0, False: 542] | | ------------------ | | 1518| 0| case 57: freestruct_rkey(source); break; \ | | ------------------ | | | Branch (1518:2): [True: 0, False: 542] | | ------------------ | | 1519| 0| case 58: freestruct_talink(source); break; \ | | ------------------ | | | Branch (1519:2): [True: 0, False: 542] | | ------------------ | | 1520| 0| case 59: freestruct_cds(source); break; \ | | ------------------ | | | Branch (1520:2): [True: 0, False: 542] | | ------------------ | | 1521| 0| case 60: freestruct_cdnskey(source); break; \ | | ------------------ | | | Branch (1521:2): [True: 0, False: 542] | | ------------------ | | 1522| 0| case 61: freestruct_openpgpkey(source); break; \ | | ------------------ | | | Branch (1522:2): [True: 0, False: 542] | | ------------------ | | 1523| 0| case 62: freestruct_csync(source); break; \ | | ------------------ | | | Branch (1523:2): [True: 0, False: 542] | | ------------------ | | 1524| 0| case 63: freestruct_zonemd(source); break; \ | | ------------------ | | | Branch (1524:2): [True: 0, False: 542] | | ------------------ | | 1525| 0| case 64: switch (common->rdclass) { \ | | ------------------ | | | Branch (1525:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1536| 0| case 67: freestruct_hhit(source); break; \ | | ------------------ | | | Branch (1536:2): [True: 0, False: 542] | | ------------------ | | 1537| 0| case 68: freestruct_brid(source); break; \ | | ------------------ | | | Branch (1537:2): [True: 0, False: 542] | | ------------------ | | 1538| 0| case 99: freestruct_spf(source); break; \ | | ------------------ | | | Branch (1538:2): [True: 0, False: 542] | | ------------------ | | 1539| 0| case 104: freestruct_nid(source); break; \ | | ------------------ | | | Branch (1539:2): [True: 0, False: 542] | | ------------------ | | 1540| 0| case 105: freestruct_l32(source); break; \ | | ------------------ | | | Branch (1540:2): [True: 0, False: 542] | | ------------------ | | 1541| 0| case 106: freestruct_l64(source); break; \ | | ------------------ | | | Branch (1541:2): [True: 0, False: 542] | | ------------------ | | 1542| 0| case 107: freestruct_lp(source); break; \ | | ------------------ | | | Branch (1542:2): [True: 0, False: 542] | | ------------------ | | 1543| 0| case 108: freestruct_eui48(source); break; \ | | ------------------ | | | Branch (1543:2): [True: 0, False: 542] | | ------------------ | | 1544| 0| case 109: freestruct_eui64(source); break; \ | | ------------------ | | | Branch (1544:2): [True: 0, False: 542] | | ------------------ | | 1545| 0| case 249: freestruct_tkey(source); break; \ | | ------------------ | | | Branch (1545:2): [True: 0, False: 542] | | ------------------ | | 1546| 0| case 250: switch (common->rdclass) { \ | | ------------------ | | | Branch (1546:2): [True: 0, False: 542] | | ------------------ | | 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: 542] | | ------------------ | | 1552| 0| case 257: freestruct_caa(source); break; \ | | ------------------ | | | Branch (1552:2): [True: 0, False: 542] | | ------------------ | | 1553| 0| case 258: freestruct_avc(source); break; \ | | ------------------ | | | Branch (1553:2): [True: 0, False: 542] | | ------------------ | | 1554| 0| case 259: freestruct_doa(source); break; \ | | ------------------ | | | Branch (1554:2): [True: 0, False: 542] | | ------------------ | | 1555| 0| case 260: freestruct_amtrelay(source); break; \ | | ------------------ | | | Branch (1555:2): [True: 0, False: 542] | | ------------------ | | 1556| 0| case 261: freestruct_resinfo(source); break; \ | | ------------------ | | | Branch (1556:2): [True: 0, False: 542] | | ------------------ | | 1557| 0| case 262: freestruct_wallet(source); break; \ | | ------------------ | | | Branch (1557:2): [True: 0, False: 542] | | ------------------ | | 1558| 0| case 32768: freestruct_ta(source); break; \ | | ------------------ | | | Branch (1558:2): [True: 0, False: 542] | | ------------------ | | 1559| 0| case 32769: freestruct_dlv(source); break; \ | | ------------------ | | | Branch (1559:2): [True: 0, False: 542] | | ------------------ | | 1560| 0| case 65533: freestruct_keydata(source); break; \ | | ------------------ | | | Branch (1560:2): [True: 0, False: 542] | | ------------------ | | 1561| 0| default: break; \ | | ------------------ | | | Branch (1561:2): [True: 0, False: 542] | | ------------------ | | 1562| 542| } ------------------ 1437| 542|} dns_rdatatype_attributes: 1507| 102|dns_rdatatype_attributes(dns_rdatatype_t type) { 1508| 102| RDATATYPE_ATTRIBUTE_SW ------------------ | | 2467| 102| switch (type) { \ | | ------------------ | | | Branch (2467:10): [True: 102, False: 0] | | ------------------ | | 2468| 0| case 1: return (RRTYPE_A_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_A_ATTRIBUTES (0) | | ------------------ | | | Branch (2468:2): [True: 0, False: 102] | | ------------------ | | 2469| 6| case 2: return (RRTYPE_NS_ATTRIBUTES); \ | | ------------------ | | | | 17| 6|#define RRTYPE_NS_ATTRIBUTES (DNS_RDATATYPEATTR_ZONECUTAUTH) | | ------------------ | | | Branch (2469:2): [True: 6, False: 96] | | ------------------ | | 2470| 0| case 3: return (RRTYPE_MD_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MD_ATTRIBUTES (0) | | ------------------ | | | Branch (2470:2): [True: 0, False: 102] | | ------------------ | | 2471| 0| case 4: return (RRTYPE_MF_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MF_ATTRIBUTES (0) | | ------------------ | | | Branch (2471:2): [True: 0, False: 102] | | ------------------ | | 2472| 0| case 5: return (RRTYPE_CNAME_ATTRIBUTES); \ | | ------------------ | | | | 18| 0| (DNS_RDATATYPEATTR_EXCLUSIVE | DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2472:2): [True: 0, False: 102] | | ------------------ | | 2473| 6| case 6: return (RRTYPE_SOA_ATTRIBUTES); \ | | ------------------ | | | | 17| 6|#define RRTYPE_SOA_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2473:2): [True: 6, False: 96] | | ------------------ | | 2474| 0| case 7: return (RRTYPE_MB_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MB_ATTRIBUTES (0) | | ------------------ | | | Branch (2474:2): [True: 0, False: 102] | | ------------------ | | 2475| 0| case 8: return (RRTYPE_MG_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MG_ATTRIBUTES (0) | | ------------------ | | | Branch (2475:2): [True: 0, False: 102] | | ------------------ | | 2476| 0| case 9: return (RRTYPE_MR_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MR_ATTRIBUTES (0) | | ------------------ | | | Branch (2476:2): [True: 0, False: 102] | | ------------------ | | 2477| 0| case 10: return (RRTYPE_NULL_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_NULL_ATTRIBUTES (0) | | ------------------ | | | Branch (2477:2): [True: 0, False: 102] | | ------------------ | | 2478| 0| case 11: return (RRTYPE_WKS_ATTRIBUTES); \ | | ------------------ | | | | 24| 0|#define RRTYPE_WKS_ATTRIBUTES (0) | | ------------------ | | | Branch (2478:2): [True: 0, False: 102] | | ------------------ | | 2479| 0| case 12: return (RRTYPE_PTR_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_PTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2479:2): [True: 0, False: 102] | | ------------------ | | 2480| 0| case 13: return (RRTYPE_HINFO_ATTRIBUTES); \ | | ------------------ | | | | 16| 0|#define RRTYPE_HINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2480:2): [True: 0, False: 102] | | ------------------ | | 2481| 0| case 14: return (RRTYPE_MINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2481:2): [True: 0, False: 102] | | ------------------ | | 2482| 0| case 15: return (RRTYPE_MX_ATTRIBUTES); \ | | ------------------ | | | | 23| 0|#define RRTYPE_MX_ATTRIBUTES (0) | | ------------------ | | | Branch (2482:2): [True: 0, False: 102] | | ------------------ | | 2483| 0| case 16: return (RRTYPE_TXT_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_TXT_ATTRIBUTES (0) | | ------------------ | | | Branch (2483:2): [True: 0, False: 102] | | ------------------ | | 2484| 0| case 17: return (RRTYPE_RP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_RP_ATTRIBUTES (0) | | ------------------ | | | Branch (2484:2): [True: 0, False: 102] | | ------------------ | | 2485| 0| case 18: return (RRTYPE_AFSDB_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_AFSDB_ATTRIBUTES (0) | | ------------------ | | | Branch (2485:2): [True: 0, False: 102] | | ------------------ | | 2486| 0| case 19: return (RRTYPE_X25_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_X25_ATTRIBUTES (0) | | ------------------ | | | Branch (2486:2): [True: 0, False: 102] | | ------------------ | | 2487| 0| case 20: return (RRTYPE_ISDN_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ISDN_ATTRIBUTES (0) | | ------------------ | | | Branch (2487:2): [True: 0, False: 102] | | ------------------ | | 2488| 0| case 21: return (RRTYPE_RT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_RT_ATTRIBUTES (0) | | ------------------ | | | Branch (2488:2): [True: 0, False: 102] | | ------------------ | | 2489| 0| case 22: return (RRTYPE_NSAP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NSAP_ATTRIBUTES (0) | | ------------------ | | | Branch (2489:2): [True: 0, False: 102] | | ------------------ | | 2490| 0| case 23: return (RRTYPE_NSAP_PTR_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NSAP_PTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2490:2): [True: 0, False: 102] | | ------------------ | | 2491| 84| case 24: return (RRTYPE_SIG_ATTRIBUTES); \ | | ------------------ | | | | 19| 84|#define RRTYPE_SIG_ATTRIBUTES (0) | | ------------------ | | | Branch (2491:2): [True: 84, False: 18] | | ------------------ | | 2492| 6| case 25: return (RRTYPE_KEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 6|#define RRTYPE_KEY_ATTRIBUTES (0) | | ------------------ | | | Branch (2492:2): [True: 6, False: 96] | | ------------------ | | 2493| 0| case 26: return (RRTYPE_PX_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_PX_ATTRIBUTES (0) | | ------------------ | | | Branch (2493:2): [True: 0, False: 102] | | ------------------ | | 2494| 0| case 27: return (RRTYPE_GPOS_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_GPOS_ATTRIBUTES (0) | | ------------------ | | | Branch (2494:2): [True: 0, False: 102] | | ------------------ | | 2495| 0| case 28: return (RRTYPE_AAAA_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_AAAA_ATTRIBUTES (0) | | ------------------ | | | Branch (2495:2): [True: 0, False: 102] | | ------------------ | | 2496| 0| case 29: return (RRTYPE_LOC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_LOC_ATTRIBUTES (0) | | ------------------ | | | Branch (2496:2): [True: 0, False: 102] | | ------------------ | | 2497| 0| case 30: return (RRTYPE_NXT_ATTRIBUTES); \ | | ------------------ | | | | 23| 0|#define RRTYPE_NXT_ATTRIBUTES (0) | | ------------------ | | | Branch (2497:2): [True: 0, False: 102] | | ------------------ | | 2498| 0| case 31: return (RRTYPE_EID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EID_ATTRIBUTES (0) | | ------------------ | | | Branch (2498:2): [True: 0, False: 102] | | ------------------ | | 2499| 0| case 32: return (RRTYPE_NIMLOC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NIMLOC_ATTRIBUTES (0) | | ------------------ | | | Branch (2499:2): [True: 0, False: 102] | | ------------------ | | 2500| 0| case 33: return (RRTYPE_SRV_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SRV_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2500:2): [True: 0, False: 102] | | ------------------ | | 2501| 0| case 34: return (RRTYPE_ATMA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ATMA_ATTRIBUTES (0) | | ------------------ | | | Branch (2501:2): [True: 0, False: 102] | | ------------------ | | 2502| 0| case 35: return (RRTYPE_NAPTR_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NAPTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2502:2): [True: 0, False: 102] | | ------------------ | | 2503| 0| case 36: return (RRTYPE_KX_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_KX_ATTRIBUTES (0) | | ------------------ | | | Branch (2503:2): [True: 0, False: 102] | | ------------------ | | 2504| 0| case 37: return (RRTYPE_CERT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CERT_ATTRIBUTES (0) | | ------------------ | | | Branch (2504:2): [True: 0, False: 102] | | ------------------ | | 2505| 0| case 38: return (RRTYPE_A6_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_A6_ATTRIBUTES (0) | | ------------------ | | | Branch (2505:2): [True: 0, False: 102] | | ------------------ | | 2506| 0| case 39: return (RRTYPE_DNAME_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DNAME_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2506:2): [True: 0, False: 102] | | ------------------ | | 2507| 0| case 40: return (RRTYPE_SINK_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SINK_ATTRIBUTES (0) | | ------------------ | | | Branch (2507:2): [True: 0, False: 102] | | ------------------ | | 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: 102] | | ------------------ | | 2509| 0| case 42: return (RRTYPE_APL_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_APL_ATTRIBUTES (0) | | ------------------ | | | Branch (2509:2): [True: 0, False: 102] | | ------------------ | | 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: 102] | | ------------------ | | 2511| 0| case 44: return (RRTYPE_SSHFP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SSHFP_ATTRIBUTES (0) | | ------------------ | | | Branch (2511:2): [True: 0, False: 102] | | ------------------ | | 2512| 0| case 45: return (RRTYPE_IPSECKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_IPSECKEY_ATTRIBUTES (0) | | ------------------ | | | Branch (2512:2): [True: 0, False: 102] | | ------------------ | | 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: 102] | | ------------------ | | 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: 102] | | ------------------ | | 2515| 0| case 48: return (RRTYPE_DNSKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_DNSKEY_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC) | | ------------------ | | | Branch (2515:2): [True: 0, False: 102] | | ------------------ | | 2516| 0| case 49: return (RRTYPE_DHCID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DHCID_ATTRIBUTES 0 | | ------------------ | | | Branch (2516:2): [True: 0, False: 102] | | ------------------ | | 2517| 0| case 50: return (RRTYPE_NSEC3_ATTRIBUTES); \ | | ------------------ | | | | 40| 0|#define RRTYPE_NSEC3_ATTRIBUTES DNS_RDATATYPEATTR_DNSSEC | | ------------------ | | | Branch (2517:2): [True: 0, False: 102] | | ------------------ | | 2518| 0| case 51: return (RRTYPE_NSEC3PARAM_ATTRIBUTES); \ | | ------------------ | | | | 38| 0|#define RRTYPE_NSEC3PARAM_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC) | | ------------------ | | | Branch (2518:2): [True: 0, False: 102] | | ------------------ | | 2519| 0| case 52: return (RRTYPE_TLSA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TLSA_ATTRIBUTES 0 | | ------------------ | | | Branch (2519:2): [True: 0, False: 102] | | ------------------ | | 2520| 0| case 53: return (RRTYPE_SMIMEA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_SMIMEA_ATTRIBUTES 0 | | ------------------ | | | Branch (2520:2): [True: 0, False: 102] | | ------------------ | | 2521| 0| case 55: return (RRTYPE_HIP_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_HIP_ATTRIBUTES (0) | | ------------------ | | | Branch (2521:2): [True: 0, False: 102] | | ------------------ | | 2522| 0| case 56: return (RRTYPE_NINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_NINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2522:2): [True: 0, False: 102] | | ------------------ | | 2523| 0| case 57: return (RRTYPE_RKEY_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_RKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2523:2): [True: 0, False: 102] | | ------------------ | | 2524| 0| case 58: return (RRTYPE_TALINK_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_TALINK_ATTRIBUTES 0 | | ------------------ | | | Branch (2524:2): [True: 0, False: 102] | | ------------------ | | 2525| 0| case 59: return (RRTYPE_CDS_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CDS_ATTRIBUTES 0 | | ------------------ | | | Branch (2525:2): [True: 0, False: 102] | | ------------------ | | 2526| 0| case 60: return (RRTYPE_CDNSKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_CDNSKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2526:2): [True: 0, False: 102] | | ------------------ | | 2527| 0| case 61: return (RRTYPE_OPENPGPKEY_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_OPENPGPKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2527:2): [True: 0, False: 102] | | ------------------ | | 2528| 0| case 62: return (RRTYPE_CSYNC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CSYNC_ATTRIBUTES 0 | | ------------------ | | | Branch (2528:2): [True: 0, False: 102] | | ------------------ | | 2529| 0| case 63: return (RRTYPE_ZONEMD_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ZONEMD_ATTRIBUTES 0 | | ------------------ | | | Branch (2529:2): [True: 0, False: 102] | | ------------------ | | 2530| 0| case 64: return (RRTYPE_SVCB_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SVCB_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2530:2): [True: 0, False: 102] | | ------------------ | | 2531| 0| case 65: return (RRTYPE_HTTPS_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_HTTPS_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2531:2): [True: 0, False: 102] | | ------------------ | | 2532| 0| case 66: return (RRTYPE_DSYNC_ATTRIBUTES); \ | | ------------------ | | | | 24| 0|#define RRTYPE_DSYNC_ATTRIBUTES (0) | | ------------------ | | | Branch (2532:2): [True: 0, False: 102] | | ------------------ | | 2533| 0| case 67: return (RRTYPE_HHIT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_HHIT_ATTRIBUTES (0) | | ------------------ | | | Branch (2533:2): [True: 0, False: 102] | | ------------------ | | 2534| 0| case 68: return (RRTYPE_BRID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_BRID_ATTRIBUTES (0) | | ------------------ | | | Branch (2534:2): [True: 0, False: 102] | | ------------------ | | 2535| 0| case 99: return (RRTYPE_SPF_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_SPF_ATTRIBUTES (0) | | ------------------ | | | Branch (2535:2): [True: 0, False: 102] | | ------------------ | | 2536| 0| case 100: return (0); \ | | ------------------ | | | Branch (2536:2): [True: 0, False: 102] | | ------------------ | | 2537| 0| case 101: return (0); \ | | ------------------ | | | Branch (2537:2): [True: 0, False: 102] | | ------------------ | | 2538| 0| case 102: return (0); \ | | ------------------ | | | Branch (2538:2): [True: 0, False: 102] | | ------------------ | | 2539| 0| case 103: return (0); \ | | ------------------ | | | Branch (2539:2): [True: 0, False: 102] | | ------------------ | | 2540| 0| case 104: return (RRTYPE_NID_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_NID_ATTRIBUTES (0) | | ------------------ | | | Branch (2540:2): [True: 0, False: 102] | | ------------------ | | 2541| 0| case 105: return (RRTYPE_L32_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_L32_ATTRIBUTES (0) | | ------------------ | | | Branch (2541:2): [True: 0, False: 102] | | ------------------ | | 2542| 0| case 106: return (RRTYPE_L64_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_L64_ATTRIBUTES (0) | | ------------------ | | | Branch (2542:2): [True: 0, False: 102] | | ------------------ | | 2543| 0| case 107: return (RRTYPE_LP_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_LP_ATTRIBUTES (0) | | ------------------ | | | Branch (2543:2): [True: 0, False: 102] | | ------------------ | | 2544| 0| case 108: return (RRTYPE_EUI48_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EUI48_ATTRIBUTES (0) | | ------------------ | | | Branch (2544:2): [True: 0, False: 102] | | ------------------ | | 2545| 0| case 109: return (RRTYPE_EUI64_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EUI64_ATTRIBUTES (0) | | ------------------ | | | Branch (2545:2): [True: 0, False: 102] | | ------------------ | | 2546| 0| case 249: return (RRTYPE_TKEY_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TKEY_ATTRIBUTES (DNS_RDATATYPEATTR_META) | | ------------------ | | | Branch (2546:2): [True: 0, False: 102] | | ------------------ | | 2547| 0| case 250: return (RRTYPE_TSIG_ATTRIBUTES); \ | | ------------------ | | | | 18| 0| (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_NOTQUESTION) | | ------------------ | | | Branch (2547:2): [True: 0, False: 102] | | ------------------ | | 2548| 0| case 251: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2548:2): [True: 0, False: 102] | | ------------------ | | 2549| 0| case 252: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2549:2): [True: 0, False: 102] | | ------------------ | | 2550| 0| case 253: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2550:2): [True: 0, False: 102] | | ------------------ | | 2551| 0| case 254: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2551:2): [True: 0, False: 102] | | ------------------ | | 2552| 0| case 255: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2552:2): [True: 0, False: 102] | | ------------------ | | 2553| 0| case 256: return (RRTYPE_URI_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_URI_ATTRIBUTES (0) | | ------------------ | | | Branch (2553:2): [True: 0, False: 102] | | ------------------ | | 2554| 0| case 257: return (RRTYPE_CAA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_CAA_ATTRIBUTES (0) | | ------------------ | | | Branch (2554:2): [True: 0, False: 102] | | ------------------ | | 2555| 0| case 258: return (RRTYPE_AVC_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_AVC_ATTRIBUTES (0) | | ------------------ | | | Branch (2555:2): [True: 0, False: 102] | | ------------------ | | 2556| 0| case 259: return (RRTYPE_DOA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_DOA_ATTRIBUTES (0) | | ------------------ | | | Branch (2556:2): [True: 0, False: 102] | | ------------------ | | 2557| 0| case 260: return (RRTYPE_AMTRELAY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_AMTRELAY_ATTRIBUTES (0) | | ------------------ | | | Branch (2557:2): [True: 0, False: 102] | | ------------------ | | 2558| 0| case 261: return (RRTYPE_RESINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_RESINFO_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2558:2): [True: 0, False: 102] | | ------------------ | | 2559| 0| case 262: return (RRTYPE_WALLET_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_WALLET_ATTRIBUTES (0) | | ------------------ | | | Branch (2559:2): [True: 0, False: 102] | | ------------------ | | 2560| 0| case 32768: return (RRTYPE_TA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TA_ATTRIBUTES 0 | | ------------------ | | | Branch (2560:2): [True: 0, False: 102] | | ------------------ | | 2561| 0| case 32769: return (RRTYPE_DLV_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DLV_ATTRIBUTES 0 | | ------------------ | | | Branch (2561:2): [True: 0, False: 102] | | ------------------ | | 2562| 0| case 65533: return (RRTYPE_KEYDATA_ATTRIBUTES); \ | | ------------------ | | | | 22| 0|#define RRTYPE_KEYDATA_ATTRIBUTES (0) | | ------------------ | | | Branch (2562:2): [True: 0, False: 102] | | ------------------ | | 2563| 102| } ------------------ 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| 554|dns_rdata_covers(dns_rdata_t *rdata) { 2328| 554| if (rdata->type == dns_rdatatype_rrsig) { ------------------ | | 160| 554|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (2328:6): [True: 0, False: 554] ------------------ 2329| 0| return covers_rrsig(rdata); 2330| 0| } 2331| 554| return covers_sig(rdata); 2332| 554|} rdata.c:uint8_fromregion: 2171| 1.33k|uint8_fromregion(isc_region_t *region) { 2172| 1.33k| REQUIRE(region->length >= 1); ------------------ | | 198| 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.37k|mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length) { 2187| 5.37k| isc_region_t tr; 2188| | 2189| 5.37k| if (length == 0U) { ------------------ | Branch (2189:6): [True: 0, False: 5.37k] ------------------ 2190| 0| return ISC_R_SUCCESS; 2191| 0| } 2192| | 2193| 5.37k| isc_buffer_availableregion(target, &tr); 2194| 5.37k| if (length > tr.length) { ------------------ | Branch (2194:6): [True: 368, False: 5.00k] ------------------ 2195| 368| return ISC_R_NOSPACE; 2196| 368| } 2197| 5.00k| if (tr.base != base) { ------------------ | Branch (2197:6): [True: 5.00k, False: 0] ------------------ 2198| 5.00k| memmove(tr.base, base, length); 2199| 5.00k| } 2200| 5.00k| isc_buffer_add(target, length); 2201| 5.00k| return ISC_R_SUCCESS; 2202| 5.37k|} rdata.c:check_private: 586| 370|check_private(isc_buffer_t *source, dns_secalg_t alg) { 587| 370| isc_region_t sr; 588| 370| if (alg == DNS_KEYALG_PRIVATEDNS) { ------------------ | Branch (588:6): [True: 197, False: 173] ------------------ 589| 197| dns_fixedname_t fixed; 590| | 591| 197| RETERR(dns_name_fromwire(dns_fixedname_initname(&fixed), source, ------------------ | | 276| 197| { \ | | 277| 197| isc_result_t _r = (x); \ | | 278| 197| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 4, False: 193] | | ------------------ | | 279| 4| return ((_r)); \ | | 280| 4| } \ | | 281| 197| } ------------------ 592| 197| DNS_DECOMPRESS_NEVER, NULL)); 593| 193| } else if (alg == DNS_KEYALG_PRIVATEOID) { ------------------ | Branch (593:13): [True: 173, 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| 173| const unsigned char *in = NULL; 600| 173| ASN1_OBJECT *obj = NULL; 601| | 602| 173| isc_buffer_activeregion(source, &sr); 603| 173| if (sr.length < 1 || (unsigned int)*sr.base + 1 > sr.length) { ------------------ | Branch (603:7): [True: 0, False: 173] | Branch (603:24): [True: 10, False: 163] ------------------ 604| 10| RETERR(DNS_R_FORMERR); ------------------ | | 276| 10| { \ | | 277| 10| isc_result_t _r = (x); \ | | 278| 10| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 10, False: 0] | | ------------------ | | 279| 10| return ((_r)); \ | | 280| 10| } \ | | 281| 10| } ------------------ 605| 0| } 606| 163| in = sr.base + 1; 607| 163| obj = d2i_ASN1_OBJECT(NULL, &in, *sr.base); 608| 163| if (obj == NULL) { ------------------ | Branch (608:7): [True: 53, False: 110] ------------------ 609| 53| ERR_clear_error(); 610| 53| RETERR(DNS_R_FORMERR); ------------------ | | 276| 53| { \ | | 277| 53| isc_result_t _r = (x); \ | | 278| 53| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 53, False: 0] | | ------------------ | | 279| 53| return ((_r)); \ | | 280| 53| } \ | | 281| 53| } ------------------ 611| 0| } 612| 110| ASN1_OBJECT_free(obj); 613| 110| if ((in - sr.base) != (*sr.base + 1)) { ------------------ | Branch (613:7): [True: 12, False: 98] ------------------ 614| 12| RETERR(DNS_R_FORMERR); ------------------ | | 276| 12| { \ | | 277| 12| isc_result_t _r = (x); \ | | 278| 12| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 12, False: 0] | | ------------------ | | 279| 12| return ((_r)); \ | | 280| 12| } \ | | 281| 12| } ------------------ 615| 0| } 616| 110| } 617| 291| return ISC_R_SUCCESS; 618| 370|} rdata.c:uint32_fromregion: 2144| 1.63k|uint32_fromregion(isc_region_t *region) { 2145| 1.63k| uint32_t value; 2146| | 2147| 1.63k| REQUIRE(region->length >= 4); ------------------ | | 198| 1.63k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.63k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.63k, False: 0] | | | | ------------------ | | | | 43| 1.63k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2148| 1.63k| value = (uint32_t)region->base[0] << 24; 2149| 1.63k| value |= (uint32_t)region->base[1] << 16; 2150| 1.63k| value |= (uint32_t)region->base[2] << 8; 2151| 1.63k| value |= (uint32_t)region->base[3]; 2152| 1.63k| return value; 2153| 1.63k|} 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.27k|name_duporclone(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) { 394| 1.27k| if (mctx != NULL) { ------------------ | Branch (394:6): [True: 0, False: 1.27k] ------------------ 395| 0| dns_name_dup(source, mctx, target); 396| 1.27k| } else { 397| 1.27k| dns_name_clone(source, target); 398| 1.27k| } 399| 1.27k|} rdata.c:mem_maybedup: 402| 2.11k|mem_maybedup(isc_mem_t *mctx, void *source, size_t length) { 403| 2.11k| void *copy = NULL; 404| | 405| 2.11k| REQUIRE(source != NULL); ------------------ | | 198| 2.11k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.11k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.11k, False: 0] | | | | ------------------ | | | | 43| 2.11k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 406| | 407| 2.11k| if (mctx == NULL) { ------------------ | Branch (407:6): [True: 2.11k, False: 0] ------------------ 408| 2.11k| return source; 409| 2.11k| } 410| | 411| 0| copy = isc_mem_allocate(mctx, length); ------------------ | | 157| 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.11k|} rdata.c:buffer_empty: 2083| 1.25k|buffer_empty(isc_buffer_t *source) { 2084| 1.25k| return (source->current == source->active) ? true : false; ------------------ | Branch (2084:9): [True: 1.13k, False: 114] ------------------ 2085| 1.25k|} rdata.c:uint16_fromregion: 2164| 7.34k|uint16_fromregion(isc_region_t *region) { 2165| 7.34k| REQUIRE(region->length >= 2); ------------------ | | 198| 7.34k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 7.34k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 7.34k, False: 0] | | | | ------------------ | | | | 43| 7.34k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 2166| | 2167| 7.34k| return (region->base[0] << 8) | region->base[1]; 2168| 7.34k|} rdata.c:fromwire_any_tsig: 255| 1.18k|fromwire_any_tsig(ARGS_FROMWIRE) { 256| 1.18k| isc_region_t sr; 257| 1.18k| dns_name_t name; 258| 1.18k| unsigned long n; 259| | 260| 1.18k| REQUIRE(type == dns_rdatatype_tsig); ------------------ | | 198| 1.18k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.18k, False: 0] | | | | ------------------ | | | | 43| 1.18k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 261| 1.18k| REQUIRE(rdclass == dns_rdataclass_any); ------------------ | | 198| 1.18k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.18k, False: 0] | | | | ------------------ | | | | 43| 1.18k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 262| | 263| 1.18k| UNUSED(type); ------------------ | | 69| 1.18k|#define UNUSED(x) (void)(x) ------------------ 264| 1.18k| UNUSED(rdclass); ------------------ | | 69| 1.18k|#define UNUSED(x) (void)(x) ------------------ 265| | 266| 1.18k| dctx = dns_decompress_setpermitted(dctx, false); 267| | 268| | /* 269| | * Algorithm Name. 270| | */ 271| 1.18k| dns_name_init(&name); 272| 1.18k| RETERR(dns_name_fromwire(&name, source, dctx, target)); ------------------ | | 276| 1.18k| { \ | | 277| 1.18k| isc_result_t _r = (x); \ | | 278| 1.18k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 51, False: 1.13k] | | ------------------ | | 279| 51| return ((_r)); \ | | 280| 51| } \ | | 281| 1.18k| } ------------------ 273| | 274| 1.13k| isc_buffer_activeregion(source, &sr); 275| | /* 276| | * Time Signed + Fudge. 277| | */ 278| 1.13k| if (sr.length < 8) { ------------------ | Branch (278:6): [True: 24, False: 1.11k] ------------------ 279| 24| return ISC_R_UNEXPECTEDEND; 280| 24| } 281| 1.11k| RETERR(mem_tobuffer(target, sr.base, 8)); ------------------ | | 276| 1.11k| { \ | | 277| 1.11k| isc_result_t _r = (x); \ | | 278| 1.11k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 1.11k] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 1.11k| } ------------------ 282| 1.11k| isc_region_consume(&sr, 8); ------------------ | | 50| 1.11k| do { \ | | 51| 1.11k| isc_region_t *_r = (r); \ | | 52| 1.11k| unsigned int _l = (l); \ | | 53| 1.11k| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 1.11k|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 1.11k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 1.11k, False: 0] | | | | | | ------------------ | | | | | | 55| 1.11k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 1.11k| _r->base += _l; \ | | 55| 1.11k| _r->length -= _l; \ | | 56| 1.11k| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 1.11k] | | ------------------ ------------------ 283| 1.11k| isc_buffer_forward(source, 8); 284| | 285| | /* 286| | * Signature Length + Signature. 287| | */ 288| 1.11k| if (sr.length < 2) { ------------------ | Branch (288:6): [True: 22, False: 1.09k] ------------------ 289| 22| return ISC_R_UNEXPECTEDEND; 290| 22| } 291| 1.09k| n = uint16_fromregion(&sr); 292| 1.09k| if (sr.length < n + 2) { ------------------ | Branch (292:6): [True: 61, False: 1.03k] ------------------ 293| 61| return ISC_R_UNEXPECTEDEND; 294| 61| } 295| 1.03k| RETERR(mem_tobuffer(target, sr.base, n + 2)); ------------------ | | 276| 1.03k| { \ | | 277| 1.03k| isc_result_t _r = (x); \ | | 278| 1.03k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 98, False: 932] | | ------------------ | | 279| 98| return ((_r)); \ | | 280| 98| } \ | | 281| 1.03k| } ------------------ 296| 932| isc_region_consume(&sr, n + 2); ------------------ | | 50| 932| do { \ | | 51| 932| isc_region_t *_r = (r); \ | | 52| 932| unsigned int _l = (l); \ | | 53| 932| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 932|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 932| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 932, False: 0] | | | | | | ------------------ | | | | | | 55| 932| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 932| _r->base += _l; \ | | 55| 932| _r->length -= _l; \ | | 56| 932| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 932] | | ------------------ ------------------ 297| 932| isc_buffer_forward(source, n + 2); 298| | 299| | /* 300| | * Original ID + Error. 301| | */ 302| 932| if (sr.length < 4) { ------------------ | Branch (302:6): [True: 50, False: 882] ------------------ 303| 50| return ISC_R_UNEXPECTEDEND; 304| 50| } 305| 882| RETERR(mem_tobuffer(target, sr.base, 4)); ------------------ | | 276| 882| { \ | | 277| 882| isc_result_t _r = (x); \ | | 278| 882| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 9, False: 873] | | ------------------ | | 279| 9| return ((_r)); \ | | 280| 9| } \ | | 281| 882| } ------------------ 306| 873| isc_region_consume(&sr, 4); ------------------ | | 50| 873| do { \ | | 51| 873| isc_region_t *_r = (r); \ | | 52| 873| unsigned int _l = (l); \ | | 53| 873| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 873|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 873| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 873, False: 0] | | | | | | ------------------ | | | | | | 55| 873| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 873| _r->base += _l; \ | | 55| 873| _r->length -= _l; \ | | 56| 873| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 873] | | ------------------ ------------------ 307| 873| isc_buffer_forward(source, 4); 308| | 309| | /* 310| | * Other Length + Other. 311| | */ 312| 873| if (sr.length < 2) { ------------------ | Branch (312:6): [True: 7, False: 866] ------------------ 313| 7| return ISC_R_UNEXPECTEDEND; 314| 7| } 315| 866| n = uint16_fromregion(&sr); 316| 866| if (sr.length < n + 2) { ------------------ | Branch (316:6): [True: 71, False: 795] ------------------ 317| 71| return ISC_R_UNEXPECTEDEND; 318| 71| } 319| 795| isc_buffer_forward(source, n + 2); 320| 795| return mem_tobuffer(target, sr.base, n + 2); 321| 866|} rdata.c:tostruct_any_tsig: 444| 726|tostruct_any_tsig(ARGS_TOSTRUCT) { 445| 726| dns_rdata_any_tsig_t *tsig; 446| 726| dns_name_t alg; 447| 726| isc_region_t sr; 448| | 449| 726| REQUIRE(rdata->type == dns_rdatatype_tsig); ------------------ | | 198| 726|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 726| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 726, False: 0] | | | | ------------------ | | | | 43| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 450| 726| REQUIRE(rdata->rdclass == dns_rdataclass_any); ------------------ | | 198| 726|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 726| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 726, False: 0] | | | | ------------------ | | | | 43| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 451| 726| REQUIRE(rdata->length != 0); ------------------ | | 198| 726|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 726| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 726, False: 0] | | | | ------------------ | | | | 43| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 452| | 453| 726| tsig = (dns_rdata_any_tsig_t *)target; 454| 726| DNS_RDATACOMMON_INIT(tsig, rdata->type, rdata->rdclass); ------------------ | | 44| 726| do { \ | | 45| 726| (_data)->common.rdtype = (_rdtype); \ | | 46| 726| (_data)->common.rdclass = (_rdclass); \ | | 47| 726| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 726] | | ------------------ ------------------ 455| | 456| 726| dns_rdata_toregion(rdata, &sr); 457| | 458| | /* 459| | * Algorithm Name. 460| | */ 461| 726| dns_name_init(&alg); 462| 726| dns_name_fromregion(&alg, &sr); 463| 726| dns_name_init(&tsig->algorithm); 464| 726| name_duporclone(&alg, mctx, &tsig->algorithm); 465| | 466| 726| isc_region_consume(&sr, name_length(&tsig->algorithm)); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 467| | 468| | /* 469| | * Time Signed. 470| | */ 471| 726| INSIST(sr.length >= 6); ------------------ | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 726| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 726, False: 0] | | | | ------------------ | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 472| 726| tsig->timesigned = ((uint64_t)sr.base[0] << 40) | 473| 726| ((uint64_t)sr.base[1] << 32) | 474| 726| ((uint64_t)sr.base[2] << 24) | 475| 726| ((uint64_t)sr.base[3] << 16) | 476| 726| ((uint64_t)sr.base[4] << 8) | (uint64_t)sr.base[5]; 477| 726| isc_region_consume(&sr, 6); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 478| | 479| | /* 480| | * Fudge. 481| | */ 482| 726| tsig->fudge = uint16_fromregion(&sr); 483| 726| isc_region_consume(&sr, 2); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 484| | 485| | /* 486| | * Signature Size. 487| | */ 488| 726| tsig->siglen = uint16_fromregion(&sr); 489| 726| isc_region_consume(&sr, 2); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 490| | 491| | /* 492| | * Signature. 493| | */ 494| 726| INSIST(sr.length >= tsig->siglen); ------------------ | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 726| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 726, False: 0] | | | | ------------------ | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 495| 726| tsig->signature = mem_maybedup(mctx, sr.base, tsig->siglen); 496| 726| isc_region_consume(&sr, tsig->siglen); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 497| | 498| | /* 499| | * Original ID. 500| | */ 501| 726| tsig->originalid = uint16_fromregion(&sr); 502| 726| isc_region_consume(&sr, 2); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 503| | 504| | /* 505| | * Error. 506| | */ 507| 726| tsig->error = uint16_fromregion(&sr); 508| 726| isc_region_consume(&sr, 2); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 509| | 510| | /* 511| | * Other Size. 512| | */ 513| 726| tsig->otherlen = uint16_fromregion(&sr); 514| 726| isc_region_consume(&sr, 2); ------------------ | | 50| 726| do { \ | | 51| 726| isc_region_t *_r = (r); \ | | 52| 726| unsigned int _l = (l); \ | | 53| 726| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 726| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 726, False: 0] | | | | | | ------------------ | | | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 726| _r->base += _l; \ | | 55| 726| _r->length -= _l; \ | | 56| 726| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 726] | | ------------------ ------------------ 515| | 516| | /* 517| | * Other. 518| | */ 519| 726| INSIST(sr.length == tsig->otherlen); ------------------ | | 202| 726|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 726| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 726, False: 0] | | | | ------------------ | | | | 55| 726| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 520| 726| tsig->other = mem_maybedup(mctx, sr.base, tsig->otherlen); 521| | 522| 726| tsig->mctx = mctx; 523| 726| return ISC_R_SUCCESS; 524| 726|} rdata.c:fromtext_key: 235| 2|fromtext_key(ARGS_FROMTEXT) { 236| 2| REQUIRE(type == dns_rdatatype_key); ------------------ | | 198| 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); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 32| 2| UNUSED(origin); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 33| 2| UNUSED(options); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 34| 2| UNUSED(callbacks); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 35| | 36| | /* flags */ 37| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 44| | 45| | /* protocol */ 46| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 50| | 51| | /* algorithm */ 52| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 0| { \ | | 277| 0| isc_result_t _r = (x); \ | | 278| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 0] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 0| } ------------------ 76| 0| } 77| | 78| 2| return ISC_R_SUCCESS; 79| 2|} rdata.c:tostruct_key: 373| 123|tostruct_key(ARGS_TOSTRUCT) { 374| 123| dns_rdata_key_t *key = target; 375| | 376| 123| REQUIRE(key != NULL); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 377| 123| REQUIRE(rdata != NULL); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 378| 123| REQUIRE(rdata->type == dns_rdatatype_key); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 379| | 380| 123| DNS_RDATACOMMON_INIT(key, rdata->type, rdata->rdclass); ------------------ | | 44| 123| do { \ | | 45| 123| (_data)->common.rdtype = (_rdtype); \ | | 46| 123| (_data)->common.rdclass = (_rdclass); \ | | 47| 123| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 123] | | ------------------ ------------------ 381| | 382| 123| return generic_tostruct_key(CALL_TOSTRUCT); ------------------ | | 109| 123|#define CALL_TOSTRUCT rdata, target, mctx ------------------ 383| 123|} rdata.c:generic_tostruct_key: 317| 123|generic_tostruct_key(ARGS_TOSTRUCT) { 318| 123| dns_rdata_key_t *key = target; 319| 123| isc_region_t sr; 320| | 321| 123| REQUIRE(key != NULL); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 322| 123| REQUIRE(rdata->length >= 4U); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 323| | 324| 123| REQUIRE(key != NULL); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 325| 123| REQUIRE(key->common.rdclass == rdata->rdclass); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 326| 123| REQUIRE(key->common.rdtype == rdata->type); ------------------ | | 198| 123|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 123| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 123, False: 0] | | | | ------------------ | | | | 43| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 327| | 328| 123| dns_rdata_toregion(rdata, &sr); 329| | 330| | /* Flags */ 331| 123| key->flags = uint16_fromregion(&sr); 332| 123| isc_region_consume(&sr, 2); ------------------ | | 50| 123| do { \ | | 51| 123| isc_region_t *_r = (r); \ | | 52| 123| unsigned int _l = (l); \ | | 53| 123| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 123|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 123| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 123, False: 0] | | | | | | ------------------ | | | | | | 55| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 123| _r->base += _l; \ | | 55| 123| _r->length -= _l; \ | | 56| 123| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 123] | | ------------------ ------------------ 333| | 334| | /* Protocol */ 335| 123| key->protocol = uint8_fromregion(&sr); 336| 123| isc_region_consume(&sr, 1); ------------------ | | 50| 123| do { \ | | 51| 123| isc_region_t *_r = (r); \ | | 52| 123| unsigned int _l = (l); \ | | 53| 123| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 123|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 123| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 123, False: 0] | | | | | | ------------------ | | | | | | 55| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 123| _r->base += _l; \ | | 55| 123| _r->length -= _l; \ | | 56| 123| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 123] | | ------------------ ------------------ 337| | 338| | /* Algorithm */ 339| 123| key->algorithm = uint8_fromregion(&sr); 340| 123| isc_region_consume(&sr, 1); ------------------ | | 50| 123| do { \ | | 51| 123| isc_region_t *_r = (r); \ | | 52| 123| unsigned int _l = (l); \ | | 53| 123| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 123|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 123| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 123, False: 0] | | | | | | ------------------ | | | | | | 55| 123| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 123| _r->base += _l; \ | | 55| 123| _r->length -= _l; \ | | 56| 123| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 123] | | ------------------ ------------------ 341| | 342| | /* Data */ 343| 123| key->datalen = sr.length; 344| 123| key->data = mem_maybedup(mctx, sr.base, key->datalen); 345| 123| key->mctx = mctx; 346| 123| return ISC_R_SUCCESS; 347| 123|} 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); ------------------ | | 198| 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); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 30| 2| UNUSED(rdclass); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 31| 2| UNUSED(callbacks); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 32| | 33| 2| RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string, ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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| 851|fromwire_sig(ARGS_FROMWIRE) { 259| 851| isc_region_t sr; 260| 851| dns_name_t name; 261| 851| unsigned char algorithm; 262| | 263| 851| REQUIRE(type == dns_rdatatype_sig); ------------------ | | 198| 851|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 851| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 851, False: 0] | | | | ------------------ | | | | 43| 851| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 264| | 265| 851| UNUSED(type); ------------------ | | 69| 851|#define UNUSED(x) (void)(x) ------------------ 266| 851| UNUSED(rdclass); ------------------ | | 69| 851|#define UNUSED(x) (void)(x) ------------------ 267| | 268| 851| dctx = dns_decompress_setpermitted(dctx, false); 269| | 270| 851| 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| 851| if (sr.length < 18) { ------------------ | Branch (280:6): [True: 23, False: 828] ------------------ 281| 23| return ISC_R_UNEXPECTEDEND; 282| 23| } 283| | 284| 828| algorithm = sr.base[2]; 285| | 286| 828| isc_buffer_forward(source, 18); 287| 828| RETERR(mem_tobuffer(target, sr.base, 18)); ------------------ | | 276| 828| { \ | | 277| 828| isc_result_t _r = (x); \ | | 278| 828| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 828] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 828| } ------------------ 288| | 289| | /* 290| | * Signer. 291| | */ 292| 828| dns_name_init(&name); 293| 828| RETERR(dns_name_fromwire(&name, source, dctx, target)); ------------------ | | 276| 828| { \ | | 277| 828| isc_result_t _r = (x); \ | | 278| 828| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 22, False: 806] | | ------------------ | | 279| 22| return ((_r)); \ | | 280| 22| } \ | | 281| 828| } ------------------ 294| | 295| | /* 296| | * Sig. 297| | */ 298| 806| isc_buffer_activeregion(source, &sr); 299| 806| if (sr.length == 0) { ------------------ | Branch (299:6): [True: 3, False: 803] ------------------ 300| 3| return ISC_R_UNEXPECTEDEND; 301| 3| } 302| | 303| 803| if (algorithm == DNS_KEYALG_PRIVATEDNS || ------------------ | Branch (303:6): [True: 197, False: 606] ------------------ 304| 606| algorithm == DNS_KEYALG_PRIVATEOID) ------------------ | Branch (304:6): [True: 173, False: 433] ------------------ 305| 370| { 306| 370| isc_buffer_t b = *source; 307| 370| RETERR(check_private(&b, algorithm)); ------------------ | | 276| 370| { \ | | 277| 370| isc_result_t _r = (x); \ | | 278| 370| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 79, False: 291] | | ------------------ | | 279| 79| return ((_r)); \ | | 280| 79| } \ | | 281| 370| } ------------------ 308| 291| } 309| | 310| 724| isc_buffer_forward(source, sr.length); 311| 724| return mem_tobuffer(target, sr.base, sr.length); 312| 803|} rdata.c:tostruct_sig: 455| 542|tostruct_sig(ARGS_TOSTRUCT) { 456| 542| isc_region_t sr; 457| 542| dns_rdata_sig_t *sig = target; 458| 542| dns_name_t signer; 459| | 460| 542| REQUIRE(rdata->type == dns_rdatatype_sig); ------------------ | | 198| 542|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 542| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 542, False: 0] | | | | ------------------ | | | | 43| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 461| 542| REQUIRE(sig != NULL); ------------------ | | 198| 542|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 542| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 542, False: 0] | | | | ------------------ | | | | 43| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 462| 542| REQUIRE(rdata->length != 0); ------------------ | | 198| 542|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 542| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 542, False: 0] | | | | ------------------ | | | | 43| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 463| | 464| 542| DNS_RDATACOMMON_INIT(sig, rdata->type, rdata->rdclass); ------------------ | | 44| 542| do { \ | | 45| 542| (_data)->common.rdtype = (_rdtype); \ | | 46| 542| (_data)->common.rdclass = (_rdclass); \ | | 47| 542| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 542] | | ------------------ ------------------ 465| | 466| 542| dns_rdata_toregion(rdata, &sr); 467| | 468| | /* 469| | * Type covered. 470| | */ 471| 542| sig->covered = uint16_fromregion(&sr); 472| 542| isc_region_consume(&sr, 2); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 473| | 474| | /* 475| | * Algorithm. 476| | */ 477| 542| sig->algorithm = uint8_fromregion(&sr); 478| 542| isc_region_consume(&sr, 1); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 479| | 480| | /* 481| | * Labels. 482| | */ 483| 542| sig->labels = uint8_fromregion(&sr); 484| 542| isc_region_consume(&sr, 1); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 485| | 486| | /* 487| | * Original TTL. 488| | */ 489| 542| sig->originalttl = uint32_fromregion(&sr); 490| 542| isc_region_consume(&sr, 4); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 491| | 492| | /* 493| | * Expire time. 494| | */ 495| 542| sig->timeexpire = uint32_fromregion(&sr); 496| 542| isc_region_consume(&sr, 4); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 497| | 498| | /* 499| | * Time signed. 500| | */ 501| 542| sig->timesigned = uint32_fromregion(&sr); 502| 542| isc_region_consume(&sr, 4); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 503| | 504| | /* 505| | * Key ID. 506| | */ 507| 542| sig->keyid = uint16_fromregion(&sr); 508| 542| isc_region_consume(&sr, 2); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 509| | 510| 542| dns_name_init(&signer); 511| 542| dns_name_fromregion(&signer, &sr); 512| 542| dns_name_init(&sig->signer); 513| 542| name_duporclone(&signer, mctx, &sig->signer); 514| 542| isc_region_consume(&sr, name_length(&sig->signer)); ------------------ | | 50| 542| do { \ | | 51| 542| isc_region_t *_r = (r); \ | | 52| 542| unsigned int _l = (l); \ | | 53| 542| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 542|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 542| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 542, False: 0] | | | | | | ------------------ | | | | | | 55| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 542| _r->base += _l; \ | | 55| 542| _r->length -= _l; \ | | 56| 542| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 542] | | ------------------ ------------------ 515| | 516| | /* 517| | * Signature. 518| | */ 519| 542| sig->siglen = sr.length; 520| 542| sig->signature = mem_maybedup(mctx, sr.base, sig->siglen); 521| 542| sig->mctx = mctx; 522| 542| return ISC_R_SUCCESS; 523| 542|} rdata.c:freestruct_sig: 526| 542|freestruct_sig(ARGS_FREESTRUCT) { 527| 542| dns_rdata_sig_t *sig = (dns_rdata_sig_t *)source; 528| | 529| 542| REQUIRE(sig != NULL); ------------------ | | 198| 542|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 542| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 542, False: 0] | | | | ------------------ | | | | 43| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 530| 542| REQUIRE(sig->common.rdtype == dns_rdatatype_sig); ------------------ | | 198| 542|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 542| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 542, False: 0] | | | | ------------------ | | | | 43| 542| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 531| | 532| 542| if (sig->mctx == NULL) { ------------------ | Branch (532:6): [True: 542, False: 0] ------------------ 533| 542| return; 534| 542| } 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); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 539| 0| } 540| | sig->mctx = NULL; 541| 0|} rdata.c:covers_sig: 586| 554|covers_sig(dns_rdata_t *rdata) { 587| 554| dns_rdatatype_t type; 588| 554| isc_region_t r; 589| | 590| 554| REQUIRE(rdata->type == dns_rdatatype_sig); ------------------ | | 198| 554|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 554| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 554, False: 0] | | | | ------------------ | | | | 43| 554| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 591| | 592| 554| dns_rdata_toregion(rdata, &r); 593| 554| type = uint16_fromregion(&r); 594| | 595| 554| return type; 596| 554|} 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); ------------------ | | 198| 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); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 30| 2| UNUSED(rdclass); ------------------ | | 69| 2|#define UNUSED(x) (void)(x) ------------------ 31| 2| UNUSED(callbacks); ------------------ | | 69| 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, ------------------ | | 276| 4| { \ | | 277| 4| isc_result_t _r = (x); \ | | 278| 4| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 4] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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, ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 67| 2| false)); 68| 2| RETERR(uint32_tobuffer(token.value.as_ulong, target)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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, ------------------ | | 276| 8| { \ | | 277| 8| isc_result_t _r = (x); \ | | 278| 8| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 8] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 8| { \ | | 277| 8| isc_result_t _r = (x); \ | | 278| 8| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 8] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); \ | | ------------------ | | | | 202| 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); \ | | ------------------ | | | | 202| 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); \ | | ------------------ | | | | 202| 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); \ | | ------------------ | | | | 202| 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); \ | | ------------------ | | | | 202| 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); \ | | ------------------ | | | | 202| 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: 41| 3.02k|dns_rdatalist_init(dns_rdatalist_t *rdatalist) { 42| 3.02k| REQUIRE(rdatalist != NULL); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 43| | 44| | /* 45| | * Initialize rdatalist. 46| | */ 47| 3.02k| *rdatalist = (dns_rdatalist_t){ 48| 3.02k| .rdata = ISC_LIST_INITIALIZER, ------------------ | | 21| 3.02k| { \ | | 22| 3.02k| .head = NULL, \ | | 23| 3.02k| .tail = NULL, \ | | 24| 3.02k| } ------------------ 49| 3.02k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 3.02k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 3.02k| { \ | | | | 27| 3.02k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.02k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 3.02k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.02k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 3.02k| } | | ------------------ ------------------ 50| 3.02k| }; 51| 3.02k| memset(rdatalist->upper, 0xeb, sizeof(rdatalist->upper)); 52| | 53| | /* 54| | * Clear upper set bit. 55| | */ 56| 3.02k| rdatalist->upper[0] &= ~0x01; 57| 3.02k|} dns_rdatalist_tordataset: 60| 3.02k|dns_rdatalist_tordataset(dns_rdatalist_t *rdatalist, dns_rdataset_t *rdataset) { 61| | /* 62| | * Make 'rdataset' refer to the rdata in 'rdatalist'. 63| | */ 64| | 65| 3.02k| REQUIRE(rdatalist != NULL); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 66| 3.02k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.05k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | | Branch (42:11): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 67| 3.02k| REQUIRE(!dns_rdataset_isassociated(rdataset)); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 68| | 69| | /* Check if dns_rdatalist_init has was called. */ 70| 3.02k| REQUIRE(rdatalist->upper[0] == 0xea); ------------------ | | 198| 3.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.02k, False: 0] | | | | ------------------ | | | | 43| 3.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 71| | 72| 3.02k| *rdataset = (dns_rdataset_t){ 73| 3.02k| .methods = &methods, 74| 3.02k| .rdclass = rdatalist->rdclass, 75| 3.02k| .type = rdatalist->type, 76| 3.02k| .covers = rdatalist->covers, 77| 3.02k| .ttl = rdatalist->ttl, 78| 3.02k| .rdlist.list = rdatalist, 79| | 80| 3.02k| .link = rdataset->link, 81| 3.02k| .attributes = rdataset->attributes, 82| 3.02k| .magic = rdataset->magic, 83| 3.02k| }; 84| 3.02k|} dns_rdatalist_fromrdataset: 88| 1.13k| dns_rdatalist_t **rdatalist) { 89| 1.13k| REQUIRE(rdatalist != NULL && rdataset != NULL); ------------------ | | 198| 1.13k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.27k| ((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))) | | ------------------ ------------------ 90| 1.13k| REQUIRE(rdataset->methods == &methods); ------------------ | | 198| 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))) | | ------------------ ------------------ 91| | 92| 1.13k| *rdatalist = rdataset->rdlist.list; 93| 1.13k|} dns_rdatalist_disassociate: 96| 3.02k|dns_rdatalist_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 97| 3.02k| UNUSED(rdataset); ------------------ | | 69| 3.02k|#define UNUSED(x) (void)(x) ------------------ 98| 3.02k|} dns__rdatalist_first: 101| 1.27k|dns__rdatalist_first(dns_rdataset_t *rdataset) { 102| 1.27k| dns_rdatalist_t *rdatalist = NULL; 103| | 104| 1.27k| rdatalist = rdataset->rdlist.list; 105| 1.27k| rdataset->rdlist.iter = ISC_LIST_HEAD(rdatalist->rdata); ------------------ | | 62| 1.27k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 106| | 107| 1.27k| if (rdataset->rdlist.iter == NULL) { ------------------ | Branch (107:6): [True: 0, False: 1.27k] ------------------ 108| 0| return ISC_R_NOMORE; 109| 0| } 110| | 111| 1.27k| return ISC_R_SUCCESS; 112| 1.27k|} dns__rdatalist_next: 115| 6|dns__rdatalist_next(dns_rdataset_t *rdataset) { 116| 6| dns_rdata_t *rdata; 117| | 118| 6| rdata = rdataset->rdlist.iter; 119| 6| if (rdata == NULL) { ------------------ | Branch (119:6): [True: 0, False: 6] ------------------ 120| 0| return ISC_R_NOMORE; 121| 0| } 122| | 123| 6| rdataset->rdlist.iter = ISC_LIST_NEXT(rdata, link); ------------------ | | 140| 6|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 124| | 125| 6| if (rdataset->rdlist.iter == NULL) { ------------------ | Branch (125:6): [True: 6, False: 0] ------------------ 126| 6| return ISC_R_NOMORE; 127| 6| } 128| | 129| 0| return ISC_R_SUCCESS; 130| 6|} dns__rdatalist_current: 133| 1.27k|dns__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 134| 1.27k| dns_rdata_t *list_rdata; 135| | 136| 1.27k| list_rdata = rdataset->rdlist.iter; 137| 1.27k| INSIST(list_rdata != NULL); ------------------ | | 202| 1.27k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.27k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.27k, False: 0] | | | | ------------------ | | | | 55| 1.27k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 138| | 139| 1.27k| dns_rdata_clone(list_rdata, rdata); 140| 1.27k|} dns__rdatalist_count: 154| 6|dns__rdatalist_count(dns_rdataset_t *rdataset) { 155| 6| dns_rdatalist_t *rdatalist = NULL; 156| 6| unsigned int count; 157| | 158| 6| REQUIRE(rdataset != NULL); ------------------ | | 198| 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| | 160| 6| rdatalist = rdataset->rdlist.list; 161| | 162| 6| count = 0; 163| 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] | | ------------------ ------------------ 164| 6| count++; 165| 6| } 166| | 167| 6| return count; 168| 6|} dns__rdatalist_setownercase: 264| 1.13k|dns__rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) { 265| 1.13k| dns_rdatalist_t *rdatalist; 266| 1.13k| unsigned int i; 267| | 268| | /* 269| | * We do not need to worry about label lengths as they are all 270| | * less than or equal to 63. 271| | */ 272| 1.13k| rdatalist = rdataset->rdlist.list; 273| 1.13k| memset(rdatalist->upper, 0, sizeof(rdatalist->upper)); 274| 6.37k| for (i = 1; i < name->length; i++) { ------------------ | Branch (274:14): [True: 5.23k, False: 1.13k] ------------------ 275| 5.23k| if (name->ndata[i] >= 0x41 && name->ndata[i] <= 0x5a) { ------------------ | Branch (275:7): [True: 4.07k, False: 1.16k] | Branch (275:33): [True: 0, False: 4.07k] ------------------ 276| 0| rdatalist->upper[i / 8] |= 1 << (i % 8); 277| 0| } 278| 5.23k| } 279| | /* 280| | * Record that upper has been set. 281| | */ 282| 1.13k| rdatalist->upper[0] |= 0x01; 283| 1.13k|} dns_rdataset_init: 56| 4.34k|dns_rdataset_init(dns_rdataset_t *rdataset) { 57| | /* 58| | * Make 'rdataset' a valid, disassociated rdataset. 59| | */ 60| | 61| 4.34k| REQUIRE(rdataset != NULL); ------------------ | | 198| 4.34k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.34k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.34k, False: 0] | | | | ------------------ | | | | 43| 4.34k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 62| | 63| 4.34k| *rdataset = (dns_rdataset_t){ 64| 4.34k| .magic = DNS_RDATASET_MAGIC, ------------------ | | 88| 4.34k|#define DNS_RDATASET_MAGIC ISC_MAGIC('D', 'N', 'S', 'R') | | ------------------ | | | | 31| 4.34k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 65| 4.34k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.34k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.34k| { \ | | | | 27| 4.34k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.34k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.34k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.34k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.34k| } | | ------------------ ------------------ 66| 4.34k| }; 67| 4.34k|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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.14k|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.14k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 3.14k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.29k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.14k, False: 0] | | | | | Branch (42:11): [True: 3.14k, False: 0] | | | | ------------------ | | | | 43| 3.14k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 91| 3.14k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 3.14k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.14k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.14k, False: 0] | | | | ------------------ | | | | 43| 3.14k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 92| | 93| 3.14k| if (rdataset->methods->disassociate != NULL) { ------------------ | Branch (93:6): [True: 3.14k, False: 0] ------------------ 94| 3.14k| (rdataset->methods->disassociate)(rdataset DNS__DB_FLARG_PASS); 95| 3.14k| } 96| 3.14k| *rdataset = (dns_rdataset_t){ 97| 3.14k| .magic = DNS_RDATASET_MAGIC, ------------------ | | 88| 3.14k|#define DNS_RDATASET_MAGIC ISC_MAGIC('D', 'N', 'S', 'R') | | ------------------ | | | | 31| 3.14k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 98| 3.14k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 3.14k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 3.14k| { \ | | | | 27| 3.14k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.14k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 3.14k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.14k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 3.14k| } | | ------------------ ------------------ 99| 3.14k| }; 100| 3.14k|} dns_rdataset_isassociated: 103| 8.23k|dns_rdataset_isassociated(const dns_rdataset_t *rdataset) { 104| | /* 105| | * Is 'rdataset' associated? 106| | */ 107| | 108| 8.23k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 8.23k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8.23k, False: 0] | | | | | Branch (42:11): [True: 8.23k, False: 0] | | | | ------------------ | | | | 43| 8.23k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 109| | 110| 8.23k| if (rdataset->methods != NULL) { ------------------ | Branch (110:6): [True: 705, False: 7.52k] ------------------ 111| 705| return true; 112| 705| } 113| | 114| 7.52k| return false; 115| 8.23k|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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.40k|dns_rdataset_first(dns_rdataset_t *rdataset) { 181| 1.40k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 1.40k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.80k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.40k, False: 0] | | | | | Branch (42:11): [True: 1.40k, False: 0] | | | | ------------------ | | | | 43| 1.40k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 182| 1.40k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 1.40k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.40k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.40k, False: 0] | | | | ------------------ | | | | 43| 1.40k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 183| 1.40k| REQUIRE(rdataset->methods->first != NULL); ------------------ | | 198| 1.40k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.40k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.40k, False: 0] | | | | ------------------ | | | | 43| 1.40k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 184| | 185| 1.40k| isc_result_t result = rdataset->methods->first(rdataset); 186| 1.40k| ENSURE(result == ISC_R_SUCCESS || result == ISC_R_NOMORE); ------------------ | | 200| 1.40k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.40k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:11): [True: 1.40k, False: 0] | | | | | Branch (48:11): [True: 0, False: 0] | | | | ------------------ | | | | 49| 1.40k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 187| 1.40k| return result; 188| 1.40k|} dns_rdataset_next: 191| 132|dns_rdataset_next(dns_rdataset_t *rdataset) { 192| 132| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 132|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 264| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 132, False: 0] | | | | | Branch (42:11): [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))) | | ------------------ ------------------ 193| 132| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 194| 132| REQUIRE(rdataset->methods->next != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 195| | 196| 132| isc_result_t result = rdataset->methods->next(rdataset); 197| 132| ENSURE(result == ISC_R_SUCCESS || result == ISC_R_NOMORE); ------------------ | | 200| 132|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 264| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:11): [True: 0, False: 132] | | | | | Branch (48:11): [True: 132, False: 0] | | | | ------------------ | | | | 49| 132| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 198| 132| return result; 199| 132|} dns_rdataset_current: 202| 1.40k|dns_rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 203| | /* 204| | * Make 'rdata' refer to the current rdata. 205| | */ 206| | 207| 1.40k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 1.40k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.80k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.40k, False: 0] | | | | | Branch (42:11): [True: 1.40k, False: 0] | | | | ------------------ | | | | 43| 1.40k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 208| 1.40k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 1.40k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.40k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.40k, False: 0] | | | | ------------------ | | | | 43| 1.40k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 209| 1.40k| REQUIRE(rdataset->methods->current != NULL); ------------------ | | 198| 1.40k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.40k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.40k, False: 0] | | | | ------------------ | | | | 43| 1.40k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 210| | 211| 1.40k| (rdataset->methods->current)(rdataset, rdata); 212| 1.40k|} dns_rdataset_setownercase: 517| 1.13k|dns_rdataset_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) { 518| 1.13k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 1.13k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.27k| ((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))) | | ------------------ ------------------ 519| 1.13k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 520| | 521| 1.13k| if (rdataset->methods->setownercase != NULL && ------------------ | Branch (521:6): [True: 1.13k, False: 0] ------------------ 522| 1.13k| !rdataset->attributes.keepcase) ------------------ | Branch (522:6): [True: 1.13k, False: 0] ------------------ 523| 1.13k| { 524| 1.13k| (rdataset->methods->setownercase)(rdataset, name); 525| 1.13k| } 526| 1.13k|} 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| | 356| 6| INSIST(!rdataset->attributes.negative); ------------------ | | 202| 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))) | | ------------------ ------------------ 357| 6| INSIST(rdataset->type != dns_rdatatype_none); ------------------ | | 202| 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))) | | ------------------ ------------------ 358| 6| INSIST(dns_rdatatype_issig(rdataset->type) || ------------------ | | 202| 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))) | | ------------------ ------------------ 359| 6| rdataset->covers == dns_rdatatype_none); 360| | 361| | /* 362| | * Reset the vecheader content, but keep the refcount and mctx. 363| | */ 364| 6| *new = (dns_vecheader_t){ 365| 6| .next_header = ISC_SLINK_INITIALIZER, ------------------ | | 30| 6| { \ | | 31| 6| .next = NULL, \ | | 32| 6| } ------------------ 366| 6| .typepair = DNS_TYPEPAIR_VALUE(rdataset->type, ------------------ | | 46| 6| ({ \ | | 47| 6| DNS__TYPEPAIR_CHECK(base, covers); \ | | ------------------ | | | | 25| 6|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 48| 6| DNS__TYPEPAIR_VALUE(base, covers); \ | | ------------------ | | | | 43| 6| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 6| (((uint32_t)base) & 0xffff)) | | ------------------ | | 49| 6| }) ------------------ 367| 6| rdataset->covers), 368| 6| .trust = rdataset->trust, 369| 6| .ttl = rdataset->ttl, 370| 6| .references = atomic_load_acquire(&new->references), ------------------ | | 50| 6|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 371| 6| .mctx = new->mctx, 372| 6| }; 373| 6| } 374| | 375| 6| return result; 376| 6|} dns_rdatavec_size: 379| 6|dns_rdatavec_size(dns_vecheader_t *header) { 380| 6| REQUIRE(header != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 381| | 382| 6| unsigned char *vec = rdatavec_raw(header); 383| 6| INSIST(vec != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 384| | 385| 6| unsigned char *current = rdatavec_data(header); 386| 6| uint16_t count = rdatavec_count(header); 387| | 388| 12| while (count-- > 0) { ------------------ | Branch (388:9): [True: 6, False: 6] ------------------ 389| 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) | | | | ------------------ | | | | | | 226| 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| }) ------------------ 390| 6| current += length; 391| 6| } 392| | 393| 6| return (unsigned int)(current - vec) + header_size(header); 394| 6|} dns_rdatavec_count: 397| 6|dns_rdatavec_count(dns_vecheader_t *header) { 398| 6| REQUIRE(header != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 399| | 400| 6| return rdatavec_count(header); 401| 6|} dns_vecheader_setownercase: 819| 6|dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name) { 820| 6| REQUIRE(!CASESET(header)); ------------------ | | 198| 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))) | | ------------------ ------------------ 821| | 822| 6| bool casefullylower = true; 823| | 824| | /* 825| | * We do not need to worry about label lengths as they are all 826| | * less than or equal to 63. 827| | */ 828| 6| memset(header->upper, 0, sizeof(header->upper)); 829| 60| for (size_t i = 0; i < name->length; i++) { ------------------ | Branch (829:21): [True: 54, False: 6] ------------------ 830| 54| if (isupper(name->ndata[i])) { ------------------ | Branch (830:7): [True: 0, False: 54] ------------------ 831| 0| header->upper[i / 8] |= 1 << (i % 8); 832| 0| casefullylower = false; 833| 0| } 834| 54| } 835| 6| if (casefullylower) { ------------------ | Branch (835:6): [True: 6, False: 0] ------------------ 836| 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) | | ------------------ ------------------ 837| 6| } 838| | 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) | | ------------------ ------------------ 839| 6|} vecheader_first: 857| 127| dns_rdataclass_t rdclass) { 858| 127| unsigned char *raw = rdatavec_data(header); 859| 127| uint16_t count = rdatavec_count(header); 860| 127| if (count == 0) { ------------------ | Branch (860:6): [True: 0, False: 127] ------------------ 861| 0| iter->iter_pos = NULL; 862| 0| iter->iter_count = 0; 863| 0| return ISC_R_NOMORE; 864| 0| } 865| | 866| | /* 867| | * iter.iter_count is the number of rdata beyond the cursor 868| | * position, so we decrement the total count by one before 869| | * storing it. 870| | * 871| | * 'raw' points to the first record. 872| | */ 873| 127| iter->iter_pos = raw; 874| 127| iter->iter_count = count - 1; 875| 127| iter->iter_rdclass = rdclass; 876| 127| iter->iter_type = DNS_TYPEPAIR_TYPE(header->typepair); ------------------ | | 29| 127| ({ \ | | 30| 127| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 31| 127| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 32| 127| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 127|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 33| 127| __base; \ | | 34| 127| }) ------------------ 877| | 878| 127| return ISC_R_SUCCESS; 879| 127|} vecheader_next: 882| 126|vecheader_next(rdatavec_iter_t *iter) { 883| 126| uint16_t count = iter->iter_count; 884| 126| if (count == 0) { ------------------ | Branch (884:6): [True: 126, False: 0] ------------------ 885| 126| iter->iter_pos = NULL; 886| 126| return ISC_R_NOMORE; 887| 126| } 888| 0| iter->iter_count = count - 1; 889| | 890| | /* 891| | * Skip forward one record (length + 4) or one offset (4). 892| | */ 893| 0| unsigned char *raw = iter->iter_pos; 894| 0| uint16_t length = peek_uint16(raw); ------------------ | | 39| 0|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | ------------------ | | | | 226| 0|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | ------------------ ------------------ 895| 0| raw += length; 896| 0| iter->iter_pos = raw + sizeof(uint16_t); 897| | 898| 0| return ISC_R_SUCCESS; 899| 126|} vecheader_current: 902| 127|vecheader_current(rdatavec_iter_t *iter, dns_rdata_t *rdata) { 903| 127| unsigned char *raw = NULL; 904| 127| unsigned int length; 905| 127| isc_region_t r; 906| 127| unsigned int flags = 0; 907| | 908| 127| raw = iter->iter_pos; 909| 127| REQUIRE(raw != NULL); ------------------ | | 198| 127|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 127| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 127, False: 0] | | | | ------------------ | | | | 43| 127| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 910| | 911| | /* 912| | * Find the start of the record if not already in iter_pos 913| | * then skip the length and order fields. 914| | */ 915| 127| length = get_uint16(raw); ------------------ | | 41| 127| ({ \ | | 42| 127| uint16_t __ret = peek_uint16(buffer); \ | | ------------------ | | | | 39| 127|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | | | ------------------ | | | | | | 226| 127|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | | | ------------------ | | ------------------ | | 43| 127| buffer += sizeof(uint16_t); \ | | 44| 127| __ret; \ | | 45| 127| }) ------------------ 916| | 917| 127| if (iter->iter_type == dns_rdatatype_rrsig) { ------------------ | | 160| 127|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (917:6): [True: 0, False: 127] ------------------ 918| 0| if (*raw & DNS_RDATAVEC_OFFLINE) { ------------------ | | 59| 0|#define DNS_RDATAVEC_OFFLINE 0x01 /* RRSIG is for offline DNSKEY */ ------------------ | Branch (918:7): [True: 0, False: 0] ------------------ 919| 0| flags |= DNS_RDATA_OFFLINE; ------------------ | | 167| 0|#define DNS_RDATA_OFFLINE 0x0002 /*%< RRSIG has a offline key. */ ------------------ 920| 0| } 921| 0| length--; 922| 0| raw++; 923| 0| } 924| 127| r.length = length; 925| 127| r.base = raw; 926| 127| dns_rdata_fromregion(rdata, iter->iter_rdclass, iter->iter_type, &r); 927| 127| rdata->flags |= flags; 928| 127|} dns_vectop_new: 1023| 6|dns_vectop_new(isc_mem_t *mctx, dns_typepair_t typepair) { 1024| 6| dns_vectop_t *top = isc_mem_get(mctx, sizeof(*top)); ------------------ | | 144| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1025| 6| *top = (dns_vectop_t){ 1026| 6| .next_type = ISC_SLINK_INITIALIZER, ------------------ | | 30| 6| { \ | | 31| 6| .next = NULL, \ | | 32| 6| } ------------------ 1027| 6| .headers = ISC_SLIST_INITIALIZER, ------------------ | | 25| 6| { \ | | 26| 6| .head = NULL, \ | | 27| 6| } ------------------ 1028| 6| .typepair = typepair, 1029| 6| }; 1030| | 1031| 6| return top; 1032| 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); ------------------ | | 202| 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); \ | | ------------------ | | | | 223| 0| (p)[0] = (uint8_t)((v) >> 8); \ | | | | 224| 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]))); ------------------ | | 245| 6| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 6, False: 0] | | ------------------ ------------------ 211| 6| rdata = isc_mem_get(mctx, rdatasize); ------------------ | | 144| 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); ------------------ | | 202| 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); ------------------ | | 202| 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); \ | | ------------------ | | | | 223| 6| (p)[0] = (uint8_t)((v) >> 8); \ | | | | 224| 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); ------------------ | | 202| 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); \ | | ------------------ | | | | 223| 6| (p)[0] = (uint8_t)((v) >> 8); \ | | | | 224| 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); ------------------ | | 171| 6| do { \ | | 172| 6| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 6| (p) = NULL; \ | | 174| 6| } while (0) | | ------------------ | | | Branch (174: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); ------------------ | | 144| 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| 278|rdatavec_raw(dns_vecheader_t *header) { 109| 278| unsigned char *as_char_star = (unsigned char *)header; 110| 278| unsigned char *raw = as_char_star + header_size(header); 111| | 112| 278| return raw; 113| 278|} rdatavec.c:rdatavec_data: 116| 133|rdatavec_data(dns_vecheader_t *header) { 117| 133| return rdatavec_raw(header) + 2; 118| 133|} rdatavec.c:rdatavec_count: 121| 139|rdatavec_count(dns_vecheader_t *header) { 122| 139| unsigned char *raw = rdatavec_raw(header); 123| 139| unsigned int count = get_uint16(raw); ------------------ | | 41| 139| ({ \ | | 42| 139| uint16_t __ret = peek_uint16(buffer); \ | | ------------------ | | | | 39| 139|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | | | ------------------ | | | | | | 226| 139|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | | | ------------------ | | ------------------ | | 43| 139| buffer += sizeof(uint16_t); \ | | 44| 139| __ret; \ | | 45| 139| }) ------------------ 124| | 125| 139| return count; 126| 139|} rdatavec.c:header_size: 102| 284|header_size(const dns_vecheader_t *header) { 103| 284| UNUSED(header); ------------------ | | 69| 284|#define UNUSED(x) (void)(x) ------------------ 104| 284| return sizeof(dns_vecheader_t); 105| 284|} rdatavec.c:rdataset_disassociate: 933| 127|rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 934| 127| dns_vecheader_unref(rdataset->vec.header); 935| 127|} rdatavec.c:rdataset_first: 938| 127|rdataset_first(dns_rdataset_t *rdataset) { 939| 127| return vecheader_first(&rdataset->vec.iter, rdataset->vec.header, 940| 127| rdataset->rdclass); 941| 127|} rdatavec.c:rdataset_next: 944| 126|rdataset_next(dns_rdataset_t *rdataset) { 945| 126| return vecheader_next(&rdataset->vec.iter); 946| 126|} rdatavec.c:rdataset_current: 949| 127|rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 950| 127| vecheader_current(&rdataset->vec.iter, rdata); 951| 127|} dns__tsig_algvalid: 100| 576|dns__tsig_algvalid(unsigned int alg) { 101| 576| return alg == DST_ALG_HMACMD5 || alg == DST_ALG_HMACSHA1 || ------------------ | Branch (101:9): [True: 1, False: 575] | Branch (101:35): [True: 2, False: 573] ------------------ 102| 573| alg == DST_ALG_HMACSHA224 || alg == DST_ALG_HMACSHA256 || ------------------ | Branch (102:9): [True: 2, False: 571] | Branch (102:38): [True: 213, False: 358] ------------------ 103| 358| alg == DST_ALG_HMACSHA384 || alg == DST_ALG_HMACSHA512; ------------------ | Branch (103:9): [True: 1, False: 357] | Branch (103:38): [True: 1, False: 356] ------------------ 104| 576|} dns_tsigkey_createfromkey: 158| 367| dns_tsigkey_t **keyp) { 159| 367| dns_tsigkey_t *tkey = NULL; 160| 367| isc_result_t result; 161| | 162| 367| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 198| 367|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 734| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 367, False: 0] | | | | | Branch (42:11): [True: 367, False: 0] | | | | ------------------ | | | | 43| 367| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 163| 367| REQUIRE(name != NULL); ------------------ | | 198| 367|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 367| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 367, False: 0] | | | | ------------------ | | | | 43| 367| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 164| 367| REQUIRE(mctx != NULL); ------------------ | | 198| 367|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 367| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 367, False: 0] | | | | ------------------ | | | | 43| 367| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 165| | 166| 367| tkey = isc_mem_get(mctx, sizeof(dns_tsigkey_t)); ------------------ | | 144| 367|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 167| 367| *tkey = (dns_tsigkey_t){ 168| 367| .generated = generated, 169| 367| .restored = restored, 170| 367| .inception = inception, 171| 367| .expire = expire, 172| 367| .alg = algorithm, 173| 367| .algname = DNS_NAME_INITEMPTY, ------------------ | | 183| 367| { .magic = DNS_NAME_MAGIC, \ | | ------------------ | | | | 121| 367|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | | | ------------------ | | | | | | 31| 367|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ | | 184| 367| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 367|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 367| { \ | | | | | | 27| 367| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 367|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 367| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 367|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 367| } | | | | ------------------ | | ------------------ | | 185| 367| .list = ISC_LIST_INITIALIZER } | | ------------------ | | | | 21| 367| { \ | | | | 22| 367| .head = NULL, \ | | | | 23| 367| .tail = NULL, \ | | | | 24| 367| } | | ------------------ ------------------ 174| 367| .lrulink = ISC_LINK_INITIALIZER, ------------------ | | 30| 367|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 367| { \ | | | | 27| 367| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 367|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 367| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 367|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 367| } | | ------------------ ------------------ 175| 367| }; 176| | 177| 367| tkey->name = dns_fixedname_initname(&tkey->fn); 178| 367| dns_name_copy(name, tkey->name); 179| 367| (void)dns_name_downcase(tkey->name, tkey->name); 180| | 181| 367| if (algorithm != DST_ALG_UNKNOWN) { ------------------ | Branch (181:6): [True: 12, False: 355] ------------------ 182| 12| if (dstkey != NULL && dst_key_alg(dstkey) != algorithm) { ------------------ | Branch (182:7): [True: 2, False: 10] | Branch (182:25): [True: 0, False: 2] ------------------ 183| 0| result = DNS_R_BADALG; 184| 0| goto cleanup_name; 185| 0| } 186| 355| } else if (dstkey != NULL) { ------------------ | Branch (186:13): [True: 0, False: 355] ------------------ 187| 0| result = DNS_R_BADALG; 188| 0| goto cleanup_name; 189| 0| } 190| | 191| 367| if (creator != NULL) { ------------------ | Branch (191:6): [True: 0, False: 367] ------------------ 192| 0| tkey->creator = isc_mem_get(mctx, sizeof(dns_name_t)); ------------------ | | 144| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 193| 0| dns_name_init(tkey->creator); 194| 0| dns_name_dup(creator, mctx, tkey->creator); 195| 0| } 196| | 197| 367| if (dstkey != NULL) { ------------------ | Branch (197:6): [True: 2, False: 365] ------------------ 198| 2| dst_key_attach(dstkey, &tkey->key); 199| 2| } 200| | 201| 367| isc_refcount_init(&tkey->references, 1); ------------------ | | 44| 367|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 202| 367| isc_mem_attach(mctx, &tkey->mctx); 203| | 204| | /* 205| | * Ignore this if it's a GSS key, since the key size is meaningless. 206| | */ 207| 367| if (dstkey != NULL && dst_key_size(dstkey) < 64 && ------------------ | Branch (207:6): [True: 2, False: 365] | Branch (207:24): [True: 0, False: 2] ------------------ 208| 0| algorithm != DST_ALG_GSSAPI) ------------------ | Branch (208:6): [True: 0, False: 0] ------------------ 209| 0| { 210| 0| char namestr[DNS_NAME_FORMATSIZE]; 211| 0| dns_name_format(name, namestr, sizeof(namestr)); 212| 0| isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, 213| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 214| 0| "the key '%s' is too short to be secure", 215| 0| namestr); 216| 0| } 217| | 218| 367| tkey->magic = TSIG_MAGIC; ------------------ | | 45| 367|#define TSIG_MAGIC ISC_MAGIC('T', 'S', 'I', 'G') | | ------------------ | | | | 31| 367|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 219| | 220| 367| if (tkey->restored) { ------------------ | Branch (220:6): [True: 0, False: 367] ------------------ 221| 0| tsig_log(tkey, ISC_LOG_DEBUG(3), "restored from file"); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 222| 367| } else if (tkey->generated) { ------------------ | Branch (222:13): [True: 0, False: 367] ------------------ 223| 0| tsig_log(tkey, ISC_LOG_DEBUG(3), "generated"); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 224| 367| } else { 225| 367| tsig_log(tkey, ISC_LOG_DEBUG(3), "statically configured"); ------------------ | | 36| 367|#define ISC_LOG_DEBUG(level) (level) ------------------ 226| 367| } 227| | 228| 367| SET_IF_NOT_NULL(keyp, tkey); ------------------ | | 104| 367| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 367, False: 0] | | ------------------ | | 105| 367| *(obj) = (val); \ | | 106| 367| } ------------------ 229| 367| return ISC_R_SUCCESS; 230| | 231| 0|cleanup_name: 232| 0| isc_mem_put(mctx, tkey, sizeof(dns_tsigkey_t)); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 233| | 234| 0| return result; 235| 367|} dns__tsig_algfromname: 281| 621|dns__tsig_algfromname(const dns_name_t *algorithm) { 282| 4.89k| for (size_t i = 0; i < ARRAY_SIZE(known_algs); ++i) { ------------------ | | 98| 4.89k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (282:21): [True: 4.28k, False: 601] ------------------ 283| 4.28k| const dns_name_t *name = known_algs[i].name; 284| 4.28k| if (algorithm == name || dns_name_equal(algorithm, name)) { ------------------ | Branch (284:7): [True: 0, False: 4.28k] | Branch (284:28): [True: 20, False: 4.26k] ------------------ 285| 20| return known_algs[i].dstalg; 286| 20| } 287| 4.28k| } 288| 601| return DST_ALG_UNKNOWN; 289| 621|} dns_tsigkey_create: 428| 367| dns_tsigkey_t **key) { 429| 367| dst_key_t *dstkey = NULL; 430| 367| isc_result_t result; 431| | 432| 367| REQUIRE(length >= 0); ------------------ | | 198| 367|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 367| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 367, False: 0] | | | | ------------------ | | | | 43| 367| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 433| 367| if (length > 0) { ------------------ | Branch (433:6): [True: 2, False: 365] ------------------ 434| 2| REQUIRE(secret != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 435| 2| } 436| | 437| 367| if (dns__tsig_algvalid(algorithm)) { ------------------ | Branch (437:6): [True: 11, False: 356] ------------------ 438| 11| if (secret != NULL) { ------------------ | Branch (438:7): [True: 2, False: 9] ------------------ 439| 2| isc_buffer_t b; 440| | 441| 2| isc_buffer_init(&b, secret, length); 442| 2| isc_buffer_add(&b, length); 443| 2| RETERR(dst_key_frombuffer( ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 444| 2| name, algorithm, 0, DNS_KEYPROTO_DNSSEC, 445| 2| dns_rdataclass_in, &b, mctx, &dstkey)); 446| 2| } 447| 356| } else if (length > 0) { ------------------ | Branch (447:13): [True: 0, False: 356] ------------------ 448| 0| return DNS_R_BADALG; 449| 0| } 450| | 451| 367| result = dns_tsigkey_createfromkey(name, algorithm, dstkey, false, 452| 367| false, NULL, 0, 0, mctx, key); 453| 367| if (dstkey != NULL) { ------------------ | Branch (453:6): [True: 2, False: 365] ------------------ 454| 2| dst_key_free(&dstkey); 455| 2| } 456| 367| return result; 457| 367|} dns_tsig_verify: 783| 630| dns_tsigkeyring_t *ring1, dns_tsigkeyring_t *ring2) { 784| 630| dns_rdata_any_tsig_t tsig, querytsig; 785| 630| isc_region_t r, source_r, header_r, sig_r; 786| 630| isc_buffer_t databuf; 787| 630| unsigned char data[32]; 788| 630| dns_name_t *keyname = NULL; 789| 630| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 147| 630| { \ | | 148| 630| .data = NULL, \ | | 149| 630| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 630|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 630| { \ | | | | | | 27| 630| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 630|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 630| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 630|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 630| } | | | | ------------------ | | ------------------ | | 150| 630| } ------------------ 790| 630| isc_stdtime_t now; 791| 630| isc_result_t result; 792| 630| dns_tsigkey_t *tsigkey = NULL; 793| 630| dst_key_t *key = NULL; 794| 630| unsigned char header[DNS_MESSAGE_HEADERLEN]; 795| 630| dst_context_t *ctx = NULL; 796| 630| isc_mem_t *mctx = NULL; 797| 630| uint16_t addcount, id; 798| 630| unsigned int siglen; 799| 630| unsigned int alg; 800| 630| bool response; 801| | 802| 630| REQUIRE(source != NULL); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 630| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 803| 630| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 630, False: 0] | | | | | Branch (42:11): [True: 630, False: 0] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 804| 630| tsigkey = dns_message_gettsigkey(msg); 805| 630| response = is_response(msg); ------------------ | | 48| 630|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) ------------------ 806| | 807| 630| REQUIRE(tsigkey == NULL || VALID_TSIGKEY(tsigkey)); ------------------ | | 198| 630|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 260, False: 0] | | | | | Branch (42:11): [True: 260, False: 0] | | | | | Branch (42:11): [True: 370, False: 260] | | | | ------------------ | | | | 43| 630| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| | 809| 630| msg->verify_attempted = 1; 810| 630| msg->verified_sig = 0; 811| 630| msg->tsigstatus = dns_tsigerror_badsig; 812| | 813| 630| if (msg->tcp_continuation) { ------------------ | Branch (813:6): [True: 0, False: 630] ------------------ 814| 0| if (tsigkey == NULL || msg->querytsig == NULL) { ------------------ | Branch (814:7): [True: 0, False: 0] | Branch (814:26): [True: 0, False: 0] ------------------ 815| 0| return DNS_R_UNEXPECTEDTSIG; 816| 0| } 817| 0| return tsig_verify_tcp(source, msg); 818| 0| } 819| | 820| | /* 821| | * There should be a TSIG record... 822| | */ 823| 630| if (msg->tsig == NULL) { ------------------ | Branch (823:6): [True: 48, False: 582] ------------------ 824| 48| return DNS_R_EXPECTEDTSIG; 825| 48| } 826| | 827| | /* 828| | * If this is a response and there's no key or query TSIG, there 829| | * shouldn't be one on the response. 830| | */ 831| 582| if (response && (tsigkey == NULL || msg->querytsig == NULL)) { ------------------ | Branch (831:6): [True: 150, False: 432] | Branch (831:19): [True: 2, False: 148] | Branch (831:38): [True: 1, False: 147] ------------------ 832| 3| return DNS_R_UNEXPECTEDTSIG; 833| 3| } 834| | 835| 579| mctx = msg->mctx; 836| | 837| | /* 838| | * If we're here, we know the message is well formed and contains a 839| | * TSIG record. 840| | */ 841| | 842| 579| keyname = msg->tsigname; 843| 579| RETERR(dns_rdataset_first(msg->tsig)); ------------------ | | 276| 579| { \ | | 277| 579| isc_result_t _r = (x); \ | | 278| 579| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 579] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 579| } ------------------ 844| 579| dns_rdataset_current(msg->tsig, &rdata); 845| 579| RETERR(dns_rdata_tostruct(&rdata, &tsig, NULL)); ------------------ | | 276| 579| { \ | | 277| 579| isc_result_t _r = (x); \ | | 278| 579| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 579] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 579| } ------------------ 846| 579| dns_rdata_reset(&rdata); 847| 579| if (response) { ------------------ | Branch (847:6): [True: 147, False: 432] ------------------ 848| 147| RETERR(dns_rdataset_first(msg->querytsig)); ------------------ | | 276| 147| { \ | | 277| 147| isc_result_t _r = (x); \ | | 278| 147| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 147] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 147| } ------------------ 849| 147| dns_rdataset_current(msg->querytsig, &rdata); 850| 147| RETERR(dns_rdata_tostruct(&rdata, &querytsig, NULL)); ------------------ | | 276| 147| { \ | | 277| 147| isc_result_t _r = (x); \ | | 278| 147| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 147] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 147| } ------------------ 851| 147| } 852| | 853| | /* 854| | * Do the key name and algorithm match that of the query? 855| | */ 856| 579| if (response && ------------------ | Branch (856:6): [True: 147, False: 432] ------------------ 857| 147| (!dns_name_equal(keyname, tsigkey->name) || ------------------ | Branch (857:7): [True: 0, False: 147] ------------------ 858| 147| !dns_name_equal(&tsig.algorithm, &querytsig.algorithm))) ------------------ | Branch (858:7): [True: 24, False: 123] ------------------ 859| 24| { 860| 24| msg->tsigstatus = dns_tsigerror_badkey; 861| 24| tsig_log(msg->tsigkey, 2, 862| 24| "key name and algorithm do not match"); 863| 24| return DNS_R_TSIGVERIFYFAILURE; 864| 24| } 865| | 866| | /* 867| | * Get the current time. 868| | */ 869| 555| if (msg->fuzzing) { ------------------ | Branch (869:6): [True: 555, False: 0] ------------------ 870| 555| now = msg->fuzztime; 871| 555| } else { 872| 0| now = isc_stdtime_now(); 873| 0| } 874| | 875| | /* 876| | * Find dns_tsigkey_t based on keyname. 877| | */ 878| 555| if (tsigkey == NULL) { ------------------ | Branch (878:6): [True: 368, False: 187] ------------------ 879| 368| result = ISC_R_NOTFOUND; 880| 368| if (ring1 != NULL) { ------------------ | Branch (880:7): [True: 356, False: 12] ------------------ 881| 356| result = dns_tsigkey_find(&tsigkey, keyname, 882| 356| &tsig.algorithm, ring1); 883| 356| } 884| 368| if (result == ISC_R_NOTFOUND && ring2 != NULL) { ------------------ | Branch (884:7): [True: 365, False: 3] | Branch (884:35): [True: 353, False: 12] ------------------ 885| 353| result = dns_tsigkey_find(&tsigkey, keyname, 886| 353| &tsig.algorithm, ring2); 887| 353| } 888| 368| if (result != ISC_R_SUCCESS) { ------------------ | Branch (888:7): [True: 365, False: 3] ------------------ 889| 365| msg->tsigstatus = dns_tsigerror_badkey; 890| 365| alg = dns__tsig_algfromname(&tsig.algorithm); 891| 365| RETERR(dns_tsigkey_create(keyname, alg, NULL, 0, mctx, ------------------ | | 276| 365| { \ | | 277| 365| isc_result_t _r = (x); \ | | 278| 365| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 365] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 365| } ------------------ 892| 365| &msg->tsigkey)); 893| 365| if (alg == DST_ALG_UNKNOWN) { ------------------ | Branch (893:8): [True: 355, False: 10] ------------------ 894| 355| dns_name_clone(&tsig.algorithm, 895| 355| &msg->tsigkey->algname); 896| 355| } 897| | 898| 365| tsig_log(msg->tsigkey, 2, "unknown key"); 899| 365| return DNS_R_TSIGVERIFYFAILURE; 900| 365| } 901| 3| msg->tsigkey = tsigkey; 902| 3| } 903| | 904| 190| key = tsigkey->key; 905| | 906| | /* 907| | * Check digest length. 908| | */ 909| 190| alg = dst_key_alg(key); 910| 190| RETERR(dst_key_sigsize(key, &siglen)); ------------------ | | 276| 190| { \ | | 277| 190| isc_result_t _r = (x); \ | | 278| 190| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 190] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 190| } ------------------ 911| 190| if (dns__tsig_algvalid(alg)) { ------------------ | Branch (911:6): [True: 190, False: 0] ------------------ 912| 190| if (tsig.siglen > siglen) { ------------------ | Branch (912:7): [True: 19, False: 171] ------------------ 913| 19| tsig_log(msg->tsigkey, 2, "signature length too big"); 914| 19| return DNS_R_FORMERR; 915| 19| } 916| 171| if (tsig.siglen > 0 && ------------------ | Branch (916:7): [True: 49, False: 122] ------------------ 917| 49| (tsig.siglen < 10 || tsig.siglen < ((siglen + 1) / 2))) ------------------ | Branch (917:8): [True: 11, False: 38] | Branch (917:28): [True: 4, False: 34] ------------------ 918| 15| { 919| 15| tsig_log(msg->tsigkey, 2, 920| 15| "signature length below minimum"); 921| 15| return DNS_R_FORMERR; 922| 15| } 923| 171| } 924| | 925| 156| if (tsig.siglen > 0) { ------------------ | Branch (925:6): [True: 34, False: 122] ------------------ 926| 34| uint16_t addcount_n; 927| | 928| 34| sig_r.base = tsig.signature; 929| 34| sig_r.length = tsig.siglen; 930| | 931| 34| RETERR(dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, ------------------ | | 276| 34| { \ | | 277| 34| isc_result_t _r = (x); \ | | 278| 34| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 34] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 34| } ------------------ 932| 34| false, &ctx)); 933| | 934| 34| if (response) { ------------------ | Branch (934:7): [True: 3, False: 31] ------------------ 935| 3| isc_buffer_init(&databuf, data, sizeof(data)); 936| 3| isc_buffer_putuint16(&databuf, querytsig.siglen); 937| 3| isc_buffer_usedregion(&databuf, &r); 938| 3| result = dst_context_adddata(ctx, &r); 939| 3| if (result != ISC_R_SUCCESS) { ------------------ | Branch (939:8): [True: 0, False: 3] ------------------ 940| 0| goto cleanup_context; 941| 0| } 942| 3| if (querytsig.siglen > 0) { ------------------ | Branch (942:8): [True: 3, False: 0] ------------------ 943| 3| r.length = querytsig.siglen; 944| 3| r.base = querytsig.signature; 945| 3| result = dst_context_adddata(ctx, &r); 946| 3| if (result != ISC_R_SUCCESS) { ------------------ | Branch (946:9): [True: 0, False: 3] ------------------ 947| 0| goto cleanup_context; 948| 0| } 949| 3| } 950| 3| } 951| | 952| | /* 953| | * Extract the header. 954| | */ 955| 34| isc_buffer_usedregion(source, &r); 956| 34| memmove(header, r.base, DNS_MESSAGE_HEADERLEN); ------------------ | | 145| 34|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 957| 34| isc_region_consume(&r, DNS_MESSAGE_HEADERLEN); ------------------ | | 50| 34| do { \ | | 51| 34| isc_region_t *_r = (r); \ | | 52| 34| unsigned int _l = (l); \ | | 53| 34| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 34|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 34| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 34, False: 0] | | | | | | ------------------ | | | | | | 55| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 54| 34| _r->base += _l; \ | | 55| 34| _r->length -= _l; \ | | 56| 34| } while (0) | | ------------------ | | | Branch (56:11): [Folded, False: 34] | | ------------------ ------------------ 958| | 959| | /* 960| | * Decrement the additional field counter. 961| | */ 962| 34| memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2); ------------------ | | 145| 34|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 963| 34| addcount_n = ntohs(addcount); 964| 34| addcount = htons((uint16_t)(addcount_n - 1)); 965| 34| memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2); ------------------ | | 145| 34|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 966| | 967| | /* 968| | * Put in the original id. 969| | */ 970| 34| id = htons(tsig.originalid); 971| 34| memmove(&header[0], &id, 2); 972| | 973| | /* 974| | * Digest the modified header. 975| | */ 976| 34| header_r.base = (unsigned char *)header; 977| 34| header_r.length = DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 34|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 978| 34| result = dst_context_adddata(ctx, &header_r); 979| 34| if (result != ISC_R_SUCCESS) { ------------------ | Branch (979:7): [True: 0, False: 34] ------------------ 980| 0| goto cleanup_context; 981| 0| } 982| | 983| | /* 984| | * Digest all non-TSIG records. 985| | */ 986| 34| isc_buffer_usedregion(source, &source_r); 987| 34| r.base = source_r.base + DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 34|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 988| 34| r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 34|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 989| 34| result = dst_context_adddata(ctx, &r); 990| 34| if (result != ISC_R_SUCCESS) { ------------------ | Branch (990:7): [True: 0, False: 34] ------------------ 991| 0| goto cleanup_context; 992| 0| } 993| | 994| | /* 995| | * Digest the key name. 996| | */ 997| 34| dns_name_toregion(tsigkey->name, &r); 998| 34| result = dst_context_adddata(ctx, &r); 999| 34| if (result != ISC_R_SUCCESS) { ------------------ | Branch (999:7): [True: 0, False: 34] ------------------ 1000| 0| goto cleanup_context; 1001| 0| } 1002| | 1003| 34| isc_buffer_init(&databuf, data, sizeof(data)); 1004| 34| isc_buffer_putuint16(&databuf, tsig.common.rdclass); 1005| 34| isc_buffer_putuint32(&databuf, msg->tsig->ttl); 1006| 34| isc_buffer_usedregion(&databuf, &r); 1007| 34| result = dst_context_adddata(ctx, &r); 1008| 34| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1008:7): [True: 0, False: 34] ------------------ 1009| 0| goto cleanup_context; 1010| 0| } 1011| | 1012| | /* 1013| | * Digest the key algorithm. 1014| | */ 1015| 34| dns_name_toregion(dns_tsigkey_algorithm(tsigkey), &r); 1016| 34| result = dst_context_adddata(ctx, &r); 1017| 34| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1017:7): [True: 0, False: 34] ------------------ 1018| 0| goto cleanup_context; 1019| 0| } 1020| | 1021| 34| isc_buffer_clear(&databuf); 1022| 34| isc_buffer_putuint48(&databuf, tsig.timesigned); 1023| 34| isc_buffer_putuint16(&databuf, tsig.fudge); 1024| 34| isc_buffer_putuint16(&databuf, tsig.error); 1025| 34| isc_buffer_putuint16(&databuf, tsig.otherlen); 1026| 34| isc_buffer_usedregion(&databuf, &r); 1027| 34| result = dst_context_adddata(ctx, &r); 1028| 34| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1028:7): [True: 0, False: 34] ------------------ 1029| 0| goto cleanup_context; 1030| 0| } 1031| | 1032| 34| if (tsig.otherlen > 0) { ------------------ | Branch (1032:7): [True: 17, False: 17] ------------------ 1033| 17| r.base = tsig.other; 1034| 17| r.length = tsig.otherlen; 1035| 17| result = dst_context_adddata(ctx, &r); 1036| 17| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1036:8): [True: 0, False: 17] ------------------ 1037| 0| goto cleanup_context; 1038| 0| } 1039| 17| } 1040| | 1041| 34| result = dst_context_verify(ctx, &sig_r); 1042| 34| if (result == DST_R_VERIFYFAILURE) { ------------------ | Branch (1042:7): [True: 27, False: 7] ------------------ 1043| 27| result = DNS_R_TSIGVERIFYFAILURE; 1044| 27| tsig_log(msg->tsigkey, 2, 1045| 27| "signature failed to verify(1)"); 1046| 27| goto cleanup_context; 1047| 27| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1047:14): [True: 0, False: 7] ------------------ 1048| 0| goto cleanup_context; 1049| 0| } 1050| 7| msg->verified_sig = 1; 1051| 122| } else if (!response || (tsig.error != dns_tsigerror_badsig && ------------------ | Branch (1051:13): [True: 6, False: 116] | Branch (1051:27): [True: 54, False: 62] ------------------ 1052| 54| tsig.error != dns_tsigerror_badkey)) ------------------ | Branch (1052:6): [True: 21, False: 33] ------------------ 1053| 27| { 1054| 27| tsig_log(msg->tsigkey, 2, "signature was empty"); 1055| 27| return DNS_R_TSIGVERIFYFAILURE; 1056| 27| } 1057| | 1058| | /* 1059| | * Here at this point, the MAC has been verified. Even if any of 1060| | * the following code returns a TSIG error, the reply will be 1061| | * signed and WILL always include the request MAC in the digest 1062| | * computation. 1063| | */ 1064| | 1065| | /* 1066| | * Is the time ok? 1067| | */ 1068| 102| if (now + msg->timeadjust > tsig.timesigned + tsig.fudge) { ------------------ | Branch (1068:6): [True: 2, False: 100] ------------------ 1069| 2| msg->tsigstatus = dns_tsigerror_badtime; 1070| 2| tsig_log(msg->tsigkey, 2, "signature has expired"); 1071| 2| result = DNS_R_CLOCKSKEW; 1072| 2| goto cleanup_context; 1073| 100| } else if (now + msg->timeadjust < tsig.timesigned - tsig.fudge) { ------------------ | Branch (1073:13): [True: 81, False: 19] ------------------ 1074| 81| msg->tsigstatus = dns_tsigerror_badtime; 1075| 81| tsig_log(msg->tsigkey, 2, "signature is in the future"); 1076| 81| result = DNS_R_CLOCKSKEW; 1077| 81| goto cleanup_context; 1078| 81| } 1079| | 1080| 19| if (dns__tsig_algvalid(alg)) { ------------------ | Branch (1080:6): [True: 19, False: 0] ------------------ 1081| 19| uint16_t digestbits = dst_key_getbits(key); 1082| | 1083| 19| if (tsig.siglen > 0 && digestbits != 0 && ------------------ | Branch (1083:7): [True: 7, False: 12] | Branch (1083:26): [True: 0, False: 7] ------------------ 1084| 0| tsig.siglen < ((digestbits + 7) / 8)) ------------------ | Branch (1084:7): [True: 0, False: 0] ------------------ 1085| 0| { 1086| 0| msg->tsigstatus = dns_tsigerror_badtrunc; 1087| 0| tsig_log(msg->tsigkey, 2, 1088| 0| "truncated signature length too small"); 1089| 0| result = DNS_R_TSIGVERIFYFAILURE; 1090| 0| goto cleanup_context; 1091| 0| } 1092| 19| if (tsig.siglen > 0 && digestbits == 0 && tsig.siglen < siglen) ------------------ | Branch (1092:7): [True: 7, False: 12] | Branch (1092:26): [True: 7, False: 0] | Branch (1092:45): [True: 5, False: 2] ------------------ 1093| 5| { 1094| 5| msg->tsigstatus = dns_tsigerror_badtrunc; 1095| 5| tsig_log(msg->tsigkey, 2, "signature length too small"); 1096| 5| result = DNS_R_TSIGVERIFYFAILURE; 1097| 5| goto cleanup_context; 1098| 5| } 1099| 19| } 1100| | 1101| 14| if (response && tsig.error != dns_rcode_noerror) { ------------------ | | 269| 13|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ | Branch (1101:6): [True: 13, False: 1] | Branch (1101:18): [True: 12, False: 1] ------------------ 1102| 12| msg->tsigstatus = tsig.error; 1103| 12| if (tsig.error == dns_tsigerror_badtime) { ------------------ | Branch (1103:7): [True: 0, False: 12] ------------------ 1104| 0| result = DNS_R_CLOCKSKEW; 1105| 12| } else { 1106| 12| result = DNS_R_TSIGERRORSET; 1107| 12| } 1108| 12| goto cleanup_context; 1109| 12| } 1110| | 1111| 2| msg->tsigstatus = dns_rcode_noerror; ------------------ | | 269| 2|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 1112| 2| result = ISC_R_SUCCESS; 1113| | 1114| 129|cleanup_context: 1115| 129| if (ctx != NULL) { ------------------ | Branch (1115:6): [True: 34, False: 95] ------------------ 1116| 34| dst_context_destroy(&ctx); 1117| 34| } 1118| | 1119| 129| return result; 1120| 2|} dns_tsigkey_find: 1439| 709| const dns_name_t *algorithm, dns_tsigkeyring_t *ring) { 1440| 709| dns_tsigkey_t *key = NULL; 1441| 709| isc_result_t result; 1442| 709| isc_rwlocktype_t locktype = isc_rwlocktype_read; 1443| 709| isc_stdtime_t now = isc_stdtime_now(); 1444| | 1445| 709| REQUIRE(name != NULL); ------------------ | | 198| 709|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 709| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 709, False: 0] | | | | ------------------ | | | | 43| 709| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1446| 709| REQUIRE(VALID_TSIGKEYRING(ring)); ------------------ | | 198| 709|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 709, False: 0] | | | | | Branch (42:11): [True: 709, False: 0] | | | | ------------------ | | | | 43| 709| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1447| 709| REQUIRE(tsigkey != NULL && *tsigkey == NULL); ------------------ | | 198| 709|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 709, False: 0] | | | | | Branch (42:11): [True: 709, False: 0] | | | | ------------------ | | | | 43| 709| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1448| | 1449| 709|again: 1450| 709| RWLOCK(&ring->lock, locktype); ------------------ | | 30| 709| { \ | | 31| 709| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 709| (t), __FILE__, __LINE__)); \ | | 33| 709| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 709| { \ | | | | 253| 709| switch (type) { \ | | | | 254| 709| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 709, False: 0] | | | | ------------------ | | | | 255| 709| isc_rwlock_rdlock(rwl); \ | | | | 256| 709| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 709] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 709] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 709| } \ | | | | 263| 709| } | | ------------------ | | 34| 709| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 709| (lp), (t), __FILE__, __LINE__)); \ | | 36| 709| } ------------------ 1451| 709| result = isc_hashmap_find(ring->keys, dns_name_hash(name), tkey_match, 1452| 709| name, (void **)&key); 1453| 709| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (1453:6): [True: 453, False: 256] ------------------ 1454| 453| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 453| { \ | | 39| 453| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 453| (lp), (t), __FILE__, __LINE__)); \ | | 41| 453| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 453| { \ | | | | 283| 453| switch (type) { \ | | | | 284| 453| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 453, False: 0] | | | | ------------------ | | | | 285| 453| isc_rwlock_rdunlock(rwl); \ | | | | 286| 453| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 453] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 453] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 453| } \ | | | | 293| 453| } | | ------------------ | | 42| 453| } ------------------ 1455| 453| return result; 1456| 453| } 1457| | 1458| 256| if (algorithm != NULL && key->alg != dns__tsig_algfromname(algorithm)) { ------------------ | Branch (1458:6): [True: 256, False: 0] | Branch (1458:27): [True: 253, False: 3] ------------------ 1459| 253| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 253| { \ | | 39| 253| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 253| (lp), (t), __FILE__, __LINE__)); \ | | 41| 253| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 253| { \ | | | | 283| 253| switch (type) { \ | | | | 284| 253| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 253, False: 0] | | | | ------------------ | | | | 285| 253| isc_rwlock_rdunlock(rwl); \ | | | | 286| 253| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 253] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 253] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 253| } \ | | | | 293| 253| } | | ------------------ | | 42| 253| } ------------------ 1460| 253| return ISC_R_NOTFOUND; 1461| 253| } 1462| 3| if (key->inception != key->expire && isc_serial_lt(key->expire, now)) { ------------------ | Branch (1462:6): [True: 0, False: 3] | Branch (1462:39): [True: 0, False: 0] ------------------ 1463| | /* 1464| | * The key has expired. 1465| | */ 1466| 0| if (locktype == isc_rwlocktype_read) { ------------------ | Branch (1466:7): [True: 0, False: 0] ------------------ 1467| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1468| 0| locktype = isc_rwlocktype_write; 1469| 0| key = NULL; 1470| 0| goto again; 1471| 0| } 1472| 0| dns__tsigkey_delete(ring, key); 1473| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1474| 0| return ISC_R_NOTFOUND; 1475| 0| } 1476| 3| dns_tsigkey_ref(key); 1477| 3| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 3| { \ | | 39| 3| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 3| (lp), (t), __FILE__, __LINE__)); \ | | 41| 3| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 3| { \ | | | | 283| 3| switch (type) { \ | | | | 284| 3| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 3, False: 0] | | | | ------------------ | | | | 285| 3| isc_rwlock_rdunlock(rwl); \ | | | | 286| 3| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 3] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 3] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 3| } \ | | | | 293| 3| } | | ------------------ | | 42| 3| } ------------------ 1478| 3| if (key->generated) { ------------------ | Branch (1478:6): [True: 0, False: 3] ------------------ 1479| | ISC_SIEVE_MARK(key, visited); ------------------ | | 116| 0| if (!ISC_SIEVE_MARKED(entry, visited)) { \ | | ------------------ | | | | 114| 0|#define ISC_SIEVE_MARKED(entry, visited) CMM_LOAD_SHARED((entry)->visited) | | ------------------ | | | Branch (116:6): [True: 0, False: 0] | | ------------------ | | 117| 0| CMM_STORE_SHARED((entry)->visited, true); \ | | 118| 0| } ------------------ 1480| 0| } 1481| 3| *tsigkey = key; 1482| 3| return ISC_R_SUCCESS; 1483| 3|} dns_tsigkey_algorithm: 1486| 34|dns_tsigkey_algorithm(dns_tsigkey_t *tkey) { 1487| 34| REQUIRE(VALID_TSIGKEY(tkey)); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 68| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 34, False: 0] | | | | | Branch (42:11): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1488| | 1489| 34| switch (tkey->alg) { 1490| 0| case DST_ALG_HMACMD5: ------------------ | Branch (1490:2): [True: 0, False: 34] ------------------ 1491| 0| return dns_tsig_hmacmd5_name; 1492| 0| case DST_ALG_HMACSHA1: ------------------ | Branch (1492:2): [True: 0, False: 34] ------------------ 1493| 0| return dns_tsig_hmacsha1_name; 1494| 0| case DST_ALG_HMACSHA224: ------------------ | Branch (1494:2): [True: 0, False: 34] ------------------ 1495| 0| return dns_tsig_hmacsha224_name; 1496| 34| case DST_ALG_HMACSHA256: ------------------ | Branch (1496:2): [True: 34, False: 0] ------------------ 1497| 34| return dns_tsig_hmacsha256_name; 1498| 0| case DST_ALG_HMACSHA384: ------------------ | Branch (1498:2): [True: 0, False: 34] ------------------ 1499| 0| return dns_tsig_hmacsha384_name; 1500| 0| case DST_ALG_HMACSHA512: ------------------ | Branch (1500:2): [True: 0, False: 34] ------------------ 1501| 0| return dns_tsig_hmacsha512_name; 1502| 0| case DST_ALG_GSSAPI: ------------------ | Branch (1502:2): [True: 0, False: 34] ------------------ 1503| 0| return dns_tsig_gssapi_name; 1504| | 1505| 0| case DST_ALG_UNKNOWN: ------------------ | Branch (1505:2): [True: 0, False: 34] ------------------ 1506| | /* 1507| | * If the tsigkey object was created with an 1508| | * unknown algorithm, then we cloned 1509| | * the algorithm name here. 1510| | */ 1511| 0| return &tkey->algname; 1512| | 1513| 0| default: ------------------ | Branch (1513:2): [True: 0, False: 34] ------------------ 1514| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 1515| 34| } 1516| 34|} dns_tsigkeyring_create: 1519| 6|dns_tsigkeyring_create(isc_mem_t *mctx, dns_tsigkeyring_t **ringp) { 1520| 6| dns_tsigkeyring_t *ring = NULL; 1521| | 1522| 6| REQUIRE(mctx != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1523| 6| REQUIRE(ringp != NULL && *ringp == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1524| | 1525| 6| ring = isc_mem_get(mctx, sizeof(dns_tsigkeyring_t)); ------------------ | | 144| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1526| 6| *ring = (dns_tsigkeyring_t){ 1527| 6| .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)) | | ------------------ ------------------ 1528| 6| .mctx = isc_mem_ref(mctx), 1529| 6| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 6|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 1530| 6| }; 1531| | 1532| 6| ISC_SIEVE_INIT(ring->lrulist); ------------------ | | 108| 6| { \ | | 109| 6| ISC_LIST_INIT((sieve).list); \ | | ------------------ | | | | 43| 6| do { \ | | | | 44| 6| (list).head = NULL; \ | | | | 45| 6| (list).tail = NULL; \ | | | | 46| 6| } while (0) | | | | ------------------ | | | | | Branch (46:11): [Folded, False: 6] | | | | ------------------ | | ------------------ | | 110| 6| (sieve).hand = NULL; \ | | 111| 6| } ------------------ 1533| | 1534| 6| isc_hashmap_create(mctx, 12, &ring->keys); 1535| 6| isc_rwlock_init(&ring->lock); 1536| | 1537| 6| *ringp = ring; 1538| 6|} dns_tsigkeyring_add: 1541| 2|dns_tsigkeyring_add(dns_tsigkeyring_t *ring, dns_tsigkey_t *tkey) { 1542| 2| isc_result_t result; 1543| | 1544| 2| REQUIRE(VALID_TSIGKEY(tkey)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1545| 2| REQUIRE(VALID_TSIGKEYRING(ring)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1546| | 1547| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1548| 2| result = isc_hashmap_add(ring->keys, dns_name_hash(tkey->name), 1549| 2| tkey_match, tkey->name, tkey, NULL); 1550| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1550:6): [True: 2, False: 0] ------------------ 1551| 2| dns_tsigkey_ref(tkey); 1552| | 1553| | /* 1554| | * If this is a TKEY-generated key, add it to the LRU list, 1555| | * and if we've exceeded the quota for generated keys, 1556| | * delete the least recently used one. 1557| | */ 1558| 2| if (tkey->generated) { ------------------ | Branch (1558:7): [True: 0, False: 2] ------------------ 1559| 0| if (++ring->generated > DNS_TSIG_MAXGENERATEDKEYS) { ------------------ | | 62| 0|#define DNS_TSIG_MAXGENERATEDKEYS 4096 ------------------ | Branch (1559:8): [True: 0, False: 0] ------------------ 1560| 0| dns_tsigkey_t *key = ISC_SIEVE_NEXT( ------------------ | | 127| 0| ({ \ | | 128| 0| __typeof__((sieve).hand) __hand = ((sieve).hand); \ | | 129| 0| if (__hand == NULL && !ISC_LIST_EMPTY((sieve).list)) { \ | | ------------------ | | | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (129:7): [True: 0, False: 0] | | | Branch (129:25): [True: 0, False: 0] | | ------------------ | | 130| 0| __hand = ISC_LIST_TAIL((sieve).list); \ | | ------------------ | | | | 63| 0|#define ISC_LIST_TAIL(list) ((list).tail) | | ------------------ | | 131| 0| } \ | | 132| 0| \ | | 133| 0| while (__hand != NULL && ISC_SIEVE_MARKED(__hand, visited)) { \ | | ------------------ | | | | 114| 0|#define ISC_SIEVE_MARKED(entry, visited) CMM_LOAD_SHARED((entry)->visited) | | ------------------ | | | Branch (133:10): [True: 0, False: 0] | | ------------------ | | 134| 0| ISC_SIEVE_UNMARK(__hand, visited); \ | | ------------------ | | | | 120| 0| CMM_STORE_SHARED((entry)->visited, false) | | ------------------ | | 135| 0| \ | | 136| 0| __hand = ISC_LIST_PREV(__hand, link); \ | | ------------------ | | | | 139| 0|#define ISC_LIST_PREV(elt, link) ((elt)->link.prev) | | ------------------ | | 137| 0| if (__hand == NULL) { \ | | ------------------ | | | Branch (137:8): [True: 0, False: 0] | | ------------------ | | 138| 0| /* We know the queue is not empty */ \ | | 139| 0| __hand = ISC_LIST_TAIL((sieve).list); \ | | ------------------ | | | | 63| 0|#define ISC_LIST_TAIL(list) ((list).tail) | | ------------------ | | 140| 0| } \ | | 141| 0| } \ | | 142| 0| (sieve).hand = __hand; \ | | 143| 0| __hand; \ | | 144| 0| }) ------------------ | Branch (1560:26): [True: 0, False: 0] ------------------ 1561| 0| ring->lrulist, visited, lrulink); 1562| 0| dns__tsigkey_delete(ring, key); 1563| 0| } 1564| | /* 1565| | * Insert the new key AFTER any possible eviction, so 1566| | * that the key is not evicted immediately after the 1567| | * insertion. 1568| | */ 1569| 0| ISC_SIEVE_INSERT(ring->lrulist, tkey, lrulink); ------------------ | | 168| 0| ISC_LIST_PREPEND((sieve).list, entry, link) | | ------------------ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 1570| 0| } 1571| 2| } 1572| 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(); \ | | | | ------------------ | | | | | | 206| 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| } ------------------ 1573| | 1574| 2| return result; 1575| 2|} tsig.c:tsig_log: 107| 932|tsig_log(dns_tsigkey_t *key, int level, const char *fmt, ...) { 108| 932| va_list ap; 109| 932| char message[4096]; 110| 932| char namestr[DNS_NAME_FORMATSIZE]; 111| 932| char creatorstr[DNS_NAME_FORMATSIZE]; 112| | 113| 932| if (!isc_log_wouldlog(level)) { ------------------ | Branch (113:6): [True: 932, False: 0] ------------------ 114| 932| return; 115| 932| } 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: 460| 365|destroy_tsigkey(dns_tsigkey_t *key) { 461| 365| REQUIRE(VALID_TSIGKEY(key)); ------------------ | | 198| 365|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 730| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 365, False: 0] | | | | | Branch (42:11): [True: 365, False: 0] | | | | ------------------ | | | | 43| 365| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 462| | 463| 365| key->magic = 0; 464| 365| if (key->key != NULL) { ------------------ | Branch (464:6): [True: 0, False: 365] ------------------ 465| 0| dst_key_free(&key->key); 466| 0| } 467| 365| if (key->creator != NULL) { ------------------ | Branch (467:6): [True: 0, False: 365] ------------------ 468| 0| dns_name_free(key->creator, key->mctx); 469| 0| isc_mem_put(key->mctx, key->creator, sizeof(dns_name_t)); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 470| 0| } 471| | isc_mem_putanddetach(&key->mctx, key, sizeof(dns_tsigkey_t)); ------------------ | | 187| 365| do { \ | | 188| 365| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 365| (p) = NULL; \ | | 190| 365| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 365] | | ------------------ ------------------ 472| 365|} tsig.c:tkey_match: 142| 256|tkey_match(void *node, const void *key) { 143| 256| dns_tsigkey_t *tkey = node; 144| | 145| 256| return dns_name_equal(tkey->name, key); 146| 256|} 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)); ------------------ | | 202| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 144| 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); ------------------ | | 202| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 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: 114| 2| dns_view_t **viewp) { 115| 2| dns_view_t *view = NULL; 116| 2| isc_result_t result; 117| 2| char buffer[1024]; 118| | 119| 2| REQUIRE(name != NULL); ------------------ | | 198| 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| 2| REQUIRE(viewp != NULL && *viewp == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 121| | 122| 2| switch (rdclass) { 123| 2| case dns_rdataclass_in: ------------------ | | 24| 2|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (123:2): [True: 2, False: 0] ------------------ 124| 2| break; 125| 0| case dns_rdataclass_chaos: ------------------ | | 26| 0|#define dns_rdataclass_chaos ((dns_rdataclass_t)dns_rdataclass_chaos) ------------------ | Branch (125:2): [True: 0, False: 2] ------------------ 126| 0| if (strcmp(name, "_bind") == 0) { ------------------ | Branch (126:7): [True: 0, False: 0] ------------------ 127| | /* allowed */ 128| 0| break; 129| 0| } 130| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 131| 0| default: ------------------ | Branch (131:2): [True: 0, False: 2] ------------------ 132| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 133| 2| } 134| | 135| 2| result = isc_file_sanitize(NULL, name, "nta", buffer, sizeof(buffer)); 136| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 137| | 138| 2| view = isc_mem_get(mctx, sizeof(*view)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 139| 2| *view = (dns_view_t){ 140| 2| .rdclass = rdclass, 141| 2| .name = isc_mem_strdup(mctx, name), ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 142| 2| .nta_file = isc_mem_strdup(mctx, buffer), ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 143| 2| .recursion = true, 144| 2| .enablevalidation = true, 145| 2| .minimalresponses = dns_minimal_no, 146| 2| .transfer_format = dns_one_answer, 147| 2| .msgcompression = true, 148| 2| .provideixfr = true, 149| 2| .maxcachettl = 7 * 24 * 3600, 150| 2| .maxncachettl = 3 * 3600, 151| 2| .dstport = 53, 152| 2| .staleanswerttl = 1, 153| 2| .staleanswersok = dns_stale_answer_conf, 154| 2| .sendcookie = true, 155| 2| .synthfromdnssec = true, 156| 2| .trust_anchor_telemetry = true, 157| 2| .root_key_sentinel = true, 158| 2| .udpsize = DEFAULT_EDNS_BUFSIZE, ------------------ | | 79| 2|#define DEFAULT_EDNS_BUFSIZE 1232 ------------------ 159| 2| .max_restarts = DEFAULT_MAX_RESTARTS, ------------------ | | 74| 2|#define DEFAULT_MAX_RESTARTS 11 ------------------ 160| 2| }; 161| | 162| 2| isc_refcount_init(&view->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 163| 2| isc_refcount_init(&view->weakrefs, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 164| | 165| 2| dns_fixedname_init(&view->redirectfixed); 166| | 167| 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] | | ------------------ ------------------ 168| 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] | | ------------------ ------------------ 169| 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] | | ------------------ ------------------ 170| | 171| 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] | | | | ------------------ | | ------------------ ------------------ 172| | 173| 2| isc_mem_attach(mctx, &view->mctx); 174| | 175| 2| if (dispatchmgr != NULL) { ------------------ | Branch (175:6): [True: 0, False: 2] ------------------ 176| 0| dns_dispatchmgr_attach(dispatchmgr, &view->dispatchmgr); 177| 0| } 178| | 179| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 180| | 181| 2| dns_zt_create(mctx, view, &view->zonetable); 182| | 183| 2| dns_fwdtable_create(mctx, view, &view->fwdtable); 184| | 185| 2| dns_tsigkeyring_create(view->mctx, &view->dynamickeys); 186| | 187| 2| view->failcache = dns_badcache_new(view->mctx); 188| | 189| 2| view->unreachcache = dns_unreachcache_new( 190| 2| view->mctx, UNREACH_HOLD_TIME_INITIAL_SEC, ------------------ | | 82| 2|#define UNREACH_HOLD_TIME_INITIAL_SEC ((uint16_t)10) ------------------ 191| 2| UNREACH_HOLD_TIME_MAX_SEC, UNREACH_BACKOFF_ELIGIBLE_SEC); ------------------ | | 83| 2|#define UNREACH_HOLD_TIME_MAX_SEC (UNREACH_HOLD_TIME_INITIAL_SEC << 6) | | ------------------ | | | | 82| 2|#define UNREACH_HOLD_TIME_INITIAL_SEC ((uint16_t)10) | | ------------------ ------------------ UNREACH_HOLD_TIME_MAX_SEC, UNREACH_BACKOFF_ELIGIBLE_SEC); ------------------ | | 84| 2|#define UNREACH_BACKOFF_ELIGIBLE_SEC ((uint16_t)120) ------------------ 192| | 193| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 194| | 195| 2| dns_order_create(view->mctx, &view->order); 196| | 197| 2| dns_peerlist_new(view->mctx, &view->peers); 198| | 199| 2| dns_aclenv_create(view->mctx, &view->aclenv); 200| | 201| 2| dns_nametree_create(view->mctx, DNS_NAMETREE_COUNT, "sfd", &view->sfd); 202| | 203| 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)) | | ------------------ ------------------ 204| 2| *viewp = view; 205| 2|} dns_view_weakattach: 541| 2|dns_view_weakattach(dns_view_t *source, dns_view_t **targetp) { 542| 2| REQUIRE(DNS_VIEW_VALID(source)); ------------------ | | 198| 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))) | | ------------------ ------------------ 543| 2| REQUIRE(targetp != NULL && *targetp == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 544| | 545| 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); \ | | ------------------ | | | | 202| 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| }) ------------------ 546| | 547| 2| *targetp = source; 548| 2|} dns_view_setkeyring: 651| 1.14k|dns_view_setkeyring(dns_view_t *view, dns_tsigkeyring_t *ring) { 652| 1.14k| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 1.14k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.29k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.14k, False: 0] | | | | | Branch (42:11): [True: 1.14k, False: 0] | | | | ------------------ | | | | 43| 1.14k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 653| 1.14k| REQUIRE(ring != NULL); ------------------ | | 198| 1.14k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.14k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.14k, False: 0] | | | | ------------------ | | | | 43| 1.14k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 1.14k| if (view->statickeys != NULL) { ------------------ | Branch (654:6): [True: 1.14k, False: 1] ------------------ 655| 1.14k| dns_tsigkeyring_detach(&view->statickeys); 656| 1.14k| } 657| 1.14k| dns_tsigkeyring_attach(ring, &view->statickeys); 658| 1.14k|} dns_view_freeze: 707| 2|dns_view_freeze(dns_view_t *view) { 708| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 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))) | | ------------------ ------------------ 709| 2| REQUIRE(!view->frozen); ------------------ | | 198| 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))) | | ------------------ ------------------ 710| | 711| 2| if (view->resolver != NULL) { ------------------ | Branch (711:6): [True: 0, False: 2] ------------------ 712| 0| INSIST(view->cachedb != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 713| 0| dns_resolver_freeze(view->resolver); 714| 0| } 715| | view->frozen = true; 716| 2|} dns_view_addzone: 727| 2|dns_view_addzone(dns_view_t *view, dns_zone_t *zone) { 728| 2| isc_result_t result; 729| 2| dns_zt_t *zonetable = NULL; 730| | 731| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 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(!view->frozen); ------------------ | | 198| 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| rcu_read_lock(); 735| 2| zonetable = rcu_dereference(view->zonetable); 736| 2| if (zonetable != NULL) { ------------------ | Branch (736:6): [True: 2, False: 0] ------------------ 737| 2| result = dns_zt_mount(zonetable, zone); 738| 2| } else { 739| 0| result = ISC_R_SHUTTINGDOWN; 740| 0| } 741| 2| rcu_read_unlock(); 742| | 743| 2| return result; 744| 2|} dns_view_find: 791| 424| dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { 792| 424| isc_result_t result; 793| 424| dns_db_t *db = NULL, *zdb = NULL; 794| 424| bool is_cache, is_staticstub_zone; 795| 424| dns_rdataset_t zrdataset, zsigrdataset; 796| 424| dns_zone_t *zone = NULL; 797| 424| dns_zt_t *zonetable = NULL; 798| | 799| | /* 800| | * Find an rdataset whose owner name is 'name', and whose type is 801| | * 'type'. 802| | */ 803| | 804| 424| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 424|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 848| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 424, False: 0] | | | | | Branch (42:11): [True: 424, False: 0] | | | | ------------------ | | | | 43| 424| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 805| 424| REQUIRE(view->frozen); ------------------ | | 198| 424|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 424| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 424, False: 0] | | | | ------------------ | | | | 43| 424| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 806| 424| REQUIRE(type != dns_rdatatype_rrsig); ------------------ | | 198| 424|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 424| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 424, False: 0] | | | | ------------------ | | | | 43| 424| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 807| 424| REQUIRE(rdataset != NULL); /* XXXBEW - remove this */ ------------------ | | 198| 424|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 424| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 424, False: 0] | | | | ------------------ | | | | 43| 424| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| | 809| | /* 810| | * Initialize. 811| | */ 812| 424| dns_rdataset_init(&zrdataset); 813| 424| dns_rdataset_init(&zsigrdataset); 814| | 815| | /* 816| | * Find a database to answer the query. 817| | */ 818| 424| is_staticstub_zone = false; 819| 424| rcu_read_lock(); 820| 424| zonetable = rcu_dereference(view->zonetable); 821| 424| if (zonetable != NULL) { ------------------ | Branch (821:6): [True: 424, False: 0] ------------------ 822| 424| result = dns_zt_find(zonetable, name, DNS_ZTFIND_MIRROR, &zone); 823| 424| } else { 824| 0| result = ISC_R_SHUTTINGDOWN; 825| 0| } 826| 424| rcu_read_unlock(); 827| 424| if (zone != NULL && dns_zone_gettype(zone) == dns_zone_staticstub && ------------------ | Branch (827:6): [True: 200, False: 224] | Branch (827:22): [True: 0, False: 200] ------------------ 828| 0| !use_static_stub) ------------------ | Branch (828:6): [True: 0, False: 0] ------------------ 829| 0| { 830| 0| result = ISC_R_NOTFOUND; 831| 0| } 832| 424| if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) { ------------------ | Branch (832:6): [True: 123, False: 301] | Branch (832:33): [True: 77, False: 224] ------------------ 833| 200| result = dns_zone_getdb(zone, &db); 834| 200| if (result != ISC_R_SUCCESS && view->cachedb != NULL) { ------------------ | Branch (834:7): [True: 0, False: 200] | Branch (834:34): [True: 0, False: 0] ------------------ 835| 0| dns_db_attach(view->cachedb, &db); 836| 200| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (836:14): [True: 0, False: 200] ------------------ 837| 0| goto cleanup; 838| 0| } 839| 200| if (dns_zone_gettype(zone) == dns_zone_staticstub && ------------------ | Branch (839:7): [True: 0, False: 200] ------------------ 840| 0| dns_name_equal(name, dns_zone_getorigin(zone))) ------------------ | Branch (840:7): [True: 0, False: 0] ------------------ 841| 0| { 842| 0| is_staticstub_zone = true; 843| 0| } 844| 224| } else if (result == ISC_R_NOTFOUND && view->cachedb != NULL) { ------------------ | Branch (844:13): [True: 224, False: 0] | Branch (844:41): [True: 0, False: 224] ------------------ 845| 0| dns_db_attach(view->cachedb, &db); 846| 224| } else { 847| 224| goto cleanup; 848| 224| } 849| | 850| 200| is_cache = dns_db_iscache(db); 851| | 852| 200|db_find: 853| | /* 854| | * Now look for an answer in the database. 855| | */ 856| 200| result = dns_db_find(db, name, NULL, type, options, now, foundname, ------------------ | | 815| 200| dns__db_find(db, name, version, type, options, now, foundname, NULL, \ | | 816| 200| NULL, rdataset, sigrdataset DNS__DB_FILELINE) ------------------ 857| 200| rdataset, sigrdataset); 858| | 859| 200| if (result == DNS_R_DELEGATION || result == ISC_R_NOTFOUND) { ------------------ | Branch (859:6): [True: 0, False: 200] | Branch (859:36): [True: 0, False: 200] ------------------ 860| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 297| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 0] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 861| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 297| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 0] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 862| 0| if (!is_cache) { ------------------ | Branch (862:7): [True: 0, False: 0] ------------------ 863| 0| dns_db_detach(&db); 864| 0| if (view->cachedb != NULL && !is_staticstub_zone) { ------------------ | Branch (864:8): [True: 0, False: 0] | Branch (864:33): [True: 0, False: 0] ------------------ 865| | /* 866| | * Either the answer is in the cache, or we 867| | * don't know it. 868| | * Note that if the result comes from a 869| | * static-stub zone we stop the search here 870| | * (see the function description in view.h). 871| | */ 872| 0| is_cache = true; 873| 0| dns_db_attach(view->cachedb, &db); 874| 0| goto db_find; 875| 0| } 876| 0| } else { 877| | /* 878| | * We don't have the data in the cache. If we've got 879| | * glue from the zone, use it. 880| | */ 881| 0| if (dns_rdataset_isassociated(&zrdataset)) { ------------------ | Branch (881:8): [True: 0, False: 0] ------------------ 882| 0| dns_rdataset_clone(&zrdataset, rdataset); ------------------ | | 349| 0| dns__rdataset_clone(source, target DNS__DB_FILELINE) ------------------ 883| 0| if (sigrdataset != NULL && ------------------ | Branch (883:9): [True: 0, False: 0] ------------------ 884| 0| dns_rdataset_isassociated(&zsigrdataset)) ------------------ | Branch (884:9): [True: 0, False: 0] ------------------ 885| 0| { 886| 0| dns_rdataset_clone(&zsigrdataset, ------------------ | | 349| 0| dns__rdataset_clone(source, target DNS__DB_FILELINE) ------------------ 887| 0| sigrdataset); 888| 0| } 889| 0| result = DNS_R_GLUE; 890| 0| if (db != NULL) { ------------------ | Branch (890:9): [True: 0, False: 0] ------------------ 891| 0| dns_db_detach(&db); 892| 0| } 893| 0| dns_db_attach(zdb, &db); 894| 0| goto cleanup; 895| 0| } 896| 0| } 897| | /* 898| | * We don't know the answer. 899| | */ 900| 0| result = ISC_R_NOTFOUND; 901| 200| } else if (result == DNS_R_GLUE) { ------------------ | Branch (901:13): [True: 0, False: 200] ------------------ 902| | /* 903| | * Glue is the answer wanted. 904| | */ 905| 0| result = ISC_R_SUCCESS; 906| 0| } 907| | 908| 200| if (result == ISC_R_NOTFOUND && !is_staticstub_zone && use_hints && ------------------ | Branch (908:6): [True: 0, False: 200] | Branch (908:34): [True: 0, False: 0] | Branch (908:57): [True: 0, False: 0] ------------------ 909| 0| view->rootdb != NULL) ------------------ | Branch (909:6): [True: 0, False: 0] ------------------ 910| 0| { 911| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 297| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 0] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 912| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 297| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 0] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 913| 0| if (db != NULL) { ------------------ | Branch (913:7): [True: 0, False: 0] ------------------ 914| 0| dns_db_detach(&db); 915| 0| } 916| 0| result = dns_db_find(view->rootdb, name, NULL, type, options, ------------------ | | 815| 0| dns__db_find(db, name, version, type, options, now, foundname, NULL, \ | | 816| 0| NULL, rdataset, sigrdataset DNS__DB_FILELINE) ------------------ 917| 0| now, foundname, rdataset, sigrdataset); 918| 0| if (result == ISC_R_SUCCESS || result == DNS_R_GLUE) { ------------------ | Branch (918:7): [True: 0, False: 0] | Branch (918:34): [True: 0, False: 0] ------------------ 919| | /* 920| | * Lazily rearm priming if the rootdb's 921| | * stored TTL has elapsed. The stale 922| | * record is still returned; it is better 923| | * than nothing until the fresh priming 924| | * fetch completes. 925| | */ 926| 0| maybe_prime(view); 927| 0| dns_db_attach(view->rootdb, &db); 928| 0| result = DNS_R_HINT; 929| 0| } else if (result == DNS_R_NXRRSET) { ------------------ | Branch (929:14): [True: 0, False: 0] ------------------ 930| 0| dns_db_attach(view->rootdb, &db); 931| 0| result = DNS_R_HINTNXRRSET; 932| 0| } else if (result == DNS_R_NXDOMAIN) { ------------------ | Branch (932:14): [True: 0, False: 0] ------------------ 933| 0| result = ISC_R_NOTFOUND; 934| 0| } 935| 0| } 936| | 937| 424|cleanup: 938| 424| dns_rdataset_cleanup(&zrdataset); ------------------ | | 297| 424| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 424, Folded] | | | Branch (297:26): [True: 0, False: 424] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 939| 424| dns_rdataset_cleanup(&zsigrdataset); ------------------ | | 297| 424| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 424, Folded] | | | Branch (297:26): [True: 0, False: 424] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 940| | 941| 424| if (zdb != NULL) { ------------------ | Branch (941:6): [True: 0, False: 424] ------------------ 942| 0| dns_db_detach(&zdb); 943| 0| } 944| | 945| 424| if (db != NULL) { ------------------ | Branch (945:6): [True: 200, False: 224] ------------------ 946| 200| if (dbp != NULL) { ------------------ | Branch (946:7): [True: 0, False: 200] ------------------ 947| 0| *dbp = db; 948| 200| } else { 949| 200| dns_db_detach(&db); 950| 200| } 951| 200| } 952| | 953| 424| if (zone != NULL) { ------------------ | Branch (953:6): [True: 200, False: 224] ------------------ 954| 200| dns_zone_detach(&zone); 955| 200| } 956| | 957| 424| return result; 958| 200|} dns_view_simplefind: 964| 424| dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { 965| 424| isc_result_t result; 966| 424| dns_fixedname_t foundname; 967| | 968| 424| dns_fixedname_init(&foundname); 969| 424| result = dns_view_find(view, name, type, now, options, use_hints, false, 970| 424| NULL, dns_fixedname_name(&foundname), rdataset, 971| 424| sigrdataset); 972| 424| if (result == DNS_R_NXDOMAIN) { ------------------ | Branch (972:6): [True: 77, False: 347] ------------------ 973| | /* 974| | * The rdataset and sigrdataset of the relevant NSEC record 975| | * may be returned, but the caller cannot use them because 976| | * foundname is not returned by this simplified API. We 977| | * disassociate them here to prevent any misuse by the caller. 978| | */ 979| 77| dns_rdataset_cleanup(rdataset); ------------------ | | 297| 77| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 77, False: 0] | | | Branch (297:26): [True: 0, False: 77] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 980| 77| dns_rdataset_cleanup(sigrdataset); ------------------ | | 297| 77| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 77] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 981| 347| } else if (result != ISC_R_SUCCESS && result != DNS_R_GLUE && ------------------ | Branch (981:13): [True: 224, False: 123] | Branch (981:40): [True: 224, False: 0] ------------------ 982| 224| result != DNS_R_HINT && result != DNS_R_NCACHENXDOMAIN && ------------------ | Branch (982:6): [True: 224, False: 0] | Branch (982:30): [True: 224, False: 0] ------------------ 983| 224| result != DNS_R_NCACHENXRRSET && result != DNS_R_NXRRSET && ------------------ | Branch (983:6): [True: 224, False: 0] | Branch (983:39): [True: 224, False: 0] ------------------ 984| 224| result != DNS_R_HINTNXRRSET && result != ISC_R_NOTFOUND) ------------------ | Branch (984:6): [True: 224, False: 0] | Branch (984:37): [True: 0, False: 224] ------------------ 985| 0| { 986| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 297| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 0] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 987| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 297| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 0, False: 0] | | | Branch (297:26): [True: 0, False: 0] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 988| 0| result = ISC_R_NOTFOUND; 989| 0| } 990| | 991| 424| return result; 992| 424|} dns_view_checksig: 1329| 447|dns_view_checksig(dns_view_t *view, isc_buffer_t *source, dns_message_t *msg) { 1330| 447| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 447|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 894| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 447, False: 0] | | | | | Branch (42:11): [True: 447, False: 0] | | | | ------------------ | | | | 43| 447| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1331| 447| REQUIRE(source != NULL); ------------------ | | 198| 447|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 447| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 447, False: 0] | | | | ------------------ | | | | 43| 447| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1332| | 1333| 447| return dns_tsig_verify(source, msg, view->statickeys, 1334| 447| view->dynamickeys); 1335| 447|} dns_view_sfd_add: 1979| 2|dns_view_sfd_add(dns_view_t *view, const dns_name_t *name) { 1980| 2| isc_result_t result; 1981| | 1982| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1983| | 1984| 2| result = dns_nametree_add(view->sfd, name, 0); 1985| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 1986| 2|} dns_zone_create: 470| 2|dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx, isc_tid_t tid) { 471| 2| isc_time_t now; 472| 2| dns_zone_t *zone = NULL; 473| | 474| 2| REQUIRE(zonep != NULL && *zonep == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 475| 2| REQUIRE(mctx != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 476| | 477| 2| now = isc_time_now(); 478| 2| zone = isc_mem_get(mctx, sizeof(*zone)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 479| 2| *zone = (dns_zone_t){ 480| 2| .masterformat = dns_masterformat_none, 481| 2| .journalsize = -1, 482| 2| .rdclass = dns_rdataclass_none, ------------------ | | 32| 2|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ 483| 2| .type = dns_zone_none, 484| 2| .refresh = DNS_ZONE_DEFAULTREFRESH, ------------------ | | 130| 2|#define DNS_ZONE_DEFAULTREFRESH 3600 /*%< 1 hour */ ------------------ 485| 2| .retry = DNS_ZONE_DEFAULTRETRY, ------------------ | | 140| 2| 60 /*%< 1 minute, subject to \ ------------------ 486| 2| .maxrefresh = DNS_ZONE_MAXREFRESH, ------------------ | | 127| 2|#define DNS_ZONE_MAXREFRESH 2419200 /*%< 4 weeks */ ------------------ 487| 2| .minrefresh = DNS_ZONE_MINREFRESH, ------------------ | | 124| 2|#define DNS_ZONE_MINREFRESH 300 /*%< 5 minutes */ ------------------ 488| 2| .maxretry = DNS_ZONE_MAXRETRY, ------------------ | | 136| 2|#define DNS_ZONE_MAXRETRY 1209600 /*%< 2 weeks */ ------------------ 489| 2| .minretry = DNS_ZONE_MINRETRY, ------------------ | | 133| 2|#define DNS_ZONE_MINRETRY 300 /*%< 5 minutes */ ------------------ 490| 2| .checkdstype = dns_checkdstype_yes, 491| 2| .zero_no_soa_ttl = true, 492| 2| .check_names = dns_severity_ignore, 493| 2| .idlein = DNS_DEFAULT_IDLEIN, ------------------ | | 53| 2|#define DNS_DEFAULT_IDLEIN 3600 /*%< 1 hour */ ------------------ 494| 2| .idleout = DNS_DEFAULT_IDLEOUT, ------------------ | | 54| 2|#define DNS_DEFAULT_IDLEOUT 3600 /*%< 1 hour */ ------------------ 495| 2| .maxxfrin = MAX_XFER_TIME, ------------------ | | 55| 2|#define MAX_XFER_TIME (2 * 3600) /*%< Documented default is 2 hours */ ------------------ 496| 2| .maxxfrout = MAX_XFER_TIME, ------------------ | | 55| 2|#define MAX_XFER_TIME (2 * 3600) /*%< Documented default is 2 hours */ ------------------ 497| 2| .sigvalidityinterval = 30 * 24 * 3600, 498| 2| .sigresigninginterval = 7 * 24 * 3600, 499| 2| .statlevel = dns_zonestat_none, 500| 2| .signatures = 10, 501| 2| .nodes = 100, 502| 2| .privatetype = (dns_rdatatype_t)0xffffU, 503| 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 | | ------------------ ------------------ 504| 2| .requestixfr = true, 505| 2| .ixfr_ratio = 100, 506| 2| .requestexpire = true, 507| 2| .updatemethod = dns_updatemethod_increment, 508| 2| .tid = tid, 509| 2| .notifytime = now, 510| 2| .newincludes = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 511| 2| .checkds_requests = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 512| 2| .signing = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 513| 2| .nsec3chain = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 514| 2| .maintenance_queue = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 515| 2| .forwards = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 516| 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| } | | ------------------ ------------------ 517| 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| } | | ------------------ ------------------ 518| 2| }; 519| 2| dns_remote_t r = { 520| 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)) | | ------------------ ------------------ 521| 2| }; 522| | 523| 2| isc_mem_attach(mctx, &zone->mctx); 524| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 525| 2| ZONEDB_INITLOCK(&zone->dblock); ------------------ | | 110| 2|#define ZONEDB_INITLOCK(l) isc_rwlock_init(l) ------------------ 526| | 527| 2| isc_refcount_init(&zone->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 528| 2| isc_refcount_init(&zone->irefs, 0); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 529| 2| dns_name_init(&zone->origin); 530| 2| isc_sockaddr_any(&zone->parentalsrc4); 531| 2| isc_sockaddr_any6(&zone->parentalsrc6); 532| 2| isc_sockaddr_any(&zone->xfrsource4); 533| 2| isc_sockaddr_any6(&zone->xfrsource6); 534| | 535| 2| zone->primaries = r; 536| 2| zone->parentals = r; 537| 2| zone->alsonotify = r; 538| 2| zone->cds_endpoints = r; 539| 2| zone->defaultkasp = NULL; 540| 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] | | ------------------ ------------------ 541| | 542| 2| dns_notifyctx_init(&zone->notifysoa, dns_rdatatype_soa); ------------------ | | 120| 2|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ 543| 2| dns_notifyctx_init(&zone->notifycds, dns_rdatatype_cds); ------------------ | | 172| 2|#define dns_rdatatype_cds ((dns_rdatatype_t)dns_rdatatype_cds) ------------------ 544| | 545| 2| isc_stats_create(mctx, &zone->gluecachestats, 546| 2| dns_gluecachestatscounter_max); 547| | 548| 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)) | | ------------------ ------------------ 549| | 550| | /* Must be after magic is set. */ 551| 2| dns_zone_setdbtype(zone, dbargc_default, dbargv_default); 552| | 553| 2| *zonep = zone; 554| 2|} dns__zone_inline_secure: 741| 18|dns__zone_inline_secure(dns_zone_t *zone) { 742| 18| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 18|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 36| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 18, False: 0] | | | | | Branch (42:11): [True: 18, False: 0] | | | | ------------------ | | | | 43| 18| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 743| 18| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 198| 18|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 18| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 18, False: 0] | | | | ------------------ | | | | 43| 18| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 744| 18| if (zone->raw != NULL) { ------------------ | Branch (744:6): [True: 0, False: 18] ------------------ 745| 0| return true; 746| 0| } 747| 18| return false; 748| 18|} dns__zone_inline_raw: 755| 14|dns__zone_inline_raw(dns_zone_t *zone) { 756| 14| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 757| 14| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 758| 14| if (zone->secure != NULL) { ------------------ | Branch (758:6): [True: 0, False: 14] ------------------ 759| 0| return true; 760| 0| } 761| 14| return false; 762| 14|} dns__zone_freedbargs: 841| 2|dns__zone_freedbargs(dns_zone_t *zone) { 842| 2| unsigned int i; 843| | 844| | /* Free the old database argument list. */ 845| 2| if (zone->db_argv != NULL) { ------------------ | Branch (845:6): [True: 0, False: 2] ------------------ 846| 0| for (i = 0; i < zone->db_argc; i++) { ------------------ | Branch (846:15): [True: 0, False: 0] ------------------ 847| 0| isc_mem_free(zone->mctx, zone->db_argv[i]); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 848| 0| } 849| 0| isc_mem_cput(zone->mctx, zone->db_argv, zone->db_argc, ------------------ | | 176| 0| do { \ | | 177| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 178| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE); \ | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ | | 179| 0| (p) = NULL; \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:11): [Folded, False: 0] | | ------------------ ------------------ 850| 0| sizeof(*zone->db_argv)); 851| 0| } 852| 2| zone->db_argc = 0; 853| | zone->db_argv = NULL; 854| 2|} dns__zone_setview_helper: 857| 2|dns__zone_setview_helper(dns_zone_t *zone, dns_view_t *view) { 858| 2| char namebuf[1024]; 859| | 860| 2| if (zone->prev_view == NULL && zone->view != NULL) { ------------------ | Branch (860:6): [True: 2, False: 0] | Branch (860:33): [True: 0, False: 2] ------------------ 861| 0| dns_view_weakattach(zone->view, &zone->prev_view); 862| 0| } 863| | 864| 2| INSIST(zone != zone->raw); ------------------ | | 202| 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))) | | ------------------ ------------------ 865| 2| if (zone->view != NULL) { ------------------ | Branch (865:6): [True: 0, False: 2] ------------------ 866| 0| dns_view_sfd_del(zone->view, &zone->origin); 867| 0| dns_view_weakdetach(&zone->view); 868| 0| } 869| 2| dns_view_weakattach(view, &zone->view); 870| 2| dns_view_sfd_add(view, &zone->origin); 871| | 872| 2| if (zone->strviewname != NULL) { ------------------ | Branch (872:6): [True: 0, False: 2] ------------------ 873| 0| isc_mem_free(zone->mctx, zone->strviewname); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 874| 0| } 875| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (875:6): [True: 2, False: 0] ------------------ 876| 2| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 197| 2| do { \ | | 198| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 2| (p) = NULL; \ | | 200| 2| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 2] | | ------------------ ------------------ 877| 2| } 878| | 879| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 880| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 881| 2| zone_viewname_tostr(zone, namebuf, sizeof namebuf); 882| 2| zone->strviewname = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 883| | 884| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (884:6): [True: 0, False: 2] ------------------ 885| 0| dns_zone_setview(zone->raw, view); 886| 0| } 887| 2|} dns_zone_isdynamic: 932| 6|dns_zone_isdynamic(dns_zone_t *zone, bool ignore_freeze) { 933| 6| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 934| | 935| 6| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (935:6): [True: 0, False: 6] | Branch (935:42): [True: 0, False: 6] ------------------ 936| 6| zone->type == dns_zone_stub || zone->type == dns_zone_key || ------------------ | Branch (936:6): [True: 0, False: 6] | Branch (936:37): [True: 0, False: 6] ------------------ 937| 6| (zone->type == dns_zone_redirect && ------------------ | Branch (937:7): [True: 0, False: 6] ------------------ 938| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (938:7): [True: 0, False: 0] ------------------ 939| 0| { 940| 0| return true; 941| 0| } 942| | 943| | /* Inline zones are always dynamic. */ 944| 6| if (zone->type == dns_zone_primary && zone->raw != NULL) { ------------------ | Branch (944:6): [True: 6, False: 0] | Branch (944:40): [True: 0, False: 6] ------------------ 945| 0| return true; 946| 0| } 947| | 948| | /* If !ignore_freeze, we need check whether updates are disabled. */ 949| 6| if (zone->type == dns_zone_primary && ------------------ | Branch (949:6): [True: 6, False: 0] ------------------ 950| 6| (!zone->update_disabled || ignore_freeze) && ------------------ | Branch (950:7): [True: 6, False: 0] | Branch (950:33): [True: 0, False: 0] ------------------ 951| 6| ((zone->ssutable != NULL) || ------------------ | Branch (951:7): [True: 0, False: 6] ------------------ 952| 6| (zone->update_acl != NULL && !dns_acl_isnone(zone->update_acl)))) ------------------ | Branch (952:8): [True: 0, False: 6] | Branch (952:36): [True: 0, False: 0] ------------------ 953| 0| { 954| 0| return true; 955| 0| } 956| | 957| 6| return false; 958| 6|} dns_zone_rpz_enable_db: 992| 2|dns_zone_rpz_enable_db(dns_zone_t *zone, dns_db_t *db) { 993| 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 (993:6): [True: 2, False: 0] ------------------ 994| 2| return; 995| 2| } 996| 0| REQUIRE(zone->rpzs != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 997| 0| dns_rpz_dbupdate_register(db, zone->rpzs->zones[zone->rpz_num]); 998| 0|} dns_zone_catz_enable_db: 1013| 2|dns_zone_catz_enable_db(dns_zone_t *zone, dns_db_t *db) { 1014| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1015| 2| REQUIRE(db != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1016| | 1017| 2| if (zone->catzs != NULL) { ------------------ | Branch (1017:6): [True: 0, False: 2] ------------------ 1018| 0| dns_catz_dbupdate_register(db, zone->catzs); 1019| 0| } 1020| 2|} dns_zone_load: 1481| 2|dns_zone_load(dns_zone_t *zone, bool newonly) { 1482| 2| return zone_load(zone, newonly ? DNS_ZONELOADFLAG_NOSTAT : 0, false); ------------------ | Branch (1482:25): [True: 0, False: 2] ------------------ 1483| 2|} dns_zone_logv: 13615| 16| const char *prefix, const char *fmt, va_list ap) { 13616| 16| char message[4096]; 13617| 16| const char *zstr; 13618| | 13619| 16| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 13620| | 13621| 16| if (!isc_log_wouldlog(level)) { ------------------ | Branch (13621:6): [True: 14, False: 2] ------------------ 13622| 14| return; 13623| 14| } 13624| | 13625| 2| vsnprintf(message, sizeof(message), fmt, ap); 13626| | 13627| 2| switch (zone->type) { 13628| 0| case dns_zone_key: ------------------ | Branch (13628:2): [True: 0, False: 2] ------------------ 13629| 0| zstr = "managed-keys-zone"; 13630| 0| break; 13631| 0| case dns_zone_redirect: ------------------ | Branch (13631:2): [True: 0, False: 2] ------------------ 13632| 0| zstr = "redirect-zone"; 13633| 0| break; 13634| 2| default: ------------------ | Branch (13634:2): [True: 2, False: 0] ------------------ 13635| 2| zstr = "zone "; 13636| 2| } 13637| | 13638| 2| isc_log_write(category, DNS_LOGMODULE_ZONE, level, "%s%s%s%s: %s", 13639| 2| prefix != NULL ? prefix : "", prefix != NULL ? ": " : "", ------------------ | Branch (13639:9): [True: 0, False: 2] | Branch (13639:39): [True: 0, False: 2] ------------------ 13640| 2| zstr, zone->strnamerd, message); 13641| 2|} dns_zone_logc: 13645| 10| const char *fmt, ...) { 13646| 10| va_list ap; 13647| | 13648| 10| va_start(ap, fmt); 13649| 10| dns_zone_logv(zone, category, level, NULL, fmt, ap); 13650| | va_end(ap); 13651| 10|} dns_zonetype_name: 13709| 2|dns_zonetype_name(dns_zonetype_t type) { 13710| 2| switch (type) { 13711| 0| case dns_zone_none: ------------------ | Branch (13711:2): [True: 0, False: 2] ------------------ 13712| 0| return "none"; 13713| 2| case dns_zone_primary: ------------------ | Branch (13713:2): [True: 2, False: 0] ------------------ 13714| 2| return "primary"; 13715| 0| case dns_zone_secondary: ------------------ | Branch (13715:2): [True: 0, False: 2] ------------------ 13716| 0| return "secondary"; 13717| 0| case dns_zone_mirror: ------------------ | Branch (13717:2): [True: 0, False: 2] ------------------ 13718| 0| return "mirror"; 13719| 0| case dns_zone_stub: ------------------ | Branch (13719:2): [True: 0, False: 2] ------------------ 13720| 0| return "stub"; 13721| 0| case dns_zone_staticstub: ------------------ | Branch (13721:2): [True: 0, False: 2] ------------------ 13722| 0| return "static-stub"; 13723| 0| case dns_zone_key: ------------------ | Branch (13723:2): [True: 0, False: 2] ------------------ 13724| 0| return "key"; 13725| 0| case dns_zone_dlz: ------------------ | Branch (13725:2): [True: 0, False: 2] ------------------ 13726| 0| return "dlz"; 13727| 0| case dns_zone_redirect: ------------------ | Branch (13727:2): [True: 0, False: 2] ------------------ 13728| 0| return "redirect"; 13729| 0| default: ------------------ | Branch (13729:2): [True: 0, False: 2] ------------------ 13730| 0| return "unknown"; 13731| 2| } 13732| 2|} dns__zone_keymgmt_initialize: 16142| 2|dns__zone_keymgmt_initialize(void) { 16143| 2.05k| for (size_t idx = 0; idx < ARRAY_SIZE(keymgmt_buckets_g); ++idx) { ------------------ | | 98| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (16143:23): [True: 2.04k, False: 2] ------------------ 16144| 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); \ | | | | ------------------ | | | | | | 288| 2.04k| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2.04k] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2.04k| } | | ------------------ ------------------ 16145| 2.04k| } 16146| 2|} dns_zone_cdscheck: 19451| 2|dns_zone_cdscheck(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *version) { 19452| 2| isc_result_t result; 19453| 2| dns_dbnode_t *node = NULL; 19454| 2| dns_rdataset_t dnskey, cds, cdnskey; 19455| 2| unsigned char algorithms[DST_MAX_ALGS]; 19456| 2| unsigned int i; 19457| 2| bool empty = false; 19458| | 19459| 2| enum { notexpected = 0, expected = 1, found = 2 }; 19460| | 19461| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 19462| | 19463| 2| RETERR(dns_db_getoriginnode(db, &node)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 19464| | 19465| 2| dns_rdataset_init(&cds); 19466| 2| dns_rdataset_init(&dnskey); 19467| 2| dns_rdataset_init(&cdnskey); 19468| | 19469| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_cds, ------------------ | | 1119| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 2| sigrdataset DNS__DB_FILELINE) ------------------ 19470| 2| dns_rdatatype_none, 0, &cds, NULL); 19471| 2| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (19471:6): [True: 0, False: 2] ------------------ 19472| 0| CHECK(result); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 19473| 0| } 19474| | 19475| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_cdnskey, ------------------ | | 1119| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 2| sigrdataset DNS__DB_FILELINE) ------------------ 19476| 2| dns_rdatatype_none, 0, &cdnskey, NULL); 19477| 2| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (19477:6): [True: 0, False: 2] ------------------ 19478| 0| CHECK(result); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 19479| 0| } 19480| | 19481| 2| if (!dns_rdataset_isassociated(&cds) && ------------------ | Branch (19481:6): [True: 2, False: 0] ------------------ 19482| 2| !dns_rdataset_isassociated(&cdnskey)) ------------------ | Branch (19482:6): [True: 2, False: 0] ------------------ 19483| 2| { 19484| 2| result = ISC_R_SUCCESS; 19485| 2| goto cleanup; 19486| 2| } 19487| | 19488| 0| result = dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, ------------------ | | 1119| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 0| sigrdataset DNS__DB_FILELINE) ------------------ 19489| 0| dns_rdatatype_none, 0, &dnskey, NULL); 19490| 0| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (19490:6): [True: 0, False: 0] ------------------ 19491| 0| empty = true; 19492| 0| } else { 19493| 0| CHECK(result); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 19494| 0| } 19495| | 19496| | /* 19497| | * For each DNSSEC algorithm in the CDS RRset there must be 19498| | * a matching DNSKEY record with the exception of a CDS deletion 19499| | * record which must be by itself. 19500| | */ 19501| 0| if (dns_rdataset_isassociated(&cds)) { ------------------ | Branch (19501:6): [True: 0, False: 0] ------------------ 19502| 0| bool logged_digest_type[DNS_DSDIGEST_MAX + 1] = { 0 }; 19503| 0| bool delete = false; 19504| 0| memset(algorithms, notexpected, sizeof(algorithms)); 19505| 0| DNS_RDATASET_FOREACH(&cds) { ------------------ | | 262| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19506| 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| } ------------------ 19507| 0| dns_rdata_cds_t structcds; 19508| | 19509| 0| dns_rdataset_current(&cds, &crdata); 19510| | /* 19511| | * CDS deletion record has this form "0 0 0 00" which 19512| | * is 5 zero octets. 19513| | */ 19514| 0| if (crdata.length == 5U && ------------------ | Branch (19514:8): [True: 0, False: 0] ------------------ 19515| 0| memcmp(crdata.data, ------------------ | Branch (19515:8): [True: 0, False: 0] ------------------ 19516| 0| (unsigned char[5]){ 0, 0, 0, 0, 0 }, 5) == 0) 19517| 0| { 19518| 0| delete = true; 19519| 0| continue; 19520| 0| } 19521| | 19522| 0| if (empty) { ------------------ | Branch (19522:8): [True: 0, False: 0] ------------------ 19523| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19524| 0| } 19525| | 19526| 0| CHECK(dns_rdata_tostruct(&crdata, &structcds, NULL)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 19527| | 19528| | /* 19529| | * Log deprecated CDS digest types. 19530| | */ 19531| 0| switch (structcds.digest_type) { ------------------ | Branch (19531:12): [True: 0, False: 0] ------------------ 19532| 0| case DNS_DSDIGEST_SHA1: ------------------ | | 19| 0|#define DNS_DSDIGEST_SHA1 (1) ------------------ | Branch (19532:4): [True: 0, False: 0] ------------------ 19533| 0| case DNS_DSDIGEST_GOST: ------------------ | | 21| 0|#define DNS_DSDIGEST_GOST (3) ------------------ | Branch (19533:4): [True: 0, False: 0] ------------------ 19534| 0| if (!logged_digest_type[structcds.digest_type]) ------------------ | Branch (19534:9): [True: 0, False: 0] ------------------ 19535| 0| { 19536| 0| char algbuf[DNS_DSDIGEST_FORMATSIZE]; 19537| 0| dns_dsdigest_format( 19538| 0| structcds.digest_type, algbuf, 19539| 0| sizeof(algbuf)); 19540| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 19541| 0| "deprecated CDS digest type " 19542| 0| "%u (%s)", 19543| 0| structcds.digest_type, 19544| 0| algbuf); 19545| 0| logged_digest_type[structcds.digest_type] = 19546| 0| true; 19547| 0| } 19548| 0| break; 19549| 0| } 19550| | 19551| 0| if (structcds.algorithm != DNS_KEYALG_PRIVATEDNS && ------------------ | Branch (19551:8): [True: 0, False: 0] ------------------ 19552| 0| structcds.algorithm != DNS_KEYALG_PRIVATEOID) ------------------ | Branch (19552:8): [True: 0, False: 0] ------------------ 19553| 0| { 19554| 0| if (algorithms[structcds.algorithm] == 0) { ------------------ | Branch (19554:9): [True: 0, False: 0] ------------------ 19555| 0| algorithms[structcds.algorithm] = 19556| 0| expected; 19557| 0| } 19558| 0| DNS_RDATASET_FOREACH(&dnskey) { ------------------ | | 262| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19559| 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| } ------------------ 19560| 0| dns_rdata_dnskey_t structdnskey; 19561| | 19562| 0| dns_rdataset_current(&dnskey, &rdata); 19563| 0| dns_rdata_tostruct(&rdata, 19564| 0| &structdnskey, NULL); 19565| | 19566| 0| if (structdnskey.algorithm == ------------------ | Branch (19566:10): [True: 0, False: 0] ------------------ 19567| 0| structcds.algorithm) 19568| 0| { 19569| 0| algorithms[structcds.algorithm] = 19570| 0| found; 19571| 0| } 19572| 0| } 19573| 0| } else { 19574| 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| } ------------------ 19575| 0| dns_rdata_dnskey_t structdnskey; 19576| 0| dst_algorithm_t dnskeyalg; 19577| | 19578| | /* Convert CDS to DS */ 19579| 0| crdata.type = dns_rdatatype_ds; ------------------ | | 157| 0|#define dns_rdatatype_ds ((dns_rdatatype_t)dns_rdatatype_ds) ------------------ 19580| 0| result = dns_dnssec_matchdskey(&zone->origin, 19581| 0| &crdata, &dnskey, 19582| 0| &rdata); 19583| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (19583:9): [True: 0, False: 0] ------------------ 19584| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19585| 0| } 19586| 0| CHECK(dns_rdata_tostruct(&rdata, &structdnskey, ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 19587| 0| NULL)); 19588| 0| dnskeyalg = dst_algorithm_fromdata( 19589| 0| structdnskey.algorithm, 19590| 0| structdnskey.data, 19591| 0| structdnskey.datalen); 19592| 0| algorithms[dnskeyalg] = found; 19593| 0| } 19594| 0| } 19595| 0| for (i = 0; i < sizeof(algorithms); i++) { ------------------ | Branch (19595:15): [True: 0, False: 0] ------------------ 19596| 0| if (delete) { ------------------ | Branch (19596:8): [True: 0, False: 0] ------------------ 19597| 0| if (algorithms[i] != notexpected) { ------------------ | Branch (19597:9): [True: 0, False: 0] ------------------ 19598| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19599| 0| } 19600| 0| } else if (algorithms[i] == expected) { ------------------ | Branch (19600:15): [True: 0, False: 0] ------------------ 19601| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19602| 0| } 19603| 0| } 19604| 0| } 19605| | 19606| | /* 19607| | * For each DNSSEC algorithm in the CDNSKEY RRset there must be 19608| | * a matching DNSKEY record with the exception of a CDNSKEY deletion 19609| | * record which must be by itself. 19610| | */ 19611| 0| if (dns_rdataset_isassociated(&cdnskey)) { ------------------ | Branch (19611:6): [True: 0, False: 0] ------------------ 19612| 0| bool delete = false; 19613| 0| memset(algorithms, notexpected, sizeof(algorithms)); 19614| 0| DNS_RDATASET_FOREACH(&cdnskey) { ------------------ | | 262| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19615| 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| } ------------------ 19616| 0| dns_rdata_cdnskey_t structcdnskey; 19617| 0| dst_algorithm_t cdnskeyalg; 19618| | 19619| 0| dns_rdataset_current(&cdnskey, &crdata); 19620| | /* 19621| | * CDNSKEY deletion record has this form 19622| | * "0 3 0 AA==" which is 2 zero octets, a 3, 19623| | * and 2 zero octets. 19624| | */ 19625| 0| if (crdata.length == 5U && ------------------ | Branch (19625:8): [True: 0, False: 0] ------------------ 19626| 0| memcmp(crdata.data, ------------------ | Branch (19626:8): [True: 0, False: 0] ------------------ 19627| 0| (unsigned char[5]){ 0, 0, 3, 0, 0 }, 5) == 0) 19628| 0| { 19629| 0| delete = true; 19630| 0| continue; 19631| 0| } 19632| | 19633| 0| if (empty) { ------------------ | Branch (19633:8): [True: 0, False: 0] ------------------ 19634| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19635| 0| } 19636| | 19637| 0| CHECK(dns_rdata_tostruct(&crdata, &structcdnskey, ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 19638| 0| NULL)); 19639| 0| cdnskeyalg = dst_algorithm_fromdata( 19640| 0| structcdnskey.algorithm, structcdnskey.data, 19641| 0| structcdnskey.datalen); 19642| 0| if (algorithms[cdnskeyalg] == 0) { ------------------ | Branch (19642:8): [True: 0, False: 0] ------------------ 19643| 0| algorithms[cdnskeyalg] = expected; 19644| 0| } 19645| 0| DNS_RDATASET_FOREACH(&dnskey) { ------------------ | | 262| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19646| 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| } ------------------ 19647| 0| dns_rdata_dnskey_t structdnskey; 19648| 0| dst_algorithm_t dnskeyalg; 19649| | 19650| 0| dns_rdataset_current(&dnskey, &rdata); 19651| 0| CHECK(dns_rdata_tostruct(&rdata, &structdnskey, ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 19652| 0| NULL)); 19653| 0| dnskeyalg = dst_algorithm_fromdata( 19654| 0| structdnskey.algorithm, 19655| 0| structdnskey.data, 19656| 0| structdnskey.datalen); 19657| | 19658| 0| if (dnskeyalg == cdnskeyalg) { ------------------ | Branch (19658:9): [True: 0, False: 0] ------------------ 19659| 0| algorithms[cdnskeyalg] = found; 19660| 0| } 19661| 0| } 19662| 0| } 19663| 0| for (i = 0; i < sizeof(algorithms); i++) { ------------------ | Branch (19663:15): [True: 0, False: 0] ------------------ 19664| 0| if (delete) { ------------------ | Branch (19664:8): [True: 0, False: 0] ------------------ 19665| 0| if (algorithms[i] != notexpected) { ------------------ | Branch (19665:9): [True: 0, False: 0] ------------------ 19666| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19667| 0| } 19668| 0| } else if (algorithms[i] == expected) { ------------------ | Branch (19668:15): [True: 0, False: 0] ------------------ 19669| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19670| 0| } 19671| 0| } 19672| 0| } 19673| 0| result = ISC_R_SUCCESS; 19674| | 19675| 2|cleanup: 19676| 2| dns_rdataset_cleanup(&cds); ------------------ | | 297| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 2, Folded] | | | Branch (297:26): [True: 0, False: 2] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 19677| 2| dns_rdataset_cleanup(&dnskey); ------------------ | | 297| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 2, Folded] | | | Branch (297:26): [True: 0, False: 2] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 19678| 2| dns_rdataset_cleanup(&cdnskey); ------------------ | | 297| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 2, Folded] | | | Branch (297:26): [True: 0, False: 2] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 19679| 2| dns_db_detachnode(&node); ------------------ | | 1018| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 19680| 2| return result; 19681| 0|} dns_zone_verifydb: 20735| 2|dns_zone_verifydb(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *ver) { 20736| 2| dns_dbversion_t *version = NULL; 20737| 2| dns_keytable_t *secroots = NULL; 20738| 2| isc_result_t result; 20739| 2| dns_name_t *origin; 20740| | 20741| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 20742| 2| REQUIRE(db != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 20743| | 20744| 2| ENTER; ------------------ | | 355| 2|#define ENTER zone_debuglog(zone, __func__, 1, "enter") ------------------ 20745| | 20746| 2| if (dns_zone_gettype(zone) != dns_zone_mirror) { ------------------ | Branch (20746:6): [True: 2, False: 0] ------------------ 20747| 2| return ISC_R_SUCCESS; 20748| 2| } 20749| | 20750| 0| if (ver == NULL) { ------------------ | Branch (20750:6): [True: 0, False: 0] ------------------ 20751| 0| dns_db_currentversion(db, &version); 20752| 0| } else { 20753| 0| version = ver; 20754| 0| } 20755| | 20756| 0| if (zone->view != NULL) { ------------------ | Branch (20756:6): [True: 0, False: 0] ------------------ 20757| 0| result = dns_view_getsecroots(zone->view, &secroots); 20758| 0| CHECK(result); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 20759| 0| } 20760| | 20761| 0| origin = dns_db_origin(db); 20762| 0| result = dns_zoneverify_dnssec(zone, db, version, origin, secroots, 20763| 0| zone->mctx, true, false, dnssec_report); 20764| | 20765| 0|cleanup: 20766| 0| if (secroots != NULL) { ------------------ | Branch (20766:6): [True: 0, False: 0] ------------------ 20767| 0| dns_keytable_detach(&secroots); 20768| 0| } 20769| | 20770| 0| if (ver == NULL) { ------------------ | Branch (20770:6): [True: 0, False: 0] ------------------ 20771| 0| dns_db_closeversion(db, &version, false); ------------------ | | 730| 0| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 20772| 0| } 20773| | 20774| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20774:6): [True: 0, False: 0] ------------------ 20775| 0| dnssec_log(zone, ISC_LOG_ERROR, "zone verification failed: %s", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 20776| 0| isc_result_totext(result)); 20777| 0| result = DNS_R_VERIFYFAILURE; 20778| 0| } 20779| | 20780| 0| return result; 20781| 0|} dns_zone_makedb: 20822| 2|dns_zone_makedb(dns_zone_t *zone, dns_db_t **dbp) { 20823| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 20824| 2| REQUIRE(dbp != NULL && *dbp == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 20825| | 20826| 2| dns_db_t *db = NULL; 20827| | 20828| 2| isc_result_t result = dns_db_create( 20829| 2| zone->mctx, zone->db_argv[0], &zone->origin, 20830| 2| (zone->type == dns_zone_stub) ? dns_dbtype_stub ------------------ | Branch (20830:3): [True: 0, False: 2] ------------------ 20831| 2| : dns_dbtype_zone, 20832| 2| zone->rdclass, zone->db_argc - 1, zone->db_argv + 1, &db); 20833| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20833:6): [True: 0, False: 2] ------------------ 20834| 0| return result; 20835| 0| } 20836| | 20837| 2| switch (zone->type) { 20838| 2| case dns_zone_primary: ------------------ | Branch (20838:2): [True: 2, False: 0] ------------------ 20839| 2| case dns_zone_secondary: ------------------ | Branch (20839:2): [True: 0, False: 2] ------------------ 20840| 2| case dns_zone_mirror: ------------------ | Branch (20840:2): [True: 0, False: 2] ------------------ 20841| 2| result = dns_db_setgluecachestats(db, zone->gluecachestats); 20842| 2| if (result == ISC_R_NOTIMPLEMENTED) { ------------------ | Branch (20842:7): [True: 0, False: 2] ------------------ 20843| 0| result = ISC_R_SUCCESS; 20844| 0| } 20845| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20845:7): [True: 0, False: 2] ------------------ 20846| 0| dns_db_detach(&db); 20847| 0| return result; 20848| 0| } 20849| 2| break; 20850| 2| default: ------------------ | Branch (20850:2): [True: 0, False: 2] ------------------ 20851| 0| break; 20852| 2| } 20853| | 20854| 2| dns_db_setmaxrrperset(db, zone->maxrrperset); 20855| 2| dns_db_setmaxtypepername(db, zone->maxtypepername); 20856| | 20857| 2| *dbp = db; 20858| | 20859| 2| return ISC_R_SUCCESS; 20860| 2|} zone.c:zone_load: 1175| 2|zone_load(dns_zone_t *zone, unsigned int flags, bool locked) { 1176| 2| isc_result_t result; 1177| 2| isc_time_t now; 1178| 2| isc_time_t loadtime; 1179| 2| dns_db_t *db = NULL; 1180| 2| bool rbt, hasraw, is_dynamic; 1181| | 1182| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1183| | 1184| 2| if (!locked) { ------------------ | Branch (1184:6): [True: 2, False: 0] ------------------ 1185| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 1186| 2| } 1187| | 1188| 2| INSIST(zone != zone->raw); ------------------ | | 202| 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))) | | ------------------ ------------------ 1189| 2| hasraw = dns__zone_inline_secure(zone); 1190| 2| if (hasraw) { ------------------ | Branch (1190:6): [True: 0, False: 2] ------------------ 1191| | /* 1192| | * We are trying to load an inline-signed zone. First call 1193| | * self recursively to try loading the raw version of the zone. 1194| | * Assuming the raw zone file is readable, there are two 1195| | * possibilities: 1196| | * 1197| | * a) the raw zone was not yet loaded and thus it will be 1198| | * loaded now, synchronously; if this succeeds, a 1199| | * subsequent attempt to load the signed zone file will 1200| | * take place and thus zone_postload() will be called 1201| | * twice: first for the raw zone and then for the secure 1202| | * zone; the latter call will be followed by scheduling 1203| | * secure maintenance to sync against the raw version, 1204| | * 1205| | * b) the raw zone was already loaded and we are trying to 1206| | * reload it, which will happen asynchronously; this means 1207| | * zone_postload() will only be called for the raw zone 1208| | * because "result" returned by the zone_load() call below 1209| | * will not be ISC_R_SUCCESS but rather DNS_R_CONTINUE; 1210| | * zone_postload() called for the raw zone will schedule 1211| | * secure maintenance to sync against the raw version. 1212| | */ 1213| 0| result = zone_load(zone->raw, flags, false); 1214| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1214:7): [True: 0, False: 0] ------------------ 1215| 0| if (!locked) { ------------------ | Branch (1215:8): [True: 0, False: 0] ------------------ 1216| 0| UNLOCK_ZONE(zone); ------------------ | | 86| 0| do { \ | | 87| 0| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 0| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 1217| 0| } 1218| 0| return result; 1219| 0| } 1220| 0| } 1221| | 1222| 2| now = isc_time_now(); 1223| | 1224| 2| INSIST(zone->type != dns_zone_none); ------------------ | | 202| 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))) | | ------------------ ------------------ 1225| | 1226| | /* load was already in progress */ 1227| 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] | | ------------------ ------------------ 1228| 0| if ((flags & DNS_ZONELOADFLAG_THAW) != 0) { ------------------ | Branch (1228:7): [True: 0, False: 0] ------------------ 1229| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_THAW); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1230| 0| } 1231| 0| CLEANUP(ISC_R_LOADING); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1232| 0| } 1233| | 1234| 2| INSIST(zone->db_argc >= 1); ------------------ | | 202| 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))) | | ------------------ ------------------ 1235| | 1236| 2| rbt = strcmp(zone->db_argv[0], ZONEDB_DEFAULT) == 0; ------------------ | | 178| 2|#define ZONEDB_DEFAULT "qpzone" ------------------ 1237| | 1238| 2| if (zone->db != NULL && zone->masterfile == NULL && rbt) { ------------------ | Branch (1238:6): [True: 0, False: 2] | Branch (1238:26): [True: 0, False: 0] | Branch (1238:54): [True: 0, False: 0] ------------------ 1239| | /* 1240| | * The zone has no master file configured. 1241| | */ 1242| 0| result = ISC_R_SUCCESS; 1243| 0| goto cleanup; 1244| 0| } 1245| | 1246| 2| is_dynamic = dns_zone_isdynamic(zone, false); 1247| 2| if (zone->db != NULL && is_dynamic) { ------------------ | Branch (1247:6): [True: 0, False: 2] | Branch (1247:26): [True: 0, False: 0] ------------------ 1248| | /* 1249| | * This is a secondary, stub, or dynamically updated zone 1250| | * being reloaded. Do nothing - the database we already 1251| | * have is guaranteed to be up-to-date. 1252| | */ 1253| 0| if (zone->type == dns_zone_primary && !hasraw) { ------------------ | Branch (1253:7): [True: 0, False: 0] | Branch (1253:41): [True: 0, False: 0] ------------------ 1254| 0| result = DNS_R_DYNAMIC; 1255| 0| } else { 1256| 0| result = ISC_R_SUCCESS; 1257| 0| } 1258| 0| goto cleanup; 1259| 0| } 1260| | 1261| | /* 1262| | * Store the current time before the zone is loaded, so that if the 1263| | * file changes between the time of the load and the time that 1264| | * zone->loadtime is set, then the file will still be reloaded 1265| | * the next time dns_zone_load is called. 1266| | */ 1267| 2| loadtime = isc_time_now(); 1268| | 1269| | /* 1270| | * Don't do the load if the file that stores the zone is older 1271| | * than the last time the zone was loaded. If the zone has not 1272| | * been loaded yet, zone->loadtime will be the epoch. 1273| | */ 1274| 2| if (zone->masterfile != NULL) { ------------------ | Branch (1274:6): [True: 2, False: 0] ------------------ 1275| 2| isc_time_t filetime; 1276| | 1277| | /* 1278| | * The file is already loaded. If we are just doing a 1279| | * "rndc reconfig", we are done. 1280| | */ 1281| 2| if (!isc_time_isepoch(&zone->loadtime) && ------------------ | Branch (1281:7): [True: 0, False: 2] ------------------ 1282| 0| (flags & DNS_ZONELOADFLAG_NOSTAT) != 0) ------------------ | Branch (1282:7): [True: 0, False: 0] ------------------ 1283| 0| { 1284| 0| result = ISC_R_SUCCESS; 1285| 0| goto cleanup; 1286| 0| } 1287| | 1288| 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] | | ------------------ ------------------ 1289| 0| !zone_touched(zone)) ------------------ | Branch (1289:7): [True: 0, False: 0] ------------------ 1290| 0| { 1291| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1292| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1293| 0| "skipping load: master file " 1294| 0| "older than last load"); 1295| 0| CLEANUP(DNS_R_UPTODATE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1296| 0| } 1297| | 1298| | /* 1299| | * If the file modification time is in the past 1300| | * set loadtime to that value. 1301| | */ 1302| 2| result = isc_file_getmodtime(zone->masterfile, &filetime); 1303| 2| if (result == ISC_R_SUCCESS && ------------------ | Branch (1303:7): [True: 2, False: 0] ------------------ 1304| 2| isc_time_compare(&loadtime, &filetime) > 0) ------------------ | Branch (1304:7): [True: 0, False: 2] ------------------ 1305| 0| { 1306| 0| loadtime = filetime; 1307| 0| } 1308| 2| } 1309| | 1310| | /* 1311| | * Built in zones (with the exception of empty zones) don't need 1312| | * to be reloaded. 1313| | */ 1314| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (1314:6): [True: 2, False: 0] ------------------ 1315| 2| strcmp(zone->db_argv[0], "_builtin") == 0 && ------------------ | Branch (1315:6): [True: 0, False: 2] ------------------ 1316| 0| (zone->db_argc < 2 || strcmp(zone->db_argv[1], "empty") != 0) && ------------------ | Branch (1316:7): [True: 0, False: 0] | Branch (1316:28): [True: 0, False: 0] ------------------ 1317| 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] | | ------------------ ------------------ 1318| 0| { 1319| 0| result = ISC_R_SUCCESS; 1320| 0| goto cleanup; 1321| 0| } 1322| | 1323| | /* 1324| | * Zones associated with a DLZ don't need to be loaded either, 1325| | * but we need to associate the database with the zone object. 1326| | */ 1327| 2| if (strcmp(zone->db_argv[0], "dlz") == 0) { ------------------ | Branch (1327:6): [True: 0, False: 2] ------------------ 1328| 0| dns_dlzdb_t *dlzdb = NULL; 1329| 0| dns_dlzfindzone_t findzone; 1330| | 1331| 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] | | ------------------ ------------------ 1332| 0| INSIST(DNS_DLZ_VALID(d)); ------------------ | | 202| 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))) | | ------------------ ------------------ 1333| 0| if (strcmp(zone->db_argv[1], d->dlzname) == 0) { ------------------ | Branch (1333:8): [True: 0, False: 0] ------------------ 1334| 0| dlzdb = d; 1335| 0| break; 1336| 0| } 1337| 0| } 1338| | 1339| 0| if (dlzdb == NULL) { ------------------ | Branch (1339:7): [True: 0, False: 0] ------------------ 1340| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1341| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1342| 0| "DLZ %s does not exist or is set " 1343| 0| "to 'search yes;'", 1344| 0| zone->db_argv[1]); 1345| 0| CLEANUP(ISC_R_NOTFOUND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1346| 0| } 1347| | 1348| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } | | ------------------ ------------------ 1349| | /* ask SDLZ driver if the zone is supported */ 1350| 0| findzone = dlzdb->implementation->methods->findzone; 1351| 0| result = (*findzone)(dlzdb->implementation->driverarg, 1352| 0| dlzdb->dbdata, dlzdb->mctx, 1353| 0| zone->view->rdclass, &zone->origin, NULL, 1354| 0| NULL, &db); 1355| 0| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (1355:7): [True: 0, False: 0] ------------------ 1356| 0| if (zone->db != NULL) { ------------------ | Branch (1356:8): [True: 0, False: 0] ------------------ 1357| 0| zone_detachdb(zone); 1358| 0| } 1359| 0| zone_attachdb(zone, db); 1360| 0| dns_db_detach(&db); 1361| 0| result = ISC_R_SUCCESS; 1362| 0| } 1363| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } | | ------------------ ------------------ 1364| | 1365| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1365:7): [True: 0, False: 0] ------------------ 1366| 0| if (dlzdb->configure_callback == NULL) { ------------------ | Branch (1366:8): [True: 0, False: 0] ------------------ 1367| 0| goto cleanup; 1368| 0| } 1369| | 1370| 0| result = (*dlzdb->configure_callback)(zone->view, dlzdb, 1371| 0| zone); 1372| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1372:8): [True: 0, False: 0] ------------------ 1373| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1374| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1375| 0| "DLZ configuration callback: %s", 1376| 0| isc_result_totext(result)); 1377| 0| } 1378| 0| } 1379| 0| goto cleanup; 1380| 0| } 1381| | 1382| 2| if ((zone->type == dns_zone_secondary || ------------------ | Branch (1382:7): [True: 0, False: 2] ------------------ 1383| 2| zone->type == dns_zone_mirror || zone->type == dns_zone_stub || ------------------ | Branch (1383:7): [True: 0, False: 2] | Branch (1383:40): [True: 0, False: 2] ------------------ 1384| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (1384:8): [True: 0, False: 2] ------------------ 1385| 0| dns_remote_addresses(&zone->primaries) != NULL)) && ------------------ | Branch (1385:8): [True: 0, False: 0] ------------------ 1386| 0| rbt) ------------------ | Branch (1386:6): [True: 0, False: 0] ------------------ 1387| 0| { 1388| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIRSTREFRESH); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1389| | 1390| 0| if (zone->stream == NULL && ------------------ | Branch (1390:7): [True: 0, False: 0] ------------------ 1391| 0| (zone->masterfile == NULL || ------------------ | Branch (1391:8): [True: 0, False: 0] ------------------ 1392| 0| !isc_file_exists(zone->masterfile))) ------------------ | Branch (1392:8): [True: 0, False: 0] ------------------ 1393| 0| { 1394| 0| if (zone->masterfile != NULL) { ------------------ | Branch (1394:8): [True: 0, False: 0] ------------------ 1395| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1396| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1397| 0| "no master file"); 1398| 0| } 1399| 0| zone->refreshtime = now; 1400| 0| if (zone->loop != NULL) { ------------------ | Branch (1400:8): [True: 0, False: 0] ------------------ 1401| 0| dns__zone_settimer(zone, now); 1402| 0| } 1403| 0| result = ISC_R_SUCCESS; 1404| 0| goto cleanup; 1405| 0| } 1406| 0| } 1407| | 1408| 2| if (zone->type == dns_zone_primary && zone->masterfile != NULL && ------------------ | Branch (1408:6): [True: 2, False: 0] | Branch (1408:40): [True: 2, False: 0] ------------------ 1409| 2| !isc_file_exists(zone->masterfile) && zone->initfile != NULL) ------------------ | Branch (1409:6): [True: 0, False: 2] | Branch (1409:44): [True: 0, False: 0] ------------------ 1410| 0| { 1411| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 1412| 0| "zone file %s not found; copying initial " 1413| 0| "file %s", 1414| 0| zone->masterfile, zone->initfile); 1415| 0| result = copy_initfile(zone); 1416| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1416:7): [True: 0, False: 0] ------------------ 1417| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1418| 0| ISC_LOG_ERROR, "copy from %s failed: %s", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1419| 0| zone->initfile, 1420| 0| isc_result_totext(result)); 1421| 0| } 1422| 0| } 1423| | 1424| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 1425| 2| "starting load"); 1426| | 1427| 2| result = dns_zone_makedb(zone, &db); 1428| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1428:6): [True: 0, False: 2] ------------------ 1429| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1430| 0| "loading zone: creating database: %s", 1431| 0| isc_result_totext(result)); 1432| 0| goto cleanup; 1433| 0| } 1434| | 1435| 2| if (!dns_db_ispersistent(db)) { ------------------ | Branch (1435:6): [True: 2, False: 0] ------------------ 1436| 2| if (zone->masterfile != NULL || zone->stream != NULL) { ------------------ | Branch (1436:7): [True: 2, False: 0] | Branch (1436:35): [True: 0, False: 0] ------------------ 1437| 2| result = zone_startload(db, zone, loadtime); 1438| 2| } else { 1439| 0| result = DNS_R_NOMASTERFILE; 1440| 0| if (zone->type == dns_zone_primary || ------------------ | Branch (1440:8): [True: 0, False: 0] ------------------ 1441| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (1441:9): [True: 0, False: 0] ------------------ 1442| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (1442:9): [True: 0, False: 0] ------------------ 1443| 0| { 1444| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1445| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1446| 0| "loading zone: " 1447| 0| "no master file configured"); 1448| 0| goto cleanup; 1449| 0| } 1450| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1451| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 1452| 0| "loading zone: " 1453| 0| "no master file configured: continuing"); 1454| 0| } 1455| 2| } 1456| | 1457| 2| if (result == DNS_R_CONTINUE) { ------------------ | Branch (1457:6): [True: 0, False: 2] ------------------ 1458| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADING); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1459| 0| if ((flags & DNS_ZONELOADFLAG_THAW) != 0) { ------------------ | Branch (1459:7): [True: 0, False: 0] ------------------ 1460| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_THAW); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1461| 0| } 1462| 0| goto cleanup; 1463| 0| } 1464| | 1465| 2| result = zone_postload(zone, db, loadtime, result); 1466| 2| if (hasraw && result == ISC_R_SUCCESS) { ------------------ | Branch (1466:6): [True: 0, False: 2] | Branch (1466:16): [True: 0, False: 0] ------------------ 1467| 0| zone_schedule_inline_sync(zone, inline_sync_incremental); 1468| 0| } 1469| | 1470| 2|cleanup: 1471| 2| if (!locked) { ------------------ | Branch (1471:6): [True: 2, False: 0] ------------------ 1472| 2| UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 1473| 2| } 1474| 2| if (db != NULL) { ------------------ | Branch (1474:6): [True: 2, False: 0] ------------------ 1475| 2| dns_db_detach(&db); 1476| 2| } 1477| 2| return result; 1478| 2|} zone.c:zone_attachdb: 15408| 2|zone_attachdb(dns_zone_t *zone, dns_db_t *db) { 15409| 2| REQUIRE(zone->db == NULL && db != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 15410| | 15411| 2| dns_db_attach(db, &zone->db); 15412| 2|} zone.c:zone_startload: 1714| 2|zone_startload(dns_db_t *db, dns_zone_t *zone, isc_time_t loadtime) { 1715| 2| isc_result_t result; 1716| 2| isc_result_t tresult; 1717| 2| unsigned int options; 1718| 2| dns_load_t *load = isc_mem_get(zone->mctx, sizeof(*load)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1719| | 1720| 2| ENTER; ------------------ | | 355| 2|#define ENTER zone_debuglog(zone, __func__, 1, "enter") ------------------ 1721| | 1722| 2| *load = (dns_load_t){ 1723| 2| .loadtime = loadtime, 1724| 2| }; 1725| | 1726| 2| dns_zone_rpz_enable_db(zone, db); 1727| 2| dns_zone_catz_enable_db(zone, db); 1728| | 1729| 2| options = get_primary_options(zone); 1730| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_MANYERRORS)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1731| 0| options |= DNS_MASTER_MANYERRORS; ------------------ | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ ------------------ 1732| 0| } 1733| | 1734| 2| zone_iattach(zone, &load->zone); 1735| 2| dns_db_attach(db, &load->db); 1736| | 1737| 2| dns_rdatacallbacks_init(&load->callbacks); 1738| 2| load->callbacks.rawdata = zone_setrawdata; 1739| 2| zone_iattach(zone, &load->callbacks.zone); 1740| | 1741| 2| CHECK(dns_db_beginload(db, &load->callbacks)); ------------------ | | 255| 2| { \ | | 256| 2| result = (r); \ | | 257| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 2] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 2| } ------------------ 1742| | 1743| 2| if (zone->zmgr != NULL && zone->db != NULL) { ------------------ | Branch (1743:6): [True: 0, False: 2] | Branch (1743:28): [True: 0, False: 0] ------------------ 1744| 0| CHECK(dns_master_loadfileasync( ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 1745| 0| zone->masterfile, dns_db_origin(db), dns_db_origin(db), 1746| 0| zone->rdclass, options, 0, &load->callbacks, zone->loop, 1747| 0| zone_loaddone, load, &zone->loadctx, 1748| 0| zone_registerinclude, zone, zone->mctx, 1749| 0| zone->masterformat, zone->maxttl)); 1750| | 1751| 0| return DNS_R_CONTINUE; 1752| 2| } else if (zone->stream != NULL) { ------------------ | Branch (1752:13): [True: 0, False: 2] ------------------ 1753| 0| FILE *stream = UNCONST(zone->stream); ------------------ | | 96| 0|#define UNCONST(ptr) ((void *)(uintptr_t)(ptr)) ------------------ 1754| 0| result = dns_master_loadstream( 1755| 0| stream, &zone->origin, &zone->origin, zone->rdclass, 1756| 0| options, &load->callbacks, zone->mctx); 1757| 2| } else { 1758| 2| result = dns_master_loadfile( 1759| 2| zone->masterfile, &zone->origin, &zone->origin, 1760| 2| zone->rdclass, options, 0, &load->callbacks, 1761| 2| zone_registerinclude, zone, zone->mctx, 1762| 2| zone->masterformat, zone->maxttl); 1763| 2| } 1764| | 1765| 2|cleanup: 1766| 2| if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE) { ------------------ | Branch (1766:6): [True: 0, False: 2] | Branch (1766:33): [True: 0, False: 0] ------------------ 1767| 0| dns_zone_rpz_disable_db(zone, load->db); 1768| 0| dns_zone_catz_disable_db(zone, load->db); 1769| 0| } 1770| | 1771| 2| tresult = dns_db_endload(db, &load->callbacks); 1772| 2| if (result == ISC_R_SUCCESS || result == DNS_R_SEENINCLUDE) { ------------------ | Branch (1772:6): [True: 2, False: 0] | Branch (1772:33): [True: 0, False: 0] ------------------ 1773| 2| result = tresult; 1774| 2| } 1775| | 1776| 2| zone_idetach(&load->callbacks.zone); 1777| 2| dns_db_detach(&load->db); 1778| 2| zone_idetach(&load->zone); 1779| | 1780| | isc_mem_put(zone->mctx, load, sizeof(*load)); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 2] | | ------------------ ------------------ 1781| 2| return result; 1782| 2|} zone.c:get_primary_options: 1593| 2|get_primary_options(dns_zone_t *zone) { 1594| 2| unsigned int options; 1595| | 1596| 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 ------------------ 1597| 2| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (1597:6): [True: 0, False: 2] | Branch (1597:42): [True: 0, False: 2] ------------------ 1598| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (1598:7): [True: 0, False: 2] ------------------ 1599| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (1599:7): [True: 0, False: 0] ------------------ 1600| 0| { 1601| 0| options |= DNS_MASTER_SECONDARY; ------------------ | | 36| 0|#define DNS_MASTER_SECONDARY 0x00000020 /*%< Secondary master file. */ ------------------ 1602| 0| } 1603| 2| if (zone->type == dns_zone_key) { ------------------ | Branch (1603:6): [True: 0, False: 2] ------------------ 1604| 0| options |= DNS_MASTER_KEY; ------------------ | | 56| 0|#define DNS_MASTER_KEY 0x00004000 /*%< Loading a key zone master file. */ ------------------ 1605| 0| } 1606| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNS)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1607| 0| options |= DNS_MASTER_CHECKNS; ------------------ | | 38| 0| 0x00000040 /*%< \ ------------------ 1608| 0| } 1609| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_FATALNS)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1610| 0| options |= DNS_MASTER_FATALNS; ------------------ | | 43| 0| 0x00000080 /*%< \ ------------------ 1611| 0| } 1612| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMES)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1613| 0| options |= DNS_MASTER_CHECKNAMES; ------------------ | | 47| 0|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ 1614| 0| } 1615| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMESFAIL)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1616| 0| options |= DNS_MASTER_CHECKNAMESFAIL; ------------------ | | 48| 0|#define DNS_MASTER_CHECKNAMESFAIL 0x00000200 ------------------ 1617| 0| } 1618| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKMX)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1619| 0| options |= DNS_MASTER_CHECKMX; ------------------ | | 52| 0|#define DNS_MASTER_CHECKMX 0x00000800 ------------------ 1620| 0| } 1621| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKMXFAIL)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1622| 0| options |= DNS_MASTER_CHECKMXFAIL; ------------------ | | 53| 0|#define DNS_MASTER_CHECKMXFAIL 0x00001000 ------------------ 1623| 0| } 1624| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKWILDCARD)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1625| 0| options |= DNS_MASTER_CHECKWILDCARD; ------------------ | | 50| 0| 0x00000400 /* Check for internal wildcards. \ ------------------ 1626| 0| } 1627| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKTTL)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1628| 0| options |= DNS_MASTER_CHECKTTL; ------------------ | | 58| 0|#define DNS_MASTER_CHECKTTL 0x00010000 /*%< Check max-zone-ttl */ ------------------ 1629| 0| } 1630| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKSVCB)) { ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 1631| 0| options |= DNS_MASTER_CHECKSVCB; ------------------ | | 59| 0|#define DNS_MASTER_CHECKSVCB 0x00020000 /*%< Check SVBC records */ ------------------ 1632| 0| } 1633| | 1634| 2| return options; 1635| 2|} zone.c:zone_get_from_db: 4849| 2| uint32_t *minimum, unsigned int *errors) { 4850| 2| isc_result_t result; 4851| 2| isc_result_t answer = ISC_R_SUCCESS; 4852| 2| dns_dbversion_t *version = NULL; 4853| 2| dns_dbnode_t *node; 4854| | 4855| 2| REQUIRE(db != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 4856| 2| REQUIRE(zone != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 4857| | 4858| 2| dns_db_currentversion(db, &version); 4859| | 4860| 2| SET_IF_NOT_NULL(nscount, 0); ------------------ | | 104| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 2, False: 0] | | ------------------ | | 105| 2| *(obj) = (val); \ | | 106| 2| } ------------------ 4861| 2| SET_IF_NOT_NULL(soacount, 0); ------------------ | | 104| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 2, False: 0] | | ------------------ | | 105| 2| *(obj) = (val); \ | | 106| 2| } ------------------ 4862| 2| SET_IF_NOT_NULL(errors, 0); ------------------ | | 104| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 2, False: 0] | | ------------------ | | 105| 2| *(obj) = (val); \ | | 106| 2| } ------------------ 4863| 2| CLR_SOA_VALUES(); ------------------ | | 4788| 2| { \ | | 4789| 2| SET_SOA_VALUES(0, 0, 0, 0, 0, 0); \ | | ------------------ | | | | 4778| 2| { \ | | | | 4779| 2| SET_IF_NOT_NULL(soattl, soattl_v); \ | | | | ------------------ | | | | | | 104| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 105| 2| *(obj) = (val); \ | | | | | | 106| 2| } | | | | ------------------ | | | | 4780| 2| SET_IF_NOT_NULL(serial, serial_v); \ | | | | ------------------ | | | | | | 104| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 105| 2| *(obj) = (val); \ | | | | | | 106| 2| } | | | | ------------------ | | | | 4781| 2| SET_IF_NOT_NULL(refresh, refresh_v); \ | | | | ------------------ | | | | | | 104| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 105| 2| *(obj) = (val); \ | | | | | | 106| 2| } | | | | ------------------ | | | | 4782| 2| SET_IF_NOT_NULL(retry, retry_v); \ | | | | ------------------ | | | | | | 104| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 105| 2| *(obj) = (val); \ | | | | | | 106| 2| } | | | | ------------------ | | | | 4783| 2| SET_IF_NOT_NULL(expire, expire_v); \ | | | | ------------------ | | | | | | 104| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 105| 2| *(obj) = (val); \ | | | | | | 106| 2| } | | | | ------------------ | | | | 4784| 2| SET_IF_NOT_NULL(minimum, minimum_v); \ | | | | ------------------ | | | | | | 104| 2| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 105| 2| *(obj) = (val); \ | | | | | | 106| 2| } | | | | ------------------ | | | | 4785| 2| } | | ------------------ | | 4790| 2| } ------------------ 4864| | 4865| 2| node = NULL; 4866| 2| result = dns_db_findnode(db, &zone->origin, false, &node); ------------------ | | 767| 2| dns__db_findnode(db, name, create, NULL, NULL, nodep DNS__DB_FILELINE) ------------------ 4867| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4867:6): [True: 0, False: 2] ------------------ 4868| 0| answer = result; 4869| 0| goto closeversion; 4870| 0| } 4871| | 4872| 2| if (nscount != NULL || errors != NULL) { ------------------ | Branch (4872:6): [True: 2, False: 0] | Branch (4872:25): [True: 0, False: 0] ------------------ 4873| 2| result = zone_count_ns_rr(zone, db, node, version, nscount, 4874| 2| errors, true); 4875| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4875:7): [True: 0, False: 2] ------------------ 4876| 0| answer = result; 4877| 0| } 4878| 2| } 4879| | 4880| 2| if (soacount != NULL || soattl != NULL || serial != NULL || ------------------ | Branch (4880:6): [True: 2, False: 0] | Branch (4880:26): [True: 0, False: 0] | Branch (4880:44): [True: 0, False: 0] ------------------ 4881| 0| refresh != NULL || retry != NULL || expire != NULL || ------------------ | Branch (4881:6): [True: 0, False: 0] | Branch (4881:25): [True: 0, False: 0] | Branch (4881:42): [True: 0, False: 0] ------------------ 4882| 0| minimum != NULL) ------------------ | Branch (4882:6): [True: 0, False: 0] ------------------ 4883| 2| { 4884| 2| result = zone_load_soa_rr(db, node, version, soacount, soattl, 4885| 2| serial, refresh, retry, expire, 4886| 2| minimum); 4887| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4887:7): [True: 0, False: 2] ------------------ 4888| 0| answer = result; 4889| 0| } 4890| 2| } 4891| | 4892| 2| dns_db_detachnode(&node); ------------------ | | 1018| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 4893| 2|closeversion: 4894| 2| dns_db_closeversion(db, &version, false); ------------------ | | 730| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 4895| | 4896| 2| return answer; 4897| 2|} zone.c:zone_load_soa_rr: 4796| 2| uint32_t *minimum) { 4797| 2| isc_result_t result; 4798| 2| unsigned int count = 0; 4799| 2| dns_rdataset_t rdataset; 4800| | 4801| 2| dns_rdataset_init(&rdataset); 4802| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_soa, ------------------ | | 1119| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 2| sigrdataset DNS__DB_FILELINE) ------------------ 4803| 2| dns_rdatatype_none, 0, &rdataset, NULL); 4804| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (4804:6): [True: 0, False: 2] ------------------ 4805| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 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))) | | ------------------ ------------------ 4806| 0| result = ISC_R_SUCCESS; 4807| 0| goto invalidate_rdataset; 4808| 0| } 4809| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4809:6): [True: 0, False: 2] ------------------ 4810| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 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))) | | ------------------ ------------------ 4811| 0| goto invalidate_rdataset; 4812| 0| } 4813| | 4814| 2| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 262| 2| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 2| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 4| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 2, False: 2] | | | | ------------------ | | ------------------ ------------------ 4815| 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| } ------------------ 4816| 2| dns_rdataset_current(&rdataset, &rdata); 4817| | 4818| 2| count++; 4819| 2| if (count == 1) { ------------------ | Branch (4819:7): [True: 2, False: 0] ------------------ 4820| 2| dns_rdata_soa_t soa; 4821| 2| result = dns_rdata_tostruct(&rdata, &soa, NULL); 4822| 2| SET_SOA_VALUES(rdataset.ttl, soa.serial, soa.refresh, ------------------ | | 4778| 2| { \ | | 4779| 2| SET_IF_NOT_NULL(soattl, soattl_v); \ | | ------------------ | | | | 104| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (104:6): [True: 2, False: 0] | | | | ------------------ | | | | 105| 2| *(obj) = (val); \ | | | | 106| 2| } | | ------------------ | | 4780| 2| SET_IF_NOT_NULL(serial, serial_v); \ | | ------------------ | | | | 104| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (104:6): [True: 2, False: 0] | | | | ------------------ | | | | 105| 2| *(obj) = (val); \ | | | | 106| 2| } | | ------------------ | | 4781| 2| SET_IF_NOT_NULL(refresh, refresh_v); \ | | ------------------ | | | | 104| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (104:6): [True: 2, False: 0] | | | | ------------------ | | | | 105| 2| *(obj) = (val); \ | | | | 106| 2| } | | ------------------ | | 4782| 2| SET_IF_NOT_NULL(retry, retry_v); \ | | ------------------ | | | | 104| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (104:6): [True: 2, False: 0] | | | | ------------------ | | | | 105| 2| *(obj) = (val); \ | | | | 106| 2| } | | ------------------ | | 4783| 2| SET_IF_NOT_NULL(expire, expire_v); \ | | ------------------ | | | | 104| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (104:6): [True: 2, False: 0] | | | | ------------------ | | | | 105| 2| *(obj) = (val); \ | | | | 106| 2| } | | ------------------ | | 4784| 2| SET_IF_NOT_NULL(minimum, minimum_v); \ | | ------------------ | | | | 104| 2| if ((obj) != NULL) { \ | | | | ------------------ | | | | | Branch (104:6): [True: 2, False: 0] | | | | ------------------ | | | | 105| 2| *(obj) = (val); \ | | | | 106| 2| } | | ------------------ | | 4785| 2| } ------------------ 4823| 2| soa.retry, soa.expire, soa.minimum); 4824| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 4825| 2| } 4826| 2| } 4827| 2| dns_rdataset_disassociate(&rdataset); ------------------ | | 301| 2| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4828| | 4829| 2| result = ISC_R_SUCCESS; 4830| | 4831| 2|invalidate_rdataset: 4832| 2| SET_IF_NOT_NULL(soacount, count); ------------------ | | 104| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 2, False: 0] | | ------------------ | | 105| 2| *(obj) = (val); \ | | 106| 2| } ------------------ 4833| 2| if (count == 0) { ------------------ | Branch (4833:6): [True: 0, False: 2] ------------------ 4834| 0| CLR_SOA_VALUES(); ------------------ | | 4788| 0| { \ | | 4789| 0| SET_SOA_VALUES(0, 0, 0, 0, 0, 0); \ | | ------------------ | | | | 4778| 0| { \ | | | | 4779| 0| SET_IF_NOT_NULL(soattl, soattl_v); \ | | | | ------------------ | | | | | | 104| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 105| 0| *(obj) = (val); \ | | | | | | 106| 0| } | | | | ------------------ | | | | 4780| 0| SET_IF_NOT_NULL(serial, serial_v); \ | | | | ------------------ | | | | | | 104| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 105| 0| *(obj) = (val); \ | | | | | | 106| 0| } | | | | ------------------ | | | | 4781| 0| SET_IF_NOT_NULL(refresh, refresh_v); \ | | | | ------------------ | | | | | | 104| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 105| 0| *(obj) = (val); \ | | | | | | 106| 0| } | | | | ------------------ | | | | 4782| 0| SET_IF_NOT_NULL(retry, retry_v); \ | | | | ------------------ | | | | | | 104| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 105| 0| *(obj) = (val); \ | | | | | | 106| 0| } | | | | ------------------ | | | | 4783| 0| SET_IF_NOT_NULL(expire, expire_v); \ | | | | ------------------ | | | | | | 104| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 105| 0| *(obj) = (val); \ | | | | | | 106| 0| } | | | | ------------------ | | | | 4784| 0| SET_IF_NOT_NULL(minimum, minimum_v); \ | | | | ------------------ | | | | | | 104| 0| if ((obj) != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (104:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 105| 0| *(obj) = (val); \ | | | | | | 106| 0| } | | | | ------------------ | | | | 4785| 0| } | | ------------------ | | 4790| 0| } ------------------ 4835| 0| } 4836| | 4837| 2| dns_rdataset_invalidate(&rdataset); 4838| | 4839| 2| return result; 4840| 2|} zone.c:zone_iattach: 4930| 4|zone_iattach(dns_zone_t *source, dns_zone_t **target) { 4931| 4| REQUIRE(DNS_ZONE_VALID(source)); ------------------ | | 198| 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))) | | ------------------ ------------------ 4932| 4| REQUIRE(LOCKED_ZONE(source)); ------------------ | | 198| 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))) | | ------------------ ------------------ 4933| 4| REQUIRE(target != NULL && *target == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 4934| 4| INSIST(isc_refcount_increment0(&source->irefs) + ------------------ | | 202| 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))) | | ------------------ ------------------ 4935| 4| isc_refcount_current(&source->references) > 4936| 4| 0); 4937| 4| *target = source; 4938| 4|} zone.c:zone_idetach: 4955| 4|zone_idetach(dns_zone_t **zonep) { 4956| 4| dns_zone_t *zone; 4957| | 4958| | /* 4959| | * 'zone' locked by caller. 4960| | */ 4961| 4| REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep)); ------------------ | | 198| 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))) | | ------------------ ------------------ 4962| 4| REQUIRE(LOCKED_ZONE(*zonep)); ------------------ | | 198| 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))) | | ------------------ ------------------ 4963| | 4964| 4| zone = *zonep; 4965| 4| *zonep = NULL; 4966| | 4967| 4| INSIST(isc_refcount_decrement(&zone->irefs) - 1 + ------------------ | | 202| 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))) | | ------------------ ------------------ 4968| 4| isc_refcount_current(&zone->references) > 4969| 4| 0); 4970| 4|} zone.c:check_nsec3param: 3213| 2|check_nsec3param(dns_zone_t *zone, dns_db_t *db) { 3214| 2| bool ok = false; 3215| 2| dns_dbnode_t *node = NULL; 3216| 2| dns_dbversion_t *version = NULL; 3217| 2| dns_rdata_nsec3param_t nsec3param; 3218| 2| dns_rdataset_t rdataset; 3219| 2| isc_result_t result; 3220| 2| bool dynamic = (zone->type == dns_zone_primary) ------------------ | Branch (3220:17): [True: 2, False: 0] ------------------ 3221| 2| ? dns_zone_isdynamic(zone, false) 3222| 2| : false; 3223| | 3224| 2| dns_rdataset_init(&rdataset); 3225| 2| result = dns_db_findnode(db, &zone->origin, false, &node); ------------------ | | 767| 2| dns__db_findnode(db, name, create, NULL, NULL, nodep DNS__DB_FILELINE) ------------------ 3226| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3226:6): [True: 0, False: 2] ------------------ 3227| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3228| 0| "nsec3param lookup failure: %s", 3229| 0| isc_result_totext(result)); 3230| 0| return result; 3231| 0| } 3232| 2| dns_db_currentversion(db, &version); 3233| | 3234| 2| result = dns_db_findrdataset(db, node, version, ------------------ | | 1119| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 2| sigrdataset DNS__DB_FILELINE) ------------------ 3235| 2| dns_rdatatype_nsec3param, 3236| 2| dns_rdatatype_none, 0, &rdataset, NULL); 3237| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (3237:6): [True: 2, False: 0] ------------------ 3238| 2| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 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))) | | ------------------ ------------------ 3239| 2| result = ISC_R_SUCCESS; 3240| 2| goto cleanup; 3241| 2| } 3242| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3242:6): [True: 0, False: 0] ------------------ 3243| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 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))) | | ------------------ ------------------ 3244| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3245| 0| "nsec3param lookup failure: %s", 3246| 0| isc_result_totext(result)); 3247| 0| goto cleanup; 3248| 0| } 3249| | 3250| 0| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 262| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3251| 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| } ------------------ 3252| | 3253| 0| dns_rdataset_current(&rdataset, &rdata); 3254| 0| result = dns_rdata_tostruct(&rdata, &nsec3param, NULL); 3255| 0| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 0, False: 0] | | ------------------ ------------------ 3256| | 3257| | /* 3258| | * For dynamic zones we must support every algorithm so we 3259| | * can regenerate all the NSEC3 chains. 3260| | * For non-dynamic zones we only need to find a supported 3261| | * algorithm. 3262| | */ 3263| 0| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NSEC3TESTZONE) && ------------------ | | 174| 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 (174:31): [True: 0, False: 0] | | ------------------ ------------------ 3264| 0| nsec3param.hash == DNS_NSEC3_UNKNOWNALG && !dynamic) ------------------ | | 49| 0|#define DNS_NSEC3_UNKNOWNALG ((dns_hash_t)245U) ------------------ | Branch (3264:7): [True: 0, False: 0] | Branch (3264:50): [True: 0, False: 0] ------------------ 3265| 0| { 3266| 0| dns_zone_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3267| 0| "nsec3 test \"unknown\" hash algorithm " 3268| 0| "found: %u", 3269| 0| nsec3param.hash); 3270| 0| ok = true; 3271| 0| } else if (!dns_nsec3_supportedhash(nsec3param.hash)) { ------------------ | Branch (3271:14): [True: 0, False: 0] ------------------ 3272| 0| if (dynamic) { ------------------ | Branch (3272:8): [True: 0, False: 0] ------------------ 3273| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3274| 0| "unsupported nsec3 hash algorithm" 3275| 0| " in dynamic zone: %u", 3276| 0| nsec3param.hash); 3277| 0| result = DNS_R_BADZONE; 3278| | /* Stop second error message. */ 3279| 0| ok = true; 3280| 0| break; 3281| 0| } else { 3282| 0| dns_zone_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3283| 0| "unsupported nsec3 hash " 3284| 0| "algorithm: %u", 3285| 0| nsec3param.hash); 3286| 0| } 3287| 0| } else { 3288| 0| ok = true; 3289| 0| } 3290| | 3291| | /* 3292| | * Warn if the zone has excessive NSEC3 iterations. 3293| | */ 3294| 0| if (nsec3param.iterations > dns_nsec3_maxiterations()) { ------------------ | Branch (3294:7): [True: 0, False: 0] ------------------ 3295| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3296| 0| "excessive NSEC3PARAM iterations %u > %u", 3297| 0| nsec3param.iterations, 3298| 0| dns_nsec3_maxiterations()); 3299| 0| } 3300| 0| } 3301| | 3302| 0| if (!ok) { ------------------ | Branch (3302:6): [True: 0, False: 0] ------------------ 3303| 0| result = DNS_R_BADZONE; 3304| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3305| 0| "no supported nsec3 hash algorithm"); 3306| 0| } 3307| | 3308| 2|cleanup: 3309| 2| dns_rdataset_cleanup(&rdataset); ------------------ | | 297| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (297:6): [True: 2, Folded] | | | Branch (297:26): [True: 0, False: 2] | | ------------------ | | 298| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 299| 0| } ------------------ 3310| 2| dns_db_closeversion(db, &version, false); ------------------ | | 730| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 3311| 2| dns_db_detachnode(&node); ------------------ | | 1018| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 3312| 2| return result; 3313| 0|} zone.c:zone_namerd_tostr: 16226| 2|zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length) { 16227| 2| isc_result_t result = ISC_R_FAILURE; 16228| 2| isc_buffer_t buffer; 16229| | 16230| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 16231| 2| REQUIRE(length > 1U); ------------------ | | 198| 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))) | | ------------------ ------------------ 16232| | 16233| | /* 16234| | * Leave space for terminating '\0'. 16235| | */ 16236| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 16237| 2| if (zone->type != dns_zone_redirect && zone->type != dns_zone_key) { ------------------ | Branch (16237:6): [True: 2, False: 0] | Branch (16237:41): [True: 2, False: 0] ------------------ 16238| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (16238:7): [True: 2, False: 0] ------------------ 16239| 2| result = dns_name_totext( 16240| 2| &zone->origin, DNS_NAME_OMITFINALDOT, &buffer); ------------------ | | 883| 2|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 16241| 2| } 16242| 2| if (result != ISC_R_SUCCESS && ------------------ | Branch (16242:7): [True: 0, False: 2] ------------------ 16243| 0| isc_buffer_availablelength(&buffer) >= ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16243:7): [True: 0, False: 0] ------------------ 16244| 0| (sizeof("") - 1)) 16245| 0| { 16246| 0| isc_buffer_putstr(&buffer, ""); 16247| 0| } 16248| | 16249| 2| if (isc_buffer_availablelength(&buffer) > 0) { ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16249:7): [True: 2, False: 0] ------------------ 16250| 2| isc_buffer_putstr(&buffer, "/"); 16251| 2| } 16252| 2| (void)dns_rdataclass_totext(zone->rdclass, &buffer); 16253| 2| } 16254| | 16255| 2| if (zone->view != NULL && strcmp(zone->view->name, "_bind") != 0 && ------------------ | Branch (16255:6): [True: 2, False: 0] | Branch (16255:28): [True: 2, False: 0] ------------------ 16256| 2| strcmp(zone->view->name, "_default") != 0 && ------------------ | Branch (16256:6): [True: 2, False: 0] ------------------ 16257| 2| strlen(zone->view->name) < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16257:6): [True: 2, False: 0] ------------------ 16258| 2| { 16259| 2| isc_buffer_putstr(&buffer, "/"); 16260| 2| isc_buffer_putstr(&buffer, zone->view->name); 16261| 2| } 16262| 2| if (dns__zone_inline_secure(zone) && ------------------ | Branch (16262:6): [True: 0, False: 2] ------------------ 16263| 0| 9U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16263:6): [True: 0, False: 0] ------------------ 16264| 0| { 16265| 0| isc_buffer_putstr(&buffer, " (signed)"); 16266| 0| } 16267| 2| if (dns__zone_inline_raw(zone) && ------------------ | Branch (16267:6): [True: 0, False: 2] ------------------ 16268| 0| 11U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16268:6): [True: 0, False: 0] ------------------ 16269| 0| { 16270| 0| isc_buffer_putstr(&buffer, " (unsigned)"); 16271| 0| } 16272| | 16273| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 16274| 2|} zone.c:zone_viewname_tostr: 16277| 2|zone_viewname_tostr(dns_zone_t *zone, char *buf, size_t length) { 16278| 2| isc_buffer_t buffer; 16279| | 16280| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 16281| 2| REQUIRE(length > 1U); ------------------ | | 198| 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))) | | ------------------ ------------------ 16282| | 16283| | /* 16284| | * Leave space for terminating '\0'. 16285| | */ 16286| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 16287| | 16288| 2| if (zone->view == NULL) { ------------------ | Branch (16288:6): [True: 0, False: 2] ------------------ 16289| 0| isc_buffer_putstr(&buffer, "_none"); 16290| 2| } else if (strlen(zone->view->name) < ------------------ | Branch (16290:13): [True: 2, False: 0] ------------------ 16291| 2| isc_buffer_availablelength(&buffer)) ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 16292| 2| { 16293| 2| isc_buffer_putstr(&buffer, zone->view->name); 16294| 2| } else { 16295| 0| isc_buffer_putstr(&buffer, "_toolong"); 16296| 0| } 16297| | 16298| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 16299| 2|} zone.c:zone_count_ns_rr: 4724| 2| unsigned int *errors, bool logit) { 4725| 2| isc_result_t result; 4726| 2| unsigned int count = 0; 4727| 2| unsigned int ecount = 0; 4728| 2| dns_rdataset_t rdataset; 4729| 2| dns_rdata_ns_t ns; 4730| | 4731| 2| dns_rdataset_init(&rdataset); 4732| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_ns, ------------------ | | 1119| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 2| sigrdataset DNS__DB_FILELINE) ------------------ 4733| 2| dns_rdatatype_none, 0, &rdataset, NULL); 4734| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (4734:6): [True: 0, False: 2] ------------------ 4735| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 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))) | | ------------------ ------------------ 4736| 0| goto success; 4737| 0| } 4738| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4738:6): [True: 0, False: 2] ------------------ 4739| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 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))) | | ------------------ ------------------ 4740| 0| goto invalidate_rdataset; 4741| 0| } 4742| | 4743| 2| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 262| 2| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 2| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 4| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 2, False: 2] | | | | ------------------ | | ------------------ ------------------ 4744| 2| if (errors != NULL && zone->rdclass == dns_rdataclass_in && ------------------ | | 24| 4|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (4744:7): [True: 2, False: 0] | Branch (4744:25): [True: 2, False: 0] ------------------ 4745| 2| (zone->type == dns_zone_primary || ------------------ | Branch (4745:8): [True: 2, False: 0] ------------------ 4746| 0| zone->type == dns_zone_secondary || ------------------ | Branch (4746:8): [True: 0, False: 0] ------------------ 4747| 0| zone->type == dns_zone_mirror)) ------------------ | Branch (4747:8): [True: 0, False: 0] ------------------ 4748| 2| { 4749| 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| } ------------------ 4750| 2| dns_rdataset_current(&rdataset, &rdata); 4751| | 4752| 2| result = dns_rdata_tostruct(&rdata, &ns, NULL); 4753| 2| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 4754| 2| if (dns_name_issubdomain(&ns.name, &zone->origin) && ------------------ | Branch (4754:8): [True: 0, False: 2] ------------------ 4755| 0| !zone_check_ns(zone, db, version, &ns.name, logit)) ------------------ | Branch (4755:8): [True: 0, False: 0] ------------------ 4756| 0| { 4757| 0| ecount++; 4758| 0| } 4759| 2| } 4760| 2| count++; 4761| 2| } 4762| 2| dns_rdataset_disassociate(&rdataset); ------------------ | | 301| 2| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4763| | 4764| 2|success: 4765| 2| SET_IF_NOT_NULL(nscount, count); ------------------ | | 104| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 2, False: 0] | | ------------------ | | 105| 2| *(obj) = (val); \ | | 106| 2| } ------------------ 4766| 2| SET_IF_NOT_NULL(errors, ecount); ------------------ | | 104| 2| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 2, False: 0] | | ------------------ | | 105| 2| *(obj) = (val); \ | | 106| 2| } ------------------ 4767| | 4768| 2| result = ISC_R_SUCCESS; 4769| | 4770| 2|invalidate_rdataset: 4771| 2| dns_rdataset_invalidate(&rdataset); 4772| | 4773| 2| return result; 4774| 2|} zone.c:zone_postload: 4071| 2| isc_result_t result) { 4072| 2| unsigned int soacount = 0; 4073| 2| unsigned int nscount = 0; 4074| 2| unsigned int errors = 0; 4075| 2| uint32_t serial, oldserial, refresh, retry, expire, minimum, soattl; 4076| 2| isc_time_t now; 4077| 2| bool needdump = false; 4078| 2| bool fixjournal = false; 4079| 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) | | ------------------ ------------------ 4080| 2| bool noprimary = false; 4081| 2| bool had_db = false; 4082| 2| bool is_dynamic = false; 4083| | 4084| 2| INSIST(LOCKED_ZONE(zone)); ------------------ | | 202| 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))) | | ------------------ ------------------ 4085| 2| if (dns__zone_inline_raw(zone)) { ------------------ | Branch (4085:6): [True: 0, False: 2] ------------------ 4086| 0| INSIST(LOCKED_ZONE(zone->secure)); ------------------ | | 202| 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))) | | ------------------ ------------------ 4087| 0| } 4088| | 4089| 2| now = isc_time_now(); 4090| | 4091| | /* 4092| | * Initiate zone transfer? We may need a error code that 4093| | * indicates that the "permanent" form does not exist. 4094| | * XXX better error feedback to log. 4095| | */ 4096| 2| if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE) { ------------------ | Branch (4096:6): [True: 0, False: 2] | Branch (4096:33): [True: 0, False: 0] ------------------ 4097| 0| if (zone->type == dns_zone_secondary || ------------------ | Branch (4097:7): [True: 0, False: 0] ------------------ 4098| 0| zone->type == dns_zone_mirror || ------------------ | Branch (4098:7): [True: 0, False: 0] ------------------ 4099| 0| zone->type == dns_zone_stub || ------------------ | Branch (4099:7): [True: 0, False: 0] ------------------ 4100| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (4100:8): [True: 0, False: 0] ------------------ 4101| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (4101:8): [True: 0, False: 0] ------------------ 4102| 0| { 4103| 0| if (result == ISC_R_FILENOTFOUND) { ------------------ | Branch (4103:8): [True: 0, False: 0] ------------------ 4104| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4105| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4106| 0| "no master file"); 4107| 0| } else if (result != DNS_R_NOMASTERFILE) { ------------------ | Branch (4107:15): [True: 0, False: 0] ------------------ 4108| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4109| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4110| 0| "loading from master file %s " 4111| 0| "failed: %s", 4112| 0| zone->masterfile, 4113| 0| isc_result_totext(result)); 4114| 0| } 4115| 0| } else if (zone->type == dns_zone_primary && ------------------ | Branch (4115:14): [True: 0, False: 0] ------------------ 4116| 0| dns__zone_inline_secure(zone) && ------------------ | Branch (4116:7): [True: 0, False: 0] ------------------ 4117| 0| result == ISC_R_FILENOTFOUND) ------------------ | Branch (4117:7): [True: 0, False: 0] ------------------ 4118| 0| { 4119| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4120| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4121| 0| "no master file; secure db will be " 4122| 0| "bootstrapped from raw zone"); 4123| 0| } else { 4124| 0| int level = ISC_LOG_ERROR; ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4125| 0| if (zone->type == dns_zone_key && ------------------ | Branch (4125:8): [True: 0, False: 0] ------------------ 4126| 0| result == ISC_R_FILENOTFOUND) ------------------ | Branch (4126:8): [True: 0, False: 0] ------------------ 4127| 0| { 4128| 0| level = ISC_LOG_DEBUG(1); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4129| 0| } 4130| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, level, 4131| 0| "loading from master file %s failed: %s", 4132| 0| zone->masterfile, 4133| 0| isc_result_totext(result)); 4134| 0| noprimary = true; 4135| 0| } 4136| | 4137| 0| if (zone->type != dns_zone_key) { ------------------ | Branch (4137:7): [True: 0, False: 0] ------------------ 4138| 0| goto cleanup; 4139| 0| } 4140| 0| } 4141| | 4142| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(2), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 4143| 2| "number of nodes in database: %u", dns_db_nodecount(db)); 4144| | 4145| 2| if (result == DNS_R_SEENINCLUDE) { ------------------ | Branch (4145:6): [True: 0, False: 2] ------------------ 4146| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4147| 2| } else { 4148| 2| DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 120| 2|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4149| 2| } 4150| | 4151| | /* 4152| | * If there's no master file for a key zone, then the zone is new: 4153| | * create an SOA record. (We do this now, instead of later, so that 4154| | * if there happens to be a journal file, we can roll forward from 4155| | * a sane starting point.) 4156| | */ 4157| 2| if (noprimary && zone->type == dns_zone_key) { ------------------ | Branch (4157:6): [True: 0, False: 2] | Branch (4157:19): [True: 0, False: 0] ------------------ 4158| 0| CHECK(add_soa(zone, db)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 4159| 0| } 4160| | 4161| | /* 4162| | * Apply update log, if any, on initial load. 4163| | */ 4164| 2| if (zone->journal != NULL && ------------------ | Branch (4164:6): [True: 2, False: 0] ------------------ 4165| 2| !DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NOMERGE) && ------------------ | | 174| 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 (4165:6): [True: 2, False: 0] ------------------ 4166| 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 (4166:6): [True: 2, False: 0] ------------------ 4167| 2| { 4168| 2| CHECK(zone_journal_rollforward(zone, db, &needdump, ------------------ | | 255| 2| { \ | | 256| 2| result = (r); \ | | 257| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 2] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 2| } ------------------ 4169| 2| &fixjournal)); 4170| 2| } 4171| | 4172| | /* 4173| | * Obtain ns, soa and cname counts for top of zone. 4174| | */ 4175| 2| INSIST(db != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 4176| 2| result = zone_get_from_db(zone, db, &nscount, &soacount, &soattl, 4177| 2| &serial, &refresh, &retry, &expire, &minimum, 4178| 2| &errors); 4179| 2| if (result != ISC_R_SUCCESS && zone->type != dns_zone_key) { ------------------ | Branch (4179:6): [True: 0, False: 2] | Branch (4179:33): [True: 0, False: 0] ------------------ 4180| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4181| 0| "could not find NS and/or SOA records"); 4182| 0| } 4183| | 4184| 2| is_dynamic = dns_zone_isdynamic(zone, true); 4185| | 4186| | /* 4187| | * Check to make sure the journal is up to date, and remove the 4188| | * journal file if it isn't, as we wouldn't be able to apply 4189| | * updates otherwise. 4190| | */ 4191| 2| if (zone->journal != NULL && is_dynamic && ------------------ | Branch (4191:6): [True: 2, False: 0] | Branch (4191:31): [True: 0, False: 2] ------------------ 4192| 0| !DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS)) ------------------ | | 174| 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 (4192:6): [True: 0, False: 0] ------------------ 4193| 0| { 4194| 0| uint32_t jserial; 4195| 0| dns_journal_t *journal = NULL; 4196| 0| bool empty = false; 4197| | 4198| 0| result = dns_journal_open(zone->mctx, zone->journal, 4199| 0| DNS_JOURNAL_READ, &journal); ------------------ | | 44| 0|#define DNS_JOURNAL_READ 0x00000000 /* false */ ------------------ 4200| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4200:7): [True: 0, False: 0] ------------------ 4201| 0| jserial = dns_journal_last_serial(journal); 4202| 0| empty = dns_journal_empty(journal); 4203| 0| dns_journal_destroy(&journal); 4204| 0| } else { 4205| 0| jserial = serial; 4206| 0| result = ISC_R_SUCCESS; 4207| 0| } 4208| | 4209| 0| if (jserial != serial) { ------------------ | Branch (4209:7): [True: 0, False: 0] ------------------ 4210| 0| if (!empty) { ------------------ | Branch (4210:8): [True: 0, False: 0] ------------------ 4211| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4212| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4213| 0| "journal file is out of date: " 4214| 0| "removing journal file"); 4215| 0| } 4216| 0| if (remove(zone->journal) < 0 && errno != ENOENT) { ------------------ | Branch (4216:8): [True: 0, False: 0] | Branch (4216:37): [True: 0, False: 0] ------------------ 4217| 0| char strbuf[ISC_STRERRORSIZE]; 4218| 0| strerror_r(errno, strbuf, sizeof(strbuf)); ------------------ | | 33| 0|#define strerror_r isc_string_strerror_r ------------------ 4219| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, 4220| 0| DNS_LOGMODULE_ZONE, 4221| 0| ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4222| 0| "unable to remove journal " 4223| 0| "'%s': '%s'", 4224| 0| zone->journal, strbuf); 4225| 0| } 4226| 0| } 4227| 0| } 4228| | 4229| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 4230| 2| "loaded; checking validity"); 4231| | 4232| | /* 4233| | * Primary / Secondary / Mirror / Stub zones require both NS and SOA 4234| | * records at the top of the zone. 4235| | */ 4236| | 4237| 2| switch (zone->type) { 4238| 0| case dns_zone_dlz: ------------------ | Branch (4238:2): [True: 0, False: 2] ------------------ 4239| 2| case dns_zone_primary: ------------------ | Branch (4239:2): [True: 2, False: 0] ------------------ 4240| 2| case dns_zone_secondary: ------------------ | Branch (4240:2): [True: 0, False: 2] ------------------ 4241| 2| case dns_zone_mirror: ------------------ | Branch (4241:2): [True: 0, False: 2] ------------------ 4242| 2| case dns_zone_stub: ------------------ | Branch (4242:2): [True: 0, False: 2] ------------------ 4243| 2| case dns_zone_redirect: ------------------ | Branch (4243:2): [True: 0, False: 2] ------------------ 4244| 2| if (soacount != 1) { ------------------ | Branch (4244:7): [True: 0, False: 2] ------------------ 4245| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4246| 0| ISC_LOG_ERROR, "has %d SOA records", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4247| 0| soacount); 4248| 0| result = DNS_R_BADZONE; 4249| 0| } 4250| 2| if (nscount == 0) { ------------------ | Branch (4250:7): [True: 0, False: 2] ------------------ 4251| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4252| 0| ISC_LOG_ERROR, "has no NS records"); ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4253| 0| result = DNS_R_BADZONE; 4254| 0| } 4255| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4255:7): [True: 0, False: 2] ------------------ 4256| 0| goto cleanup; 4257| 0| } 4258| 2| if (zone->type == dns_zone_primary && errors != 0) { ------------------ | Branch (4258:7): [True: 2, False: 0] | Branch (4258:41): [True: 0, False: 2] ------------------ 4259| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4260| 0| } 4261| 2| if (zone->type != dns_zone_stub && ------------------ | Branch (4261:7): [True: 2, False: 0] ------------------ 4262| 2| zone->type != dns_zone_redirect) ------------------ | Branch (4262:7): [True: 2, False: 0] ------------------ 4263| 2| { 4264| 2| CHECK(check_nsec3param(zone, db)); ------------------ | | 255| 2| { \ | | 256| 2| result = (r); \ | | 257| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 2] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 2| } ------------------ 4265| 2| } 4266| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4266:7): [True: 2, False: 0] ------------------ 4267| 2| DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKINTEGRITY) && ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 4268| 0| !integrity_checks(zone, db)) ------------------ | Branch (4268:7): [True: 0, False: 0] ------------------ 4269| 0| { 4270| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4271| 0| } 4272| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4272:7): [True: 2, False: 0] ------------------ 4273| 2| DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKDUPRR) && ------------------ | | 174| 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 (174:31): [True: 0, False: 2] | | ------------------ ------------------ 4274| 0| !zone_check_dup(zone, db)) ------------------ | Branch (4274:7): [True: 0, False: 0] ------------------ 4275| 0| { 4276| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4277| 0| } 4278| | 4279| 2| if (zone->type == dns_zone_primary) { ------------------ | Branch (4279:7): [True: 2, False: 0] ------------------ 4280| 2| result = dns_zone_cdscheck(zone, db, NULL); 4281| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4281:8): [True: 0, False: 2] ------------------ 4282| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4283| 0| "CDS/CDNSKEY consistency checks " 4284| 0| "failed"); 4285| 0| goto cleanup; 4286| 0| } 4287| 2| } 4288| | 4289| 2| result = check_reportchannel(zone, db); 4290| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4290:7): [True: 0, False: 2] ------------------ 4291| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4292| 0| "'log-report-channel' is set, but no " 4293| 0| "'*._er/TXT' wildcard found"); 4294| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4295| 0| } 4296| | 4297| 2| CHECK(dns_zone_verifydb(zone, db, NULL)); ------------------ | | 255| 2| { \ | | 256| 2| result = (r); \ | | 257| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 2] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 2| } ------------------ 4298| | 4299| 2| if (zone->db != NULL) { ------------------ | Branch (4299:7): [True: 0, False: 2] ------------------ 4300| 0| unsigned int oldsoacount; 4301| | 4302| | /* 4303| | * This is checked in zone_replacedb() for 4304| | * secondary zones as they don't reload from disk. 4305| | */ 4306| 0| result = zone_get_from_db( 4307| 0| zone, zone->db, NULL, &oldsoacount, NULL, 4308| 0| &oldserial, NULL, NULL, NULL, NULL, NULL); 4309| 0| RUNTIME_CHECK(result == ISC_R_SUCCESS); ------------------ | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 0, False: 0] | | ------------------ ------------------ 4310| 0| RUNTIME_CHECK(oldsoacount > 0U); ------------------ | | 245| 0| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 0, False: 0] | | ------------------ ------------------ 4311| 0| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS) && ------------------ | | 174| 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 (174:31): [True: 0, False: 0] | | ------------------ ------------------ 4312| 0| !isc_serial_gt(serial, oldserial)) ------------------ | Branch (4312:8): [True: 0, False: 0] ------------------ 4313| 0| { 4314| 0| uint32_t serialmin, serialmax; 4315| | 4316| 0| INSIST(zone->type == dns_zone_primary); ------------------ | | 202| 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))) | | ------------------ ------------------ 4317| 0| INSIST(zone->raw == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 4318| | 4319| 0| if (serial == oldserial && ------------------ | Branch (4319:9): [True: 0, False: 0] ------------------ 4320| 0| zone_unchanged(zone->db, db, zone->mctx)) ------------------ | Branch (4320:9): [True: 0, False: 0] ------------------ 4321| 0| { 4322| 0| dns_zone_logc(zone, 4323| 0| DNS_LOGCATEGORY_ZONELOAD, 4324| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4325| 0| "ixfr-from-differences: " 4326| 0| "unchanged"); 4327| 0| zone->loadtime = loadtime; 4328| 0| goto done; 4329| 0| } 4330| | 4331| 0| serialmin = (oldserial + 1) & 0xffffffffU; 4332| 0| serialmax = (oldserial + 0x7fffffffU) & 4333| 0| 0xffffffffU; 4334| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4335| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4336| 0| "ixfr-from-differences: " 4337| 0| "new serial (%u) out of range " 4338| 0| "[%u - %u]", 4339| 0| serial, serialmin, serialmax); 4340| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4341| 0| } else if (!isc_serial_ge(serial, oldserial)) { ------------------ | Branch (4341:15): [True: 0, False: 0] ------------------ 4342| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4343| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4344| 0| "zone serial (%u/%u) has gone " 4345| 0| "backwards", 4346| 0| serial, oldserial); 4347| 0| } else if (serial == oldserial && !hasinclude && ------------------ | Branch (4347:15): [True: 0, False: 0] | Branch (4347:38): [True: 0, False: 0] ------------------ 4348| 0| strcmp(zone->db_argv[0], "_builtin") != 0) ------------------ | Branch (4348:8): [True: 0, False: 0] ------------------ 4349| 0| { 4350| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4351| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4352| 0| "zone serial (%u) unchanged. " 4353| 0| "zone may fail to transfer " 4354| 0| "to secondaries.", 4355| 0| serial); 4356| 0| } 4357| 0| } 4358| | 4359| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4359:7): [True: 2, False: 0] ------------------ 4360| 2| (zone->update_acl != NULL || zone->ssutable != NULL) && ------------------ | Branch (4360:8): [True: 0, False: 2] | Branch (4360:36): [True: 0, False: 2] ------------------ 4361| 0| dns_zone_getsigresigninginterval(zone) < (3 * refresh) && ------------------ | Branch (4361:7): [True: 0, False: 0] ------------------ 4362| 0| dns_db_issecure(db)) ------------------ | Branch (4362:7): [True: 0, False: 0] ------------------ 4363| 0| { 4364| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4365| 0| ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4366| 0| "sig-re-signing-interval less than " 4367| 0| "3 * refresh."); 4368| 0| } 4369| | 4370| 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] | | ------------------ ------------------ 4371| 2| zone->maxrefresh); 4372| 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] | | ------------------ ------------------ 4373| 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] | | ------------------ ------------------ 4374| 2| DNS_MAX_EXPIRE); 4375| 2| zone->soattl = soattl; 4376| 2| zone->minimum = minimum; 4377| 2| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HAVETIMERS); ------------------ | | 119| 2|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4378| | 4379| 2| if (zone->type == dns_zone_secondary || ------------------ | Branch (4379:7): [True: 0, False: 2] ------------------ 4380| 2| zone->type == dns_zone_mirror || ------------------ | Branch (4380:7): [True: 0, False: 2] ------------------ 4381| 2| zone->type == dns_zone_stub || ------------------ | Branch (4381:7): [True: 0, False: 2] ------------------ 4382| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (4382:8): [True: 0, False: 2] ------------------ 4383| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (4383:8): [True: 0, False: 0] ------------------ 4384| 0| { 4385| 0| isc_time_t t; 4386| 0| uint32_t delay; 4387| | 4388| 0| result = isc_file_getmodtime(zone->journal, &t); 4389| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4389:8): [True: 0, False: 0] ------------------ 4390| 0| result = isc_file_getmodtime(zone->masterfile, 4391| 0| &t); 4392| 0| } 4393| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4393:8): [True: 0, False: 0] ------------------ 4394| 0| DNS_ZONE_TIME_ADD(&t, zone->expire, ------------------ | | 377| 0| do { \ | | 378| 0| isc_interval_t _i; \ | | ------------------ | | | | 53| 0|#define isc_interval_t isc_time_t | | ------------------ | | 379| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 56| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 380| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (380:7): [True: 0, False: 0] | | ------------------ | | 381| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 382| 0| "epoch approaching: upgrade required: " \ | | 383| 0| "now + %s failed", \ | | 384| 0| #b); \ | | 385| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 56| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 386| 0| (void)isc_time_add((a), &_i, (c)); \ | | 387| 0| } \ | | 388| 0| } while (0) | | ------------------ | | | Branch (388:11): [Folded, False: 0] | | ------------------ ------------------ 4395| 0| &zone->expiretime); 4396| 0| } else { 4397| 0| DNS_ZONE_TIME_ADD(&now, zone->retry, ------------------ | | 377| 0| do { \ | | 378| 0| isc_interval_t _i; \ | | ------------------ | | | | 53| 0|#define isc_interval_t isc_time_t | | ------------------ | | 379| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 56| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 380| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (380:7): [True: 0, False: 0] | | ------------------ | | 381| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 382| 0| "epoch approaching: upgrade required: " \ | | 383| 0| "now + %s failed", \ | | 384| 0| #b); \ | | 385| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 56| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 386| 0| (void)isc_time_add((a), &_i, (c)); \ | | 387| 0| } \ | | 388| 0| } while (0) | | ------------------ | | | Branch (388:11): [Folded, False: 0] | | ------------------ ------------------ 4398| 0| &zone->expiretime); 4399| 0| } 4400| | 4401| 0| delay = (zone->retry - 4402| 0| isc_random_uniform((zone->retry * 3) / 4)); 4403| 0| DNS_ZONE_TIME_ADD(&now, delay, &zone->refreshtime); ------------------ | | 377| 0| do { \ | | 378| 0| isc_interval_t _i; \ | | ------------------ | | | | 53| 0|#define isc_interval_t isc_time_t | | ------------------ | | 379| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 56| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 380| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (380:7): [True: 0, False: 0] | | ------------------ | | 381| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 382| 0| "epoch approaching: upgrade required: " \ | | 383| 0| "now + %s failed", \ | | 384| 0| #b); \ | | 385| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 56| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 386| 0| (void)isc_time_add((a), &_i, (c)); \ | | 387| 0| } \ | | 388| 0| } while (0) | | ------------------ | | | Branch (388:11): [Folded, False: 0] | | ------------------ ------------------ 4404| 0| if (isc_time_compare(&zone->refreshtime, ------------------ | Branch (4404:8): [True: 0, False: 0] ------------------ 4405| 0| &zone->expiretime) >= 0) 4406| 0| { 4407| 0| DNS_ZONE_SETFLAG(zone, ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4408| 0| DNS_ZONEFLG_FIRSTREFRESH); 4409| 0| zone->refreshtime = now; 4410| 0| } else { 4411| | /* The zone is up to date. */ 4412| 0| DNS_ZONE_CLRFLAG(zone, ------------------ | | 120| 0|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4413| 0| DNS_ZONEFLG_FIRSTREFRESH); 4414| 0| } 4415| 0| } 4416| | 4417| 2| break; 4418| | 4419| 0| case dns_zone_key: ------------------ | Branch (4419:2): [True: 0, False: 2] ------------------ 4420| | /* Nothing needs to be done now */ 4421| 0| break; 4422| | 4423| 0| default: ------------------ | Branch (4423:2): [True: 0, False: 2] ------------------ 4424| 0| UNEXPECTED_ERROR("unexpected zone type %d", zone->type); ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 4425| 0| CLEANUP(ISC_R_UNEXPECTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4426| 2| } 4427| | 4428| | /* 4429| | * Check for weak DNSKEY's. 4430| | */ 4431| 2| if (zone->type == dns_zone_primary) { ------------------ | Branch (4431:6): [True: 2, False: 0] ------------------ 4432| 2| zone_check_dnskeys(zone, db); 4433| 2| } 4434| | 4435| | /* 4436| | * Schedule DNSSEC key refresh. 4437| | */ 4438| 2| if (zone->type == dns_zone_primary && zone->kasp != NULL) { ------------------ | Branch (4438:6): [True: 2, False: 0] | Branch (4438:40): [True: 0, False: 2] ------------------ 4439| 0| zone->refreshkeytime = now; 4440| 0| } 4441| | 4442| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } | | ------------------ ------------------ 4443| 2| if (zone->db != NULL) { ------------------ | Branch (4443:6): [True: 0, False: 2] ------------------ 4444| 0| had_db = true; 4445| 0| result = zone_replacedb(zone, db, false); 4446| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } | | ------------------ ------------------ 4447| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4447:7): [True: 0, False: 0] ------------------ 4448| 0| goto cleanup; 4449| 0| } 4450| 2| } else { 4451| 2| zone_attachdb(zone, db); 4452| 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(); \ | | | | | | ------------------ | | | | | | | | 206| 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| } | | ------------------ ------------------ 4453| 2| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADED | ------------------ | | 119| 2|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4454| 2| DNS_ZONEFLG_NEEDSTARTUPNOTIFY); 4455| 2| if (dns__zone_inline_raw(zone)) { ------------------ | Branch (4455:7): [True: 0, False: 2] ------------------ 4456| 0| zone_schedule_inline_sync(zone->secure, 4457| 0| inline_sync_incremental); 4458| 0| } 4459| 2| } 4460| | 4461| 2| result = ISC_R_SUCCESS; 4462| | 4463| 2| if (fixjournal) { ------------------ | Branch (4463:6): [True: 0, False: 2] ------------------ 4464| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIXJOURNAL); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4465| 0| zone_journal_compact(zone, zone->db, 0); 4466| 0| } 4467| 2| if (needdump) { ------------------ | Branch (4467:6): [True: 0, False: 2] ------------------ 4468| 0| if (zone->type == dns_zone_key) { ------------------ | Branch (4468:7): [True: 0, False: 0] ------------------ 4469| 0| zone_needdump(zone, 30); 4470| 0| } else { 4471| 0| zone_needdump(zone, DNS_DUMP_DELAY); ------------------ | | 63| 0|#define DNS_DUMP_DELAY 900 /*%< 15 minutes */ ------------------ 4472| 0| } 4473| 0| } 4474| | 4475| 2| if (zone->loop != NULL) { ------------------ | Branch (4475:6): [True: 0, False: 2] ------------------ 4476| 0| if (zone->type == dns_zone_primary) { ------------------ | Branch (4476:7): [True: 0, False: 0] ------------------ 4477| 0| dns__zone_set_resigntime(zone); 4478| 0| resume_signingwithkey(zone); 4479| 0| resume_addnsec3chain(zone); 4480| 0| } 4481| | 4482| 0| is_dynamic = dns_zone_isdynamic(zone, false); 4483| 0| if (zone->type == dns_zone_primary && is_dynamic && ------------------ | Branch (4483:7): [True: 0, False: 0] | Branch (4483:41): [True: 0, False: 0] ------------------ 4484| 0| dns_db_issecure(db) && !dns__zone_inline_raw(zone)) ------------------ | Branch (4484:7): [True: 0, False: 0] | Branch (4484:30): [True: 0, False: 0] ------------------ 4485| 0| { 4486| 0| isc_stdtime_t resign; 4487| 0| dns_name_t *name; 4488| 0| dns_fixedname_t fixed; 4489| 0| dns_typepair_t typepair; 4490| | 4491| 0| name = dns_fixedname_initname(&fixed); 4492| | 4493| 0| result = dns_db_getsigningtime(db, &resign, name, 4494| 0| &typepair); 4495| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4495:8): [True: 0, False: 0] ------------------ 4496| 0| isc_stdtime_t timenow = isc_stdtime_now(); 4497| 0| char namebuf[DNS_NAME_FORMATSIZE]; 4498| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 4499| | 4500| 0| dns_name_format(name, namebuf, sizeof(namebuf)); 4501| 0| dns_rdatatype_format( 4502| 0| DNS_TYPEPAIR_COVERS(typepair), typebuf, ------------------ | | 36| 0| ({ \ | | 37| 0| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 38| 0| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 39| 0| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 0|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 40| 0| __covers; \ | | 41| 0| }) ------------------ 4503| 0| sizeof(typebuf)); 4504| 0| dnssec_log( 4505| 0| zone, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4506| 0| "next resign: %s/%s " 4507| 0| "in %d seconds", 4508| 0| namebuf, typebuf, 4509| 0| resign - timenow - 4510| 0| dns_zone_getsigresigninginterval( 4511| 0| zone)); 4512| 0| } else { 4513| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4514| 0| "signed dynamic zone has no " 4515| 0| "resign event scheduled"); 4516| 0| } 4517| 0| } 4518| | 4519| 0| dns__zone_settimer(zone, now); 4520| 0| } 4521| | 4522| | /* 4523| | * Clear old include list. 4524| | */ 4525| 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] | | ------------------ ------------------ 4526| 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] | | | | ------------------ | | ------------------ ------------------ 4527| 0| isc_mem_free(zone->mctx, inc->name); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 4528| 0| isc_mem_put(zone->mctx, inc, sizeof(*inc)); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 4529| 0| } 4530| 2| zone->nincludes = 0; 4531| | 4532| | /* 4533| | * Transfer new include list. 4534| | */ 4535| 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] | | ------------------ ------------------ 4536| 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] | | | | ------------------ | | ------------------ ------------------ 4537| 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] | | ------------------ ------------------ 4538| 0| zone->nincludes++; 4539| 0| } 4540| | 4541| 2| if (!dns_db_ispersistent(db)) { ------------------ | Branch (4541:6): [True: 2, False: 0] ------------------ 4542| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 2|#define ISC_LOG_INFO (-1) ------------------ 4543| 2| "loaded serial %u%s", serial, 4544| 2| dns_db_issecure(db) ? " (DNSSEC signed)" : ""); ------------------ | Branch (4544:10): [True: 0, False: 2] ------------------ 4545| 2| } 4546| | 4547| 2| if (!had_db && zone->type == dns_zone_mirror) { ------------------ | Branch (4547:6): [True: 2, False: 0] | Branch (4547:17): [True: 0, False: 2] ------------------ 4548| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4549| 0| "mirror zone is now in use"); 4550| 0| } 4551| | 4552| 2| zone->loadtime = loadtime; 4553| 2| goto done; 4554| | 4555| 0|cleanup: 4556| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4556:6): [True: 0, False: 0] ------------------ 4557| 0| dns_zone_rpz_disable_db(zone, db); 4558| 0| dns_zone_catz_disable_db(zone, db); 4559| 0| } 4560| | 4561| 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] | | ------------------ ------------------ 4562| 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] | | | | ------------------ | | ------------------ ------------------ 4563| 0| isc_mem_free(zone->mctx, inc->name); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 4564| 0| isc_mem_put(zone->mctx, inc, sizeof(*inc)); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 4565| 0| } 4566| 0| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (4566:6): [True: 0, False: 0] | Branch (4566:42): [True: 0, False: 0] ------------------ 4567| 0| zone->type == dns_zone_stub || zone->type == dns_zone_key || ------------------ | Branch (4567:6): [True: 0, False: 0] | Branch (4567:37): [True: 0, False: 0] ------------------ 4568| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (4568:7): [True: 0, False: 0] ------------------ 4569| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (4569:7): [True: 0, False: 0] ------------------ 4570| 0| { 4571| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIRSTREFRESH); ------------------ | | 119| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4572| | 4573| 0| if (zone->journal != NULL) { ------------------ | Branch (4573:7): [True: 0, False: 0] ------------------ 4574| 0| zone_saveunique(zone, zone->journal, "jn-XXXXXXXX"); 4575| 0| } 4576| 0| if (zone->masterfile != NULL) { ------------------ | Branch (4576:7): [True: 0, False: 0] ------------------ 4577| 0| zone_saveunique(zone, zone->masterfile, "db-XXXXXXXX"); 4578| 0| } 4579| | 4580| | /* Mark the zone for immediate refresh. */ 4581| 0| zone->refreshtime = now; 4582| 0| if (zone->loop != NULL) { ------------------ | Branch (4582:7): [True: 0, False: 0] ------------------ 4583| 0| dns__zone_settimer(zone, now); 4584| 0| } 4585| 0| result = ISC_R_SUCCESS; 4586| 0| } else if (zone->type == dns_zone_primary || ------------------ | Branch (4586:13): [True: 0, False: 0] ------------------ 4587| 0| zone->type == dns_zone_redirect) ------------------ | Branch (4587:6): [True: 0, False: 0] ------------------ 4588| 0| { 4589| 0| if (!(dns__zone_inline_secure(zone) && ------------------ | Branch (4589:9): [True: 0, False: 0] ------------------ 4590| 0| result == ISC_R_FILENOTFOUND)) ------------------ | Branch (4590:9): [True: 0, False: 0] ------------------ 4591| 0| { 4592| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4593| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4594| 0| "not loaded due to errors."); 4595| 0| } else if (zone->type == dns_zone_primary) { ------------------ | Branch (4595:14): [True: 0, False: 0] ------------------ 4596| 0| result = ISC_R_SUCCESS; 4597| 0| } 4598| 0| } 4599| | 4600| 2|done: 4601| 2| DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_LOADPENDING); ------------------ | | 120| 2|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4602| | /* 4603| | * If this is an inline-signed zone and we were called for the raw 4604| | * zone, we need to clear DNS_ZONEFLG_LOADPENDING for the secure zone 4605| | * as well, but only if this is a reload, not an initial zone load: in 4606| | * the former case, zone_postload() will not be run for the secure 4607| | * zone; in the latter case, it will be. Check which case we are 4608| | * dealing with by consulting the DNS_ZONEFLG_LOADED flag for the 4609| | * secure zone: if it is set, this must be a reload. 4610| | */ 4611| 2| if (dns__zone_inline_raw(zone) && ------------------ | Branch (4611:6): [True: 0, False: 2] ------------------ 4612| 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] | | ------------------ ------------------ 4613| 0| { 4614| 0| DNS_ZONE_CLRFLAG(zone->secure, DNS_ZONEFLG_LOADPENDING); ------------------ | | 120| 0|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4615| | /* 4616| | * Re-start zone maintenance if it had been stalled 4617| | * due to DNS_ZONEFLG_LOADPENDING being set when 4618| | * zone_maintenance was called. 4619| | */ 4620| 0| if (zone->secure->loop != NULL) { ------------------ | Branch (4620:7): [True: 0, False: 0] ------------------ 4621| 0| dns__zone_settimer(zone->secure, now); 4622| 0| } 4623| 0| } 4624| | 4625| 2| zone_debuglog(zone, __func__, 99, "done"); 4626| | 4627| 2| return result; 4628| 0|} zone.c:zone_journal_rollforward: 10356| 2| bool *fixjournal) { 10357| 2| dns_journal_t *journal = NULL; 10358| 2| unsigned int options; 10359| 2| isc_result_t result; 10360| | 10361| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (10361:6): [True: 2, False: 0] ------------------ 10362| 2| (dns__zone_inline_secure(zone) || ------------------ | Branch (10362:7): [True: 0, False: 2] ------------------ 10363| 2| (zone->update_acl != NULL || zone->ssutable != NULL))) ------------------ | Branch (10363:8): [True: 0, False: 2] | Branch (10363:36): [True: 0, False: 2] ------------------ 10364| 0| { 10365| 0| options = DNS_JOURNALOPT_RESIGN; ------------------ | | 42| 0|#define DNS_JOURNALOPT_RESIGN 0x00000001 ------------------ 10366| 2| } else { 10367| 2| options = 0; 10368| 2| } 10369| | 10370| 2| result = dns_journal_open(zone->mctx, zone->journal, DNS_JOURNAL_READ, ------------------ | | 44| 2|#define DNS_JOURNAL_READ 0x00000000 /* false */ ------------------ 10371| 2| &journal); 10372| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (10372:6): [True: 2, False: 0] ------------------ 10373| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(3), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 10374| 2| "no journal file, but that's OK "); 10375| 2| return ISC_R_SUCCESS; 10376| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (10376:13): [True: 0, False: 0] ------------------ 10377| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10378| 0| "journal open failed: %s", 10379| 0| isc_result_totext(result)); 10380| 0| return result; 10381| 0| } 10382| | 10383| 0| if (dns_journal_empty(journal)) { ------------------ | Branch (10383:6): [True: 0, False: 0] ------------------ 10384| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10385| 0| "journal empty"); 10386| 0| dns_journal_destroy(&journal); 10387| 0| return ISC_R_SUCCESS; 10388| 0| } 10389| | 10390| 0| result = dns_journal_rollforward(journal, db, options); 10391| 0| switch (result) { 10392| 0| case ISC_R_SUCCESS: ------------------ | Branch (10392:2): [True: 0, False: 0] ------------------ 10393| 0| *needdump = true; 10394| 0| FALLTHROUGH; ------------------ | | 101| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 10395| 0| case DNS_R_UPTODATE: ------------------ | Branch (10395:2): [True: 0, False: 0] ------------------ 10396| 0| if (dns_journal_recovered(journal)) { ------------------ | Branch (10396:7): [True: 0, False: 0] ------------------ 10397| 0| *fixjournal = true; 10398| 0| dns_zone_logc( 10399| 0| zone, DNS_LOGCATEGORY_ZONELOAD, 10400| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10401| 0| "journal rollforward completed successfully " 10402| 0| "using old journal format: %s", 10403| 0| isc_result_totext(result)); 10404| 0| } else { 10405| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 10406| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10407| 0| "journal rollforward completed " 10408| 0| "successfully: %s", 10409| 0| isc_result_totext(result)); 10410| 0| } 10411| | 10412| 0| dns_journal_destroy(&journal); 10413| 0| return ISC_R_SUCCESS; 10414| 0| case ISC_R_NOTFOUND: ------------------ | Branch (10414:2): [True: 0, False: 0] ------------------ 10415| 0| case ISC_R_RANGE: ------------------ | Branch (10415:2): [True: 0, False: 0] ------------------ 10416| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10417| 0| "journal rollforward failed: journal out of sync " 10418| 0| "with zone"); 10419| 0| dns_journal_destroy(&journal); 10420| 0| return result; 10421| 0| default: ------------------ | Branch (10421:2): [True: 0, False: 0] ------------------ 10422| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10423| 0| "journal rollforward failed: %s", 10424| 0| isc_result_totext(result)); 10425| 0| dns_journal_destroy(&journal); 10426| 0| return result; 10427| 0| } 10428| 0|} zone.c:check_reportchannel: 4029| 2|check_reportchannel(dns_zone_t *zone, dns_db_t *db) { 4030| 2| isc_result_t result; 4031| 2| dns_rdataset_t rdataset = DNS_RDATASET_INIT; ------------------ | | 244| 2| { \ | | 245| 2| .magic = DNS_RDATASET_MAGIC, \ | | ------------------ | | | | 88| 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)) | | | | ------------------ | | ------------------ | | 246| 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| } | | | | ------------------ | | ------------------ | | 247| 2| } ------------------ 4032| 2| dns_dbnode_t *node = NULL; 4033| 2| dns_dbversion_t *version = NULL; 4034| 2| dns_fixedname_t fixed; 4035| 2| dns_name_t *name = NULL; 4036| | 4037| | /* 4038| | * If this zone isn't logging reports, it's fine. 4039| | */ 4040| 2| if (!DNS_ZONE_OPTION(zone, DNS_ZONEOPT_LOGREPORTS)) { ------------------ | | 174| 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 (4040:6): [True: 2, False: 0] ------------------ 4041| 2| return ISC_R_SUCCESS; 4042| 2| } 4043| | 4044| | /* 4045| | * Otherwise, we need a '*._er' wildcard with a TXT rdataset. 4046| | */ 4047| 0| name = dns_fixedname_initname(&fixed); 4048| 0| CHECK(dns_name_concatenate(&er, &zone->origin, name)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 4049| 0| CHECK(dns_db_findnode(db, name, false, &node)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 4050| | 4051| 0| dns_db_currentversion(db, &version); 4052| | 4053| 0| result = dns_db_findrdataset(db, node, version, dns_rdatatype_txt, ------------------ | | 1119| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1120| 0| sigrdataset DNS__DB_FILELINE) ------------------ 4054| 0| dns_rdatatype_none, 0, &rdataset, NULL); 4055| 0| dns_db_closeversion(db, &version, false); ------------------ | | 730| 0| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 4056| 0| dns_db_detachnode(&node); ------------------ | | 1018| 0|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 4057| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4057:6): [True: 0, False: 0] ------------------ 4058| 0| dns_rdataset_disassociate(&rdataset); ------------------ | | 301| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4059| 0| } 4060| | 4061| 0|cleanup: 4062| 0| return result; 4063| 0|} zone.c:zone_check_dnskeys: 2712| 2|zone_check_dnskeys(dns_zone_t *zone, dns_db_t *db) { 2713| 2| dns_dbnode_t *node = NULL; 2714| 2| dns_dbversion_t *version = NULL; 2715| 2| dns_rdata_dnskey_t dnskey; 2716| 2| dns_rdataset_t rdataset; 2717| 2| isc_result_t result; 2718| 2| bool logged_algorithm[DST_MAX_ALGS] = { 0 }; 2719| 2| bool alldeprecated = true; 2720| | 2721| 2| CHECK(dns_db_findnode(db, &zone->origin, false, &node)); ------------------ | | 255| 2| { \ | | 256| 2| result = (r); \ | | 257| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 2] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 2| } ------------------ 2722| | 2723| 2| dns_db_currentversion(db, &version); 2724| 2| dns_rdataset_init(&rdataset); 2725| 2| CHECK(dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, ------------------ | | 255| 2| { \ | | 256| 2| result = (r); \ | | 257| 2| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 2, False: 0] | | ------------------ | | 258| 2| goto cleanup; \ | | 259| 2| } \ | | 260| 2| } ------------------ 2726| 2| dns_rdatatype_none, 0, &rdataset, NULL)); 2727| | 2728| 0| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 262| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 259| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 260| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (260:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2729| 0| char algbuf[DNS_SECALG_FORMATSIZE]; 2730| 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| } ------------------ 2731| 0| dns_rdataset_current(&rdataset, &rdata); 2732| 0| result = dns_rdata_tostruct(&rdata, &dnskey, NULL); 2733| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 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))) | | ------------------ ------------------ 2734| | 2735| | /* 2736| | * RFC 3110, section 4: Performance Considerations: 2737| | * 2738| | * A public exponent of 3 minimizes the effort needed to verify 2739| | * a signature. Use of 3 as the public exponent is weak for 2740| | * confidentiality uses since, if the same data can be collected 2741| | * encrypted under three different keys with an exponent of 3 2742| | * then, using the Chinese Remainder Theorem [NETSEC], the 2743| | * original plain text can be easily recovered. If a key is 2744| | * known to be used only for authentication, as is the case with 2745| | * DNSSEC, then an exponent of 3 is acceptable. However other 2746| | * applications in the future may wish to leverage DNS 2747| | * distributed keys for applications that do require 2748| | * confidentiality. For keys which might have such other uses, 2749| | * a more conservative choice would be 65537 (F4, the fourth 2750| | * fermat number). 2751| | */ 2752| 0| if (dnskey.datalen > 1 && dnskey.data[0] == 1 && ------------------ | Branch (2752:7): [True: 0, False: 0] | Branch (2752:29): [True: 0, False: 0] ------------------ 2753| 0| dnskey.data[1] == 3 && ------------------ | Branch (2753:7): [True: 0, False: 0] ------------------ 2754| 0| (dnskey.algorithm == DNS_KEYALG_RSAMD5 || ------------------ | Branch (2754:8): [True: 0, False: 0] ------------------ 2755| 0| dnskey.algorithm == DNS_KEYALG_RSASHA1 || ------------------ | Branch (2755:8): [True: 0, False: 0] ------------------ 2756| 0| dnskey.algorithm == DNS_KEYALG_NSEC3RSASHA1 || ------------------ | Branch (2756:8): [True: 0, False: 0] ------------------ 2757| 0| dnskey.algorithm == DNS_KEYALG_RSASHA256 || ------------------ | Branch (2757:8): [True: 0, False: 0] ------------------ 2758| 0| dnskey.algorithm == DNS_KEYALG_RSASHA512)) ------------------ | Branch (2758:8): [True: 0, False: 0] ------------------ 2759| 0| { 2760| 0| char algorithm[DNS_SECALG_FORMATSIZE]; 2761| 0| isc_region_t r; 2762| | 2763| 0| dns_rdata_toregion(&rdata, &r); 2764| 0| dns_secalg_format(dnskey.algorithm, algorithm, 2765| 0| sizeof(algorithm)); 2766| | 2767| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2768| 0| "weak %s (%u) key found (exponent=3, id=%u)", 2769| 0| algorithm, dnskey.algorithm, 2770| 0| dst_region_computeid(&r)); 2771| 0| } 2772| 0| switch (dnskey.algorithm) { 2773| 0| case DNS_KEYALG_RSAMD5: ------------------ | Branch (2773:3): [True: 0, False: 0] ------------------ 2774| 0| case DNS_KEYALG_DSA: ------------------ | Branch (2774:3): [True: 0, False: 0] ------------------ 2775| 0| case DNS_KEYALG_RSASHA1: ------------------ | Branch (2775:3): [True: 0, False: 0] ------------------ 2776| 0| case DNS_KEYALG_NSEC3DSA: ------------------ | Branch (2776:3): [True: 0, False: 0] ------------------ 2777| 0| case DNS_KEYALG_NSEC3RSASHA1: ------------------ | Branch (2777:3): [True: 0, False: 0] ------------------ 2778| 0| case DNS_KEYALG_ECCGOST: ------------------ | Branch (2778:3): [True: 0, False: 0] ------------------ 2779| 0| if (!logged_algorithm[dnskey.algorithm]) { ------------------ | Branch (2779:8): [True: 0, False: 0] ------------------ 2780| 0| dns_secalg_format(dnskey.algorithm, algbuf, 2781| 0| sizeof(algbuf)); 2782| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2783| 0| "deprecated DNSKEY algorithm found: " 2784| 0| "%u (%s)\n", 2785| 0| dnskey.algorithm, algbuf); 2786| 0| logged_algorithm[dnskey.algorithm] = true; 2787| 0| } 2788| 0| break; 2789| 0| default: ------------------ | Branch (2789:3): [True: 0, False: 0] ------------------ 2790| 0| alldeprecated = false; 2791| 0| break; 2792| 0| } 2793| 0| } 2794| 0| dns_rdataset_disassociate(&rdataset); ------------------ | | 301| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 2795| | 2796| 0| if (alldeprecated) { ------------------ | Branch (2796:6): [True: 0, False: 0] ------------------ 2797| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2798| 0| "all DNSKEY algorithms found are deprecated"); 2799| 0| } 2800| | 2801| 2|cleanup: 2802| 2| if (node != NULL) { ------------------ | Branch (2802:6): [True: 2, False: 0] ------------------ 2803| 2| dns_db_detachnode(&node); ------------------ | | 1018| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 2804| 2| } 2805| 2| if (version != NULL) { ------------------ | Branch (2805:6): [True: 2, False: 0] ------------------ 2806| 2| dns_db_closeversion(db, &version, false); ------------------ | | 730| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 2807| 2| } 2808| 2|} zone.c:zone_debuglog: 13675| 6| ...) { 13676| 6| int level = ISC_LOG_DEBUG(debuglevel); ------------------ | | 36| 6|#define ISC_LOG_DEBUG(level) (level) ------------------ 13677| 6| va_list ap; 13678| | 13679| 6| va_start(ap, fmt); 13680| 6| dns_zone_logv(zone, DNS_LOGCATEGORY_GENERAL, level, me, fmt, ap); 13681| | va_end(ap); 13682| 6|} dns_zone_setclass: 52| 2|dns_zone_setclass(dns_zone_t *zone, dns_rdataclass_t rdclass) { 53| 2| char namebuf[1024]; 54| | 55| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 56| 2| REQUIRE(rdclass != dns_rdataclass_none); ------------------ | | 198| 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| | 58| | /* 59| | * Test and set. 60| | */ 61| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 62| 2| INSIST(zone != zone->raw); ------------------ | | 202| 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))) | | ------------------ ------------------ 63| 2| REQUIRE(zone->rdclass == dns_rdataclass_none || ------------------ | | 198| 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))) | | ------------------ ------------------ 64| 2| zone->rdclass == rdclass); 65| 2| zone->rdclass = rdclass; 66| | 67| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (67:6): [True: 2, False: 0] ------------------ 68| 2| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 197| 2| do { \ | | 198| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 2| (p) = NULL; \ | | 200| 2| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 2] | | ------------------ ------------------ 69| 2| } 70| 2| if (zone->strrdclass != NULL) { ------------------ | Branch (70:6): [True: 0, False: 2] ------------------ 71| 0| isc_mem_free(zone->mctx, zone->strrdclass); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 72| 0| } 73| | 74| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 75| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 76| 2| zone_rdclass_tostr(zone, namebuf, sizeof namebuf); 77| 2| zone->strrdclass = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 78| | 79| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (79:6): [True: 0, False: 2] ------------------ 80| 0| dns_zone_setclass(zone->raw, rdclass); 81| 0| } 82| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 83| 2|} dns_zone_settype: 126| 2|dns_zone_settype(dns_zone_t *zone, dns_zonetype_t type) { 127| 2| char namebuf[1024]; 128| | 129| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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(type != dns_zone_none); ------------------ | | 198| 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| | /* 133| | * Test and set. 134| | */ 135| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 136| 2| REQUIRE(zone->type == dns_zone_none || zone->type == type); ------------------ | | 198| 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))) | | ------------------ ------------------ 137| 2| zone->type = type; 138| | 139| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (139:6): [True: 2, False: 0] ------------------ 140| 2| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 197| 2| do { \ | | 198| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 2| (p) = NULL; \ | | 200| 2| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 2] | | ------------------ ------------------ 141| 2| } 142| | 143| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 144| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 145| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 146| 2|} dns_zone_setdbtype: 182| 2| const char *const *dbargv) { 183| 2| char **argv = NULL; 184| 2| unsigned int i; 185| | 186| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 187| 2| REQUIRE(dbargc >= 1); ------------------ | | 198| 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| 2| REQUIRE(dbargv != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 189| | 190| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 191| | 192| | /* Set up a new database argument list. */ 193| 2| argv = isc_mem_cget(zone->mctx, dbargc, sizeof(*argv)); ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 194| 4| for (i = 0; i < dbargc; i++) { ------------------ | Branch (194:14): [True: 2, False: 2] ------------------ 195| 2| argv[i] = NULL; 196| 2| } 197| 4| for (i = 0; i < dbargc; i++) { ------------------ | Branch (197:14): [True: 2, False: 2] ------------------ 198| 2| argv[i] = isc_mem_strdup(zone->mctx, dbargv[i]); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 199| 2| } 200| | 201| | /* Free the old list. */ 202| 2| dns__zone_freedbargs(zone); 203| | 204| 2| zone->db_argc = dbargc; 205| 2| zone->db_argv = argv; 206| | 207| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 208| 2|} dns_zone_setview: 211| 2|dns_zone_setview(dns_zone_t *zone, dns_view_t *view) { 212| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 213| | 214| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 215| 2| dns__zone_setview_helper(zone, view); 216| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 217| 2|} dns_zone_setorigin: 227| 2|dns_zone_setorigin(dns_zone_t *zone, const dns_name_t *origin) { 228| 2| char namebuf[1024]; 229| | 230| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 231| 2| REQUIRE(origin != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 232| | 233| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 234| 2| INSIST(zone != zone->raw); ------------------ | | 202| 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))) | | ------------------ ------------------ 235| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (235:6): [True: 0, False: 2] ------------------ 236| 0| dns_name_free(&zone->origin, zone->mctx); 237| 0| dns_name_init(&zone->origin); 238| 0| } 239| 2| dns_name_dup(origin, zone->mctx, &zone->origin); 240| | 241| 2| if (zone->strnamerd != NULL) { ------------------ | Branch (241:6): [True: 0, False: 2] ------------------ 242| 0| isc_mem_free(zone->mctx, zone->strnamerd); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 243| 0| } 244| 2| if (zone->strname != NULL) { ------------------ | Branch (244:6): [True: 0, False: 2] ------------------ 245| 0| isc_mem_free(zone->mctx, zone->strname); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 246| 0| } 247| | 248| 2| zone_namerd_tostr(zone, namebuf, sizeof namebuf); 249| 2| zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 250| 2| zone_name_tostr(zone, namebuf, sizeof namebuf); 251| 2| zone->strname = isc_mem_strdup(zone->mctx, namebuf); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 252| | 253| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (253:6): [True: 0, False: 2] ------------------ 254| 0| dns_zone_setorigin(zone->raw, origin); 255| 0| } 256| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 257| 2|} dns_zone_expandzonefile: 439| 2| const char *typename) { 440| 2| isc_result_t result; 441| 2| foundtoken_t founds[ARRAY_SIZE(tokens)]; 442| 2| dns_fixedname_t fz; 443| 2| size_t tags = 0; 444| 2| token_names_t names = { .zonename = dns_fixedname_initname(&fz), 445| 2| .viewname = viewname, 446| 2| .typename = typename }; 447| | 448| 2| REQUIRE(zonename != NULL); ------------------ | | 198| 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(filename != NULL); ------------------ | | 198| 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| 2| REQUIRE(typename != NULL); ------------------ | | 198| 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| | 452| 2| if (viewname == NULL) { ------------------ | Branch (452:6): [True: 2, False: 0] ------------------ 453| 2| names.viewname = ""; 454| 2| } 455| | 456| | /* Normalize the name by converting to lower case */ 457| 2| result = dns_name_downcase(zonename, names.zonename); 458| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 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| | 460| 38| for (size_t i = 0; i < ARRAY_SIZE(tokens); i++) { ------------------ | | 98| 38|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (460:21): [True: 36, False: 2] ------------------ 461| 36| const token_t *token = &tokens[i]; 462| 36| const char *p = strcasestr(filename, token->name); 463| | 464| 36| if (p != NULL) { ------------------ | Branch (464:7): [True: 0, False: 36] ------------------ 465| 0| founds[tags++] = 466| 0| (foundtoken_t){ .pos = p, 467| 0| .len = strlen(token->name), 468| 0| .parse = token->parse }; 469| 0| } 470| 36| } 471| | 472| 2| if (tags == 0) { ------------------ | Branch (472:6): [True: 2, False: 0] ------------------ 473| 2| putmem(b, filename, strlen(filename)); 474| 2| goto cleanup; 475| 2| } 476| | 477| | /* sort the tag offsets in order of occurrence */ 478| 0| qsort(founds, tags, sizeof(foundtoken_t), foundtoken_order); 479| | 480| 0| const char *p = filename; 481| 0| for (size_t i = 0; i < tags; i++) { ------------------ | Branch (481:21): [True: 0, False: 0] ------------------ 482| 0| foundtoken_t *token = &founds[i]; 483| | 484| 0| CHECK(putmem(b, p, token->pos - p)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 485| | 486| 0| p = token->pos; 487| 0| INSIST(p != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 488| 0| CHECK(token->parse(&names, token, b)); ------------------ | | 255| 0| { \ | | 256| 0| result = (r); \ | | 257| 0| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 0] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 0| } ------------------ 489| | 490| | /* Advance the input pointer past the token */ 491| 0| p += founds[i].len; 492| 0| } 493| | 494| 0| const char *end = filename + strlen(filename); 495| 0| putmem(b, p, end - p); 496| | 497| 2|cleanup: 498| 2| isc_buffer_putuint8(b, 0); 499| 2|} dns_zone_setfile: 520| 2| dns_masterformat_t format, const dns_master_style_t *style) { 521| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 522| 2| REQUIRE(zone->stream == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 523| | 524| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 525| 2| setfilename(zone, &zone->masterfile, file); 526| 2| setstring(zone, &zone->initfile, initial_file); 527| 2| zone->masterformat = format; 528| 2| if (format == dns_masterformat_text) { ------------------ | Branch (528:6): [True: 2, False: 0] ------------------ 529| 2| zone->masterstyle = style; 530| 2| } 531| 2| default_journal(zone); 532| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 533| 2|} dns_zone_getdb: 929| 200|dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) { 930| 200| isc_result_t result = ISC_R_SUCCESS; 931| | 932| 200| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 933| | 934| 200| ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read); ------------------ | | 112| 200|#define ZONEDB_LOCK(l, t) RWLOCK((l), (t)) | | ------------------ | | | | 30| 200| { \ | | | | 31| 200| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | 32| 200| (t), __FILE__, __LINE__)); \ | | | | 33| 200| isc_rwlock_lock((lp), (t)); \ | | | | ------------------ | | | | | | 252| 200| { \ | | | | | | 253| 200| switch (type) { \ | | | | | | 254| 200| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (254:3): [True: 200, False: 0] | | | | | | ------------------ | | | | | | 255| 200| isc_rwlock_rdlock(rwl); \ | | | | | | 256| 200| break; \ | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (257:3): [True: 0, False: 200] | | | | | | ------------------ | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | 259| 0| break; \ | | | | | | 260| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (260:3): [True: 0, False: 200] | | | | | | ------------------ | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 262| 200| } \ | | | | | | 263| 200| } | | | | ------------------ | | | | 34| 200| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | 35| 200| (lp), (t), __FILE__, __LINE__)); \ | | | | 36| 200| } | | ------------------ ------------------ 935| 200| if (zone->db == NULL) { ------------------ | Branch (935:6): [True: 0, False: 200] ------------------ 936| 0| result = DNS_R_NOTLOADED; 937| 200| } else { 938| 200| dns_db_attach(zone->db, dpb); 939| 200| } 940| 200| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read); ------------------ | | 113| 200|#define ZONEDB_UNLOCK(l, t) RWUNLOCK((l), (t)) | | ------------------ | | | | 38| 200| { \ | | | | 39| 200| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 200| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 200| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 200| { \ | | | | | | 283| 200| switch (type) { \ | | | | | | 284| 200| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 200, False: 0] | | | | | | ------------------ | | | | | | 285| 200| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 200| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 200] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 200] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 67| 0| "unreachable"), \ | | | | | | | | | | 68| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 200| } \ | | | | | | 293| 200| } | | | | ------------------ | | | | 42| 200| } | | ------------------ ------------------ 941| | 942| 200| return result; 943| 200|} dns_zone_gettype: 1404| 602|dns_zone_gettype(dns_zone_t *zone) { 1405| 602| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 602|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 602, False: 0] | | | | | Branch (42:11): [True: 602, False: 0] | | | | ------------------ | | | | 43| 602| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1406| | 1407| 602| return zone->type; 1408| 602|} dns_zone_getorigin: 1411| 426|dns_zone_getorigin(dns_zone_t *zone) { 1412| 426| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 426|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 852| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 426, False: 0] | | | | | Branch (42:11): [True: 426, False: 0] | | | | ------------------ | | | | 43| 426| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1413| | 1414| 426| return &zone->origin; 1415| 426|} dns_zone_setkeydirectory: 1655| 2|dns_zone_setkeydirectory(dns_zone_t *zone, const char *directory) { 1656| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1657| | 1658| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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); \ | | ------------------ | | | | 202| 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] | | ------------------ ------------------ 1659| 2| setstring(zone, &zone->keydirectory, directory); 1660| | UNLOCK_ZONE(zone); ------------------ | | 86| 2| do { \ | | 87| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 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] | | ------------------ ------------------ 1661| 2|} zoneproperties.c:putmem: 301| 2|putmem(isc_buffer_t *b, const char *base, size_t length) { 302| 2| size_t space = isc_buffer_availablelength(b) - 1; ------------------ | | 161| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 303| 2| if (space < length) { ------------------ | Branch (303:6): [True: 0, False: 2] ------------------ 304| 0| isc_buffer_putmem(b, (const unsigned char *)base, space); 305| 0| return ISC_R_NOSPACE; 306| 0| } 307| | 308| 2| isc_buffer_putmem(b, (const unsigned char *)base, length); 309| 2| return ISC_R_SUCCESS; 310| 2|} zoneproperties.c:setfilename: 502| 2|setfilename(dns_zone_t *zone, char **field, const char *value) { 503| 2| char filename[PATH_MAX]; 504| 2| isc_buffer_t b; 505| | 506| 2| if (value == NULL) { ------------------ | Branch (506:6): [True: 0, False: 2] ------------------ 507| 0| *field = NULL; 508| 0| return; 509| 0| } 510| | 511| 2| isc_buffer_init(&b, filename, sizeof(filename)); 512| 2| dns_zone_expandzonefile(&b, value, &zone->origin, 513| 2| zone->view != NULL ? zone->view->name : NULL, ------------------ | Branch (513:5): [True: 0, False: 2] ------------------ 514| 2| dns_zonetype_name(zone->type)); 515| 2| setstring(zone, field, filename); 516| 2|} zoneproperties.c:setstring: 260| 8|setstring(dns_zone_t *zone, char **field, const char *value) { 261| 8| char *copy; 262| | 263| 8| if (value != NULL) { ------------------ | Branch (263:6): [True: 6, False: 2] ------------------ 264| 6| copy = isc_mem_strdup(zone->mctx, value); ------------------ | | 167| 6|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 265| 6| } else { 266| 2| copy = NULL; 267| 2| } 268| | 269| 8| if (*field != NULL) { ------------------ | Branch (269:6): [True: 0, False: 8] ------------------ 270| 0| isc_mem_free(zone->mctx, *field); ------------------ | | 197| 0| do { \ | | 198| 0| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 0| (p) = NULL; \ | | 200| 0| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 0] | | ------------------ ------------------ 271| 0| } 272| | 273| 8| *field = copy; 274| 8|} zoneproperties.c:default_journal: 583| 2|default_journal(dns_zone_t *zone) { 584| 2| char *journal; 585| | 586| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 587| 2| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 198| 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))) | | ------------------ ------------------ 588| | 589| 2| if (zone->masterfile != NULL) { ------------------ | Branch (589:6): [True: 2, False: 0] ------------------ 590| | /* Calculate string length including '\0'. */ 591| 2| int len = strlen(zone->masterfile) + sizeof(".jnl"); 592| 2| journal = isc_mem_allocate(zone->mctx, len); ------------------ | | 157| 2|#define isc_mem_allocate(c, s) isc__mem_allocate((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 593| 2| strlcpy(journal, zone->masterfile, len); 594| 2| strlcat(journal, ".jnl", len); 595| 2| } else { 596| 0| journal = NULL; 597| 0| } 598| 2| setstring(zone, &zone->journal, journal); 599| 2| if (journal != NULL) { ------------------ | Branch (599:6): [True: 2, False: 0] ------------------ 600| | isc_mem_free(zone->mctx, journal); ------------------ | | 197| 2| do { \ | | 198| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 2| (p) = NULL; \ | | 200| 2| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 2] | | ------------------ ------------------ 601| 2| } 602| 2|} zoneproperties.c:zone_namerd_tostr: 1246| 6|zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length) { 1247| 6| isc_result_t result = ISC_R_FAILURE; 1248| 6| isc_buffer_t buffer; 1249| | 1250| 6| REQUIRE(buf != NULL); ------------------ | | 198| 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| 6| REQUIRE(length > 1U); ------------------ | | 198| 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))) | | ------------------ ------------------ 1252| | 1253| | /* 1254| | * Leave space for terminating '\0'. 1255| | */ 1256| 6| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 1257| 6| if (zone->type != dns_zone_redirect && zone->type != dns_zone_key) { ------------------ | Branch (1257:6): [True: 6, False: 0] | Branch (1257:41): [True: 6, False: 0] ------------------ 1258| 6| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (1258:7): [True: 6, False: 0] ------------------ 1259| 6| result = dns_name_totext( 1260| 6| &zone->origin, DNS_NAME_OMITFINALDOT, &buffer); ------------------ | | 883| 6|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 1261| 6| } 1262| 6| if (result != ISC_R_SUCCESS && ------------------ | Branch (1262:7): [True: 0, False: 6] ------------------ 1263| 0| isc_buffer_availablelength(&buffer) >= ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1263:7): [True: 0, False: 0] ------------------ 1264| 0| (sizeof("") - 1)) 1265| 0| { 1266| 0| isc_buffer_putstr(&buffer, ""); 1267| 0| } 1268| | 1269| 6| if (isc_buffer_availablelength(&buffer) > 0) { ------------------ | | 161| 6|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1269:7): [True: 6, False: 0] ------------------ 1270| 6| isc_buffer_putstr(&buffer, "/"); 1271| 6| } 1272| 6| (void)dns_rdataclass_totext(zone->rdclass, &buffer); 1273| 6| } 1274| | 1275| 6| if (zone->view != NULL && strcmp(zone->view->name, "_bind") != 0 && ------------------ | Branch (1275:6): [True: 0, False: 6] | Branch (1275:28): [True: 0, False: 0] ------------------ 1276| 0| strcmp(zone->view->name, "_default") != 0 && ------------------ | Branch (1276:6): [True: 0, False: 0] ------------------ 1277| 0| strlen(zone->view->name) < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1277:6): [True: 0, False: 0] ------------------ 1278| 0| { 1279| 0| isc_buffer_putstr(&buffer, "/"); 1280| 0| isc_buffer_putstr(&buffer, zone->view->name); 1281| 0| } 1282| 6| if (dns__zone_inline_secure(zone) && ------------------ | Branch (1282:6): [True: 0, False: 6] ------------------ 1283| 0| 9U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1283:6): [True: 0, False: 0] ------------------ 1284| 0| { 1285| 0| isc_buffer_putstr(&buffer, " (signed)"); 1286| 0| } 1287| 6| if (dns__zone_inline_raw(zone) && ------------------ | Branch (1287:6): [True: 0, False: 6] ------------------ 1288| 0| 11U < isc_buffer_availablelength(&buffer)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1288:6): [True: 0, False: 0] ------------------ 1289| 0| { 1290| 0| isc_buffer_putstr(&buffer, " (unsigned)"); 1291| 0| } 1292| | 1293| 6| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 6|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1294| 6|} zoneproperties.c:zone_name_tostr: 1297| 2|zone_name_tostr(dns_zone_t *zone, char *buf, size_t length) { 1298| 2| isc_result_t result = ISC_R_FAILURE; 1299| 2| isc_buffer_t buffer; 1300| | 1301| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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| 2| REQUIRE(length > 1U); ------------------ | | 198| 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))) | | ------------------ ------------------ 1303| | 1304| | /* 1305| | * Leave space for terminating '\0'. 1306| | */ 1307| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 1308| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | Branch (1308:6): [True: 2, False: 0] ------------------ 1309| 2| result = dns_name_totext(&zone->origin, DNS_NAME_OMITFINALDOT, ------------------ | | 883| 2|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 1310| 2| &buffer); 1311| 2| } 1312| 2| if (result != ISC_R_SUCCESS && ------------------ | Branch (1312:6): [True: 0, False: 2] ------------------ 1313| 0| isc_buffer_availablelength(&buffer) >= (sizeof("") - 1)) ------------------ | | 161| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1313:6): [True: 0, False: 0] ------------------ 1314| 0| { 1315| 0| isc_buffer_putstr(&buffer, ""); 1316| 0| } 1317| | 1318| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1319| 2|} zoneproperties.c:zone_rdclass_tostr: 1322| 2|zone_rdclass_tostr(dns_zone_t *zone, char *buf, size_t length) { 1323| 2| isc_buffer_t buffer; 1324| | 1325| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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| 2| REQUIRE(length > 1U); ------------------ | | 198| 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))) | | ------------------ ------------------ 1327| | 1328| | /* 1329| | * Leave space for terminating '\0'. 1330| | */ 1331| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 1332| 2| (void)dns_rdataclass_totext(zone->rdclass, &buffer); 1333| | 1334| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 157| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1335| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 144| 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)); ------------------ | | 198| 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| 424| dns_zone_t **zonep) { 171| 424| isc_result_t result; 172| 424| dns_qpread_t qpr; 173| 424| void *pval = NULL; 174| 424| dns_ztfind_t exactmask = DNS_ZTFIND_NOEXACT | DNS_ZTFIND_EXACT; 175| 424| dns_ztfind_t exactopts = options & exactmask; 176| 424| dns_qpchain_t chain; 177| | 178| 424| REQUIRE(VALID_ZT(zt)); ------------------ | | 198| 424|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 848| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 424, False: 0] | | | | | Branch (42:11): [True: 424, False: 0] | | | | ------------------ | | | | 43| 424| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 179| 424| REQUIRE(exactopts != exactmask); ------------------ | | 198| 424|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 424| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 424, False: 0] | | | | ------------------ | | | | 43| 424| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 180| | 181| 424| dns_qpmulti_query(zt->multi, &qpr); 182| | 183| 424| if (exactopts == DNS_ZTFIND_EXACT) { ------------------ | Branch (183:6): [True: 0, False: 424] ------------------ 184| 0| result = dns_qp_getname(&qpr, name, DNS_DBNAMESPACE_NORMAL, 185| 0| &pval, NULL); 186| 424| } else { 187| 424| result = dns_qp_lookup(&qpr, name, DNS_DBNAMESPACE_NORMAL, NULL, 188| 424| &chain, &pval, NULL); 189| 424| if (exactopts == DNS_ZTFIND_NOEXACT && result == ISC_R_SUCCESS) ------------------ | Branch (189:7): [True: 0, False: 424] | 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| 424| } 201| 424| dns_qpread_destroy(zt->multi, &qpr); 202| | 203| 424| if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) { ------------------ | Branch (203:6): [True: 123, False: 301] | Branch (203:33): [True: 77, False: 224] ------------------ 204| 200| 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| 200| if ((options & DNS_ZTFIND_MIRROR) != 0 && ------------------ | Branch (222:7): [True: 200, False: 0] ------------------ 223| 200| dns_zone_gettype(zone) == dns_zone_mirror && ------------------ | Branch (223:7): [True: 0, False: 200] ------------------ 224| 0| !dns_zone_isloaded(zone)) ------------------ | Branch (224:7): [True: 0, False: 0] ------------------ 225| 0| { 226| 0| result = ISC_R_NOTFOUND; 227| 200| } else { 228| 200| dns_zone_attach(zone, zonep); 229| 200| } 230| 200| } 231| | 232| 424| return result; 233| 424|} 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| 426| uint32_t ival ISC_ATTR_UNUSED) { 79| 426| dns_zone_t *zone = pval; 80| 426| dns_name_t *name = dns_zone_getorigin(zone); 81| 426| return dns_qpkey_fromname(key, name, DNS_DBNAMESPACE_NORMAL); 82| 426|} 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); ------------------ | | 198| 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, ------------------ | | 276| 14| { \ | | 277| 14| isc_result_t _r = (x); \ | | 278| 14| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 14] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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])); ------------------ | | 276| 696| { \ | | 277| 696| isc_result_t _r = (x); \ | | 278| 696| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 696] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 276| 174| { \ | | 277| 174| isc_result_t _r = (x); \ | | 278| 174| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 174] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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: 247| 12| unsigned int *digestlen) { 248| 12| EVP_MAC_CTX *ctx; 249| 12| size_t maclen; 250| | 251| 12| REQUIRE(type < ISC_MD_MAX); ------------------ | | 198| 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))) | | ------------------ ------------------ 252| | 253| 12| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (253:6): [True: 0, False: 12] ------------------ 254| 0| return ISC_R_NOTIMPLEMENTED; 255| 0| } 256| | 257| 12| ctx = EVP_MAC_CTX_new(evp_hmac); 258| 12| RUNTIME_CHECK(ctx != NULL); ------------------ | | 245| 12| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 12, False: 0] | | ------------------ ------------------ 259| | 260| 12| if (EVP_MAC_init(ctx, key, keylen, md_to_hmac_params[type]) != 1) { ------------------ | Branch (260:6): [True: 0, False: 12] ------------------ 261| 0| goto fail; 262| 0| } 263| | 264| 12| if (EVP_MAC_update(ctx, buf, len) != 1) { ------------------ | Branch (264:6): [True: 0, False: 12] ------------------ 265| 0| goto fail; 266| 0| } 267| | 268| 12| maclen = *digestlen; 269| 12| if (EVP_MAC_final(ctx, digest, &maclen, maclen) != 1) { ------------------ | Branch (269:6): [True: 0, False: 12] ------------------ 270| 0| goto fail; 271| 0| } 272| | 273| 12| *digestlen = maclen; 274| | 275| 12| EVP_MAC_CTX_free(ctx); 276| 12| return ISC_R_SUCCESS; 277| | 278| 0|fail: 279| 0| ERR_clear_error(); 280| 0| EVP_MAC_CTX_free(ctx); 281| 0| return ISC_R_CRYPTOFAILURE; 282| 12|} isc_hmac_key_create: 291| 2| isc_mem_t *mctx, isc_hmac_key_t **keyp) { 292| 2| isc_hmac_key_t *key; 293| 2| uint8_t digest[ISC_MAX_MD_SIZE]; 294| 2| unsigned int digest_len = sizeof(digest); 295| 2| size_t key_len; 296| | 297| 2| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 298| 2| REQUIRE(type < ISC_MD_MAX); ------------------ | | 198| 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))) | | ------------------ ------------------ 299| | 300| 2| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (300:6): [True: 0, False: 2] ------------------ 301| 0| return ISC_R_NOTIMPLEMENTED; 302| 0| } 303| | 304| 2| if (len > (size_t)EVP_MD_block_size(isc__crypto_md[type])) { ------------------ | Branch (304:6): [True: 0, False: 2] ------------------ 305| 0| RETERR(isc_md(type, secret, len, digest, &digest_len)); ------------------ | | 276| 0| { \ | | 277| 0| isc_result_t _r = (x); \ | | 278| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 0] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 0| } ------------------ 306| 0| secret = digest; 307| 0| key_len = digest_len; 308| 2| } else { 309| 2| key_len = len; 310| 2| } 311| | 312| 2| key = isc_mem_get(mctx, STRUCT_FLEX_SIZE(key, secret, key_len)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 313| 2| *key = (isc_hmac_key_t){ 314| 2| .magic = hmac_key_magic, 315| 2| .len = key_len, 316| 2| .params = md_to_hmac_params[type], 317| 2| }; 318| 2| memmove(key->secret, secret, key_len); 319| 2| isc_mem_attach(mctx, &key->mctx); 320| | 321| 2| *keyp = key; 322| | 323| 2| return ISC_R_SUCCESS; 324| 2|} isc_hmac_key_expose: 344| 4|isc_hmac_key_expose(isc_hmac_key_t *key) { 345| 4| REQUIRE(key != NULL && key->magic == hmac_key_magic); ------------------ | | 198| 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))) | | ------------------ ------------------ 346| | 347| 4| return (isc_region_t){ .base = key->secret, .length = key->len }; 348| 4|} isc_hmac_new: 367| 34|isc_hmac_new(void) { 368| 34| EVP_MAC_CTX *ctx = EVP_MAC_CTX_new(evp_hmac); 369| 34| RUNTIME_CHECK(ctx != NULL); ------------------ | | 245| 34| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 34, False: 0] | | ------------------ ------------------ 370| 34| return ctx; 371| 34|} isc_hmac_free: 374| 34|isc_hmac_free(isc_hmac_t *hmac) { 375| 34| EVP_MAC_CTX_free(hmac); 376| 34|} isc_hmac_init: 379| 34|isc_hmac_init(isc_hmac_t *hmac, isc_hmac_key_t *key) { 380| 34| REQUIRE(key != NULL && key->magic == hmac_key_magic); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 68| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 34, False: 0] | | | | | Branch (42:11): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 381| 34| REQUIRE(hmac != NULL); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 382| | 383| 34| if (EVP_MAC_init(hmac, key->secret, key->len, key->params) != 1) { ------------------ | Branch (383:6): [True: 0, False: 34] ------------------ 384| 0| ERR_clear_error(); 385| 0| return ISC_R_CRYPTOFAILURE; 386| 0| } 387| | 388| 34| return ISC_R_SUCCESS; 389| 34|} isc_hmac_update: 392| 227|isc_hmac_update(isc_hmac_t *hmac, const unsigned char *buf, const size_t len) { 393| 227| REQUIRE(hmac != NULL); ------------------ | | 198| 227|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 227| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 227, False: 0] | | | | ------------------ | | | | 43| 227| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 394| | 395| 227| if (buf == NULL || len == 0) { ------------------ | Branch (395:6): [True: 0, False: 227] | Branch (395:21): [True: 0, False: 227] ------------------ 396| 0| return ISC_R_SUCCESS; 397| 0| } 398| | 399| 227| if (EVP_MAC_update(hmac, buf, len) != 1) { ------------------ | Branch (399:6): [True: 0, False: 227] ------------------ 400| 0| ERR_clear_error(); 401| 0| return ISC_R_CRYPTOFAILURE; 402| 0| } 403| | 404| 227| return ISC_R_SUCCESS; 405| 227|} isc_hmac_final: 408| 34|isc_hmac_final(isc_hmac_t *hmac, isc_buffer_t *out) { 409| 34| size_t len; 410| | 411| 34| REQUIRE(hmac != NULL); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 412| | 413| 34| len = isc_buffer_availablelength(out); ------------------ | | 161| 34|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 414| 34| if (len < EVP_MAC_CTX_get_mac_size(hmac)) { ------------------ | Branch (414:6): [True: 0, False: 34] ------------------ 415| 0| return ISC_R_NOSPACE; 416| 0| } 417| | 418| 34| if (EVP_MAC_final(hmac, isc_buffer_used(out), &len, len) != 1) { ------------------ | | 149| 34| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ | Branch (418:6): [True: 0, False: 34] ------------------ 419| 0| ERR_clear_error(); 420| 0| return ISC_R_CRYPTOFAILURE; 421| 0| } 422| | 423| 34| isc_buffer_add(out, len); 424| | 425| 34| return ISC_R_SUCCESS; 426| 34|} isc_crypto_fips_mode: 916| 2|isc_crypto_fips_mode(void) { 917| | return EVP_default_properties_is_fips_enabled(NULL) != 0; 918| 2|} isc__crypto_initialize: 970| 2|isc__crypto_initialize(void) { 971| | /* 972| | * We call OPENSSL_cleanup() manually, in a correct order, thus disable 973| | * the automatic atexit() handler. 974| | */ 975| 2| uint64_t opts = OPENSSL_INIT_LOAD_CONFIG | OPENSSL_INIT_NO_ATEXIT; 976| | 977| 2| RUNTIME_CHECK(OPENSSL_init_ssl(opts, NULL) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 978| | 979| 2| register_algorithms(); 980| | 981| |#if defined(ENABLE_FIPS_MODE) 982| | if (isc_crypto_fips_enable() != ISC_R_SUCCESS) { 983| | ERR_clear_error(); 984| | FATAL_ERROR("Failed to toggle FIPS mode but is " 985| | "required for this build"); 986| | } 987| |#endif 988| | 989| | /* Protect ourselves against unseeded PRNG */ 990| 2| if (RAND_status() != 1) { ------------------ | Branch (990:6): [True: 0, False: 2] ------------------ 991| 0| isc_ossl_wrap_logged_toresult( ------------------ | | 26| 0| isc__ossl_wrap_logged_toresult(category, module, funcname, fallback, \ | | 27| 0| __FILE__, __LINE__) ------------------ 992| 0| ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_CRYPTO, 993| 0| "RAND_status", ISC_R_CRYPTOFAILURE); 994| 0| FATAL_ERROR("OpenSSL pseudorandom number generator " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 995| 0| "cannot be initialized (see the `PRNG not " 996| 0| "seeded' message in the OpenSSL FAQ)"); 997| 0| } 998| 2|} ossl3.c:register_algorithms: 133| 2|register_algorithms(void) { 134| 2| if (!isc_crypto_fips_mode()) { ------------------ | Branch (134:6): [True: 2, False: 0] ------------------ 135| 2| md_register_algorithm(MD5); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 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))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 136| | 137| 2| INSIST(evp_chacha20poly1305 == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 138| 2| evp_chacha20poly1305 = 139| 2| EVP_CIPHER_fetch(NULL, "ChaCha20-Poly1305", NULL); 140| | 141| 2| INSIST(evp_chacha20 == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 142| 2| evp_chacha20 = EVP_CIPHER_fetch(NULL, "ChaCha20", NULL); 143| 2| } 144| | 145| 2| md_register_algorithm(SHA1); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 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))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 146| 2| md_register_algorithm(SHA224); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 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))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 147| 2| md_register_algorithm(SHA256); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 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))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 148| 2| md_register_algorithm(SHA384); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 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))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 149| 2| md_register_algorithm(SHA512); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 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))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 150| | 151| 2| INSIST(evp_aes_128_gcm == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 152| 2| evp_aes_128_gcm = EVP_CIPHER_fetch(NULL, "AES-128-GCM", NULL); 153| | 154| 2| INSIST(evp_aes_256_gcm == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 155| 2| evp_aes_256_gcm = EVP_CIPHER_fetch(NULL, "AES-256-GCM", NULL); 156| | 157| 2| INSIST(evp_aes_128_ctr == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 158| 2| evp_aes_128_ctr = EVP_CIPHER_fetch(NULL, "AES-128-CTR", NULL); 159| | 160| 2| INSIST(evp_aes_256_ctr == NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 161| 2| evp_aes_256_ctr = EVP_CIPHER_fetch(NULL, "AES-256-CTR", NULL); 162| | 163| | /* We _must_ have HMAC */ 164| 2| evp_hmac = EVP_MAC_fetch(NULL, "HMAC", NULL); 165| 2| if (evp_hmac == NULL) { ------------------ | Branch (165:6): [True: 0, False: 2] ------------------ 166| 0| FATAL_ERROR("OpenSSL failed to find an HMAC implementation. " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 167| 0| "Please make sure the default provider has an " 168| 0| "EVP_MAC-HMAC implementation"); 169| 0| } 170| | 171| 2| evp_tls_1_3_kdf = EVP_KDF_fetch(NULL, OSSL_KDF_NAME_TLS1_3_KDF, NULL); 172| 2| if (evp_tls_1_3_kdf == NULL) { ------------------ | Branch (172:6): [True: 0, False: 2] ------------------ 173| 0| FATAL_ERROR( ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 174| 0| "OpenSSL failed to find an TLS 1.3 KDF implementation." 175| 0| "Please make sure the default provider has an " 176| 0| "EVP_KDF-TLS13_KDF implementation"); 177| 0| } 178| | 179| 2| evp_hkdf = EVP_KDF_fetch(NULL, OSSL_KDF_NAME_HKDF, NULL); 180| 2| if (evp_hkdf == NULL) { ------------------ | Branch (180:6): [True: 0, False: 2] ------------------ 181| 0| FATAL_ERROR("OpenSSL failed to find an HKDF implementation. " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 182| 0| "Please make sure the default provider has an " 183| 0| "EVP_KDF-HKDF implementation"); 184| 0| } 185| | 186| 2| ERR_clear_error(); 187| | 188| 2| return ISC_R_SUCCESS; 189| 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, ------------------ | | 217| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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), ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 2| } ------------------ 739| 2| digest, &digestlen)); 740| | 741| 2| RETERR(digest2hex(digest, digestlen, hash, sizeof(hash))); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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); ------------------ | | 198| 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); ------------------ | | 198| 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), ------------------ | | 154| 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| 711|isc_hash32_init(isc_hash32_t *restrict state) { 58| 711| isc_halfsiphash13_init(state, isc_hash_key); 59| 711|} isc_hash32_hash: 63| 711| const size_t length, const bool case_sensitive) { 64| 711| REQUIRE(length == 0 || data != NULL); ------------------ | | 198| 711|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.42k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 711] | | | | | Branch (42:11): [True: 711, False: 0] | | | | ------------------ | | | | 43| 711| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 65| | 66| 711| isc_halfsiphash13_hash(state, data, length, case_sensitive); 67| 711|} isc_hash32_finalize: 70| 711|isc_hash32_finalize(isc_hash32_t *restrict state) { 71| 711| uint32_t hval; 72| | 73| 711| isc_halfsiphash13_finalize(state, (uint8_t *)&hval); 74| | 75| 711| return hval; 76| 711|} 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)); ------------------ | | 144| 8|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 211| | 212| 8| REQUIRE(hashmapp != NULL && *hashmapp == NULL); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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| 709| isc_hashmap_match_fn match, const void *key, void **valuep) { 295| 709| REQUIRE(ISC_HASHMAP_VALID(hashmap)); ------------------ | | 198| 709|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 709, False: 0] | | | | | Branch (42:11): [True: 709, False: 0] | | | | ------------------ | | | | 43| 709| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 296| 709| REQUIRE(valuep == NULL || *valuep == NULL); ------------------ | | 198| 709|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.41k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 709] | | | | | Branch (42:11): [True: 709, False: 0] | | | | ------------------ | | | | 43| 709| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 297| | 298| 709| uint8_t idx = hashmap->hindex; 299| 709| hashmap_node_t *node = hashmap_find(hashmap, hashval, match, key, 300| 709| &(uint32_t){ 0 }, &idx); 301| 709| if (node == NULL) { ------------------ | Branch (301:6): [True: 453, False: 256] ------------------ 302| 453| return ISC_R_NOTFOUND; 303| 453| } 304| | 305| 256| INSIST(node->key != NULL); ------------------ | | 202| 256|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 256| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 256, False: 0] | | | | ------------------ | | | | 55| 256| ((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); ------------------ | | 104| 256| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 256, False: 0] | | ------------------ | | 105| 256| *(obj) = (val); \ | | 106| 256| } ------------------ 307| 256| return ISC_R_SUCCESS; 308| 709|} isc_hashmap_add: 568| 2| void **foundp) { 569| 2| REQUIRE(ISC_HASHMAP_VALID(hashmap)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 202| 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); ------------------ | | 104| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 0] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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, ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 8| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 8|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 182| 8| sizeof(hashmap->tables[idx].table[0])); 183| 8|} hashmap.c:hashmap_find: 253| 709| uint8_t *idxp) { 254| 709| uint32_t hash; 255| 709| uint32_t psl; 256| 709| uint8_t idx = *idxp; 257| 709| uint32_t pos; 258| | 259| 709|nexttable: 260| 709| psl = 0; 261| 709| hash = isc_hash_bits32(hashval, hashmap->tables[idx].hashbits); 262| | 263| 709| while (true) { ------------------ | Branch (263:9): [True: 709, Folded] ------------------ 264| 709| hashmap_node_t *node = NULL; 265| | 266| 709| pos = (hash + psl) & hashmap->tables[idx].hashmask; 267| | 268| 709| node = &hashmap->tables[idx].table[pos]; 269| | 270| 709| if (node->key == NULL || psl > node->psl) { ------------------ | Branch (270:7): [True: 453, False: 256] | Branch (270:28): [True: 0, False: 256] ------------------ 271| 453| break; 272| 453| } 273| | 274| 256| if (node->hashval == hashval) { ------------------ | Branch (274:7): [True: 256, False: 0] ------------------ 275| 256| if (match(node->value, key)) { ------------------ | Branch (275:8): [True: 256, False: 0] ------------------ 276| 256| *pslp = psl; 277| 256| *idxp = idx; 278| 256| return node; 279| 256| } 280| 256| } 281| | 282| 0| psl++; 283| 0| } 284| 453| if (try_nexttable(hashmap, idx)) { ------------------ | Branch (284:6): [True: 0, False: 453] ------------------ 285| 0| idx = hashmap_nexttable(idx); 286| 0| goto nexttable; 287| 0| } 288| | 289| 453| return NULL; 290| 453|} hashmap.c:try_nexttable: 129| 453|try_nexttable(const isc_hashmap_t *hashmap, uint8_t idx) { 130| 453| return idx == hashmap->hindex && rehashing_in_progress(hashmap); ------------------ | Branch (130:9): [True: 453, False: 0] | Branch (130:35): [True: 0, False: 453] ------------------ 131| 453|} hashmap.c:rehashing_in_progress: 123| 457|rehashing_in_progress(const isc_hashmap_t *hashmap) { 124| 457| return hashmap->tables[hashmap_nexttable(hashmap->hindex)].table != 125| | NULL; 126| 457|} 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| 457|hashmap_nexttable(uint8_t idx) { 119| 457| return (idx == 0) ? 1 : 0; ------------------ | Branch (119:9): [True: 457, False: 0] ------------------ 120| 457|} 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); ------------------ | | 202| 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); ------------------ | | 104| 0| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 0] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 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); ------------------ | | 305| 0| { \ | | 306| 0| typeof(a) __tmp_swap = a; \ | | 307| 0| a = b; \ | | 308| 0| b = __tmp_swap; \ | | 309| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 144| 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.34k|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.34k| 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.34k| 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.34k| 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.34k| uint64_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes; 91| | /* 92| | * Add one for greater-than-or-equal comparison 93| | */ 94| 3.34k| 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.34k| 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.34k| return octets | (is_upper >> 2); 104| 3.34k|} name.c:isc__ascii_load8: 124| 3.34k|isc__ascii_load8(const uint8_t *ptr) { 125| 3.34k| uint64_t bytes = 0; 126| 3.34k| memmove(&bytes, ptr, sizeof(bytes)); 127| 3.34k| return bytes; 128| 3.34k|} name.c:isc_ascii_lowerequal: 135| 1.41k| unsigned int len) { 136| 1.41k| uint64_t a8 = 0, b8 = 0; 137| 1.41k| if (len >= 8) { ------------------ | Branch (137:6): [True: 957, False: 462] ------------------ 138| 957| const uint8_t *a_tail = a + len - 8; 139| 957| const uint8_t *b_tail = b + len - 8; 140| 1.67k| while (len >= 8) { ------------------ | Branch (140:10): [True: 971, False: 703] ------------------ 141| 971| a8 = isc_ascii_tolower8(isc__ascii_load8(a)); 142| 971| b8 = isc_ascii_tolower8(isc__ascii_load8(b)); 143| 971| if (a8 != b8) { ------------------ | Branch (143:8): [True: 254, False: 717] ------------------ 144| 254| return false; 145| 254| } 146| 717| len -= 8; 147| 717| a += 8; 148| 717| b += 8; 149| 717| } 150| | 151| 703| a8 = isc_ascii_tolower8(isc__ascii_load8(a_tail)); 152| 703| b8 = isc_ascii_tolower8(isc__ascii_load8(b_tail)); 153| 703| return a8 == b8; 154| 957| } 155| | 156| 924| while (len-- > 0) { ------------------ | Branch (156:9): [True: 462, False: 462] ------------------ 157| 462| if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 462|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 462|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ | Branch (157:7): [True: 0, False: 462] ------------------ 158| 0| return false; 159| 0| } 160| 462| } 161| 462| return true; 162| 462|} name.c:isc_ascii_lowercopy: 47| 369|isc_ascii_lowercopy(uint8_t *dst, const uint8_t *src, unsigned int len) { 48| 4.05k| while (len-- > 0) { ------------------ | Branch (48:9): [True: 3.68k, False: 369] ------------------ 49| 3.68k| *dst++ = isc__ascii_tolower1(*src++); 50| 3.68k| } 51| 369|} name.c:isc__ascii_tolower1: 39| 3.68k|isc__ascii_tolower1(uint8_t c) { 40| 3.68k| return c + ('a' - 'A') * ('A' <= c && c <= 'Z'); ------------------ | Branch (40:28): [True: 2.58k, False: 1.10k] | Branch (40:40): [True: 0, False: 2.58k] ------------------ 41| 3.68k|} hash.c:isc__ascii_tolower1: 39| 1.42k|isc__ascii_tolower1(uint8_t c) { 40| 1.42k| return c + ('a' - 'A') * ('A' <= c && c <= 'Z'); ------------------ | Branch (40:28): [True: 711, False: 711] | Branch (40:40): [True: 0, False: 711] ------------------ 41| 1.42k|} hash.c:isc_ascii_tolower4: 110| 1.42k|isc_ascii_tolower4(uint32_t octets) { 111| 1.42k| uint32_t all_bytes = 0x01010101; 112| 1.42k| uint32_t heptets = octets & (0x7F * all_bytes); 113| 1.42k| uint32_t is_ascii = ~octets & (0x80 * all_bytes); 114| 1.42k| uint32_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes; 115| 1.42k| uint32_t is_ge_A = heptets + (0x80 - 'A') * all_bytes; 116| 1.42k| uint32_t is_upper = (is_ge_A ^ is_gt_Z) & is_ascii; 117| 1.42k| return octets | (is_upper >> 2); 118| 1.42k|} hash.c:isc_rotate_left32: 82| 25.5k|isc_rotate_left32(const uint32_t x, uint32_t n) { 83| 25.5k| return (x << n) | (x >> (32 - n)); 84| 25.5k|} dns_message_checksig.c:isc_buffer_putuint8: 869| 2.38k|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 2.38k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 2.38k| { \ | | 858| 2.38k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 2.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 4.76k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 2.38k, False: 0] | | | | | | | Branch (42:11): [True: 2.38k, False: 0] | | | | | | ------------------ | | | | | | 43| 2.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 2.38k| \ | | 860| 2.38k| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 2.38k] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 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.38k| \ | | 865| 2.38k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 2.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2.38k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2.38k, False: 0] | | | | | | ------------------ | | | | | | 43| 2.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 2.38k| } ------------------ 871| | 872| 2.38k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 2.38k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 2.38k| b->used += sizeof(val); 874| 2.38k| cp[0] = val; 875| 2.38k|} dns_message_checksig.c:isc_buffer_init: 524| 1.89k| const unsigned int length) { 525| 1.89k| REQUIRE(b != NULL); ------------------ | | 198| 1.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.89k, False: 0] | | | | ------------------ | | | | 43| 1.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 1.89k| *b = (isc_buffer_t){ 528| 1.89k| .base = base, 529| 1.89k| .length = length, 530| 1.89k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 1.89k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 1.89k| { \ | | | | 27| 1.89k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 1.89k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 1.89k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 1.89k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 1.89k| } | | ------------------ ------------------ 531| 1.89k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 1.89k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 1.89k| }; 533| 1.89k|} dns_message_checksig.c:isc_buffer_putmem: 965| 3.06k| const unsigned int length) { 966| 3.06k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 3.06k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.06k, False: 0] | | | | | Branch (42:11): [True: 3.06k, False: 0] | | | | ------------------ | | | | 43| 3.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 967| | 968| 3.06k| if (b->mctx) { ------------------ | Branch (968:6): [True: 0, False: 3.06k] ------------------ 969| 0| isc_result_t result = isc_buffer_reserve(b, length); 970| 0| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 198| 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| 3.06k| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 198| 3.06k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.06k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.06k, False: 0] | | | | ------------------ | | | | 43| 3.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 974| | 975| 3.06k| if (length > 0U) { ------------------ | Branch (975:6): [True: 3.04k, False: 20] ------------------ 976| 3.04k| memmove(isc_buffer_used(b), base, length); ------------------ | | 149| 3.04k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 977| 3.04k| b->used += length; 978| 3.04k| } 979| 3.06k|} dns_message_checksig.c:isc_buffer_putuint16: 897| 19.7k|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 898| 19.7k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 19.7k| { \ | | 858| 19.7k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 19.7k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 39.5k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 19.7k, False: 0] | | | | | | | Branch (42:11): [True: 19.7k, False: 0] | | | | | | ------------------ | | | | | | 43| 19.7k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 19.7k| \ | | 860| 19.7k| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 19.7k] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 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| 19.7k| \ | | 865| 19.7k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 19.7k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 19.7k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 19.7k, False: 0] | | | | | | ------------------ | | | | | | 43| 19.7k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 19.7k| } ------------------ 899| | 900| 19.7k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 19.7k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 901| 19.7k| b->used += sizeof(val); 902| 19.7k| ISC_U16TO8_BE(cp, val); ------------------ | | 223| 19.7k| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 19.7k| (p)[1] = (uint8_t)((v)); ------------------ 903| 19.7k|} dns_message_checksig.c:isc_buffer_putuint32: 925| 1.87k|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 926| 1.87k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 1.87k| { \ | | 858| 1.87k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 1.87k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 3.75k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 1.87k, False: 0] | | | | | | | Branch (42:11): [True: 1.87k, False: 0] | | | | | | ------------------ | | | | | | 43| 1.87k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 1.87k| \ | | 860| 1.87k| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 1.87k] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 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.87k| \ | | 865| 1.87k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 1.87k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 1.87k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 1.87k, False: 0] | | | | | | ------------------ | | | | | | 43| 1.87k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 1.87k| } ------------------ 927| | 928| 1.87k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 1.87k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 929| 1.87k| b->used += sizeof(val); 930| | 931| 1.87k| ISC_U32TO8_BE(cp, val); ------------------ | | 229| 1.87k| (p)[0] = (uint8_t)((v) >> 24); \ | | 230| 1.87k| (p)[1] = (uint8_t)((v) >> 16); \ | | 231| 1.87k| (p)[2] = (uint8_t)((v) >> 8); \ | | 232| 1.87k| (p)[3] = (uint8_t)((v)); ------------------ 932| 1.87k|} fixedname.c:isc_buffer_init: 524| 4.57k| const unsigned int length) { 525| 4.57k| REQUIRE(b != NULL); ------------------ | | 198| 4.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.57k, False: 0] | | | | ------------------ | | | | 43| 4.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 4.57k| *b = (isc_buffer_t){ 528| 4.57k| .base = base, 529| 4.57k| .length = length, 530| 4.57k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.57k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.57k| { \ | | | | 27| 4.57k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.57k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.57k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.57k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.57k| } | | ------------------ ------------------ 531| 4.57k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 4.57k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 4.57k| }; 533| 4.57k|} message.c:isc_buffer_allocate: 1077| 2.26k| const unsigned int length) { 1078| 2.26k| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.52k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1079| | 1080| 2.26k| isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length); ------------------ | | 144| 2.26k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1081| 2.26k| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1082| | 1083| 2.26k| isc_buffer_init(dbuf, bdata, length); 1084| 2.26k| dbuf->extra = length; 1085| 2.26k| isc_buffer_setmctx(dbuf, mctx); 1086| | 1087| 2.26k| *dbufp = dbuf; 1088| 2.26k|} message.c:isc_buffer_setmctx: 1091| 2.26k|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1092| 2.26k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.52k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1093| | 1094| 2.26k| b->mctx = mctx; 1095| 2.26k|} message.c:isc_buffer_free: 1154| 2.26k|isc_buffer_free(isc_buffer_t **restrict dbufp) { 1155| 2.26k| REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp)); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.04k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1156| 2.26k| REQUIRE((*dbufp)->mctx != NULL); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1157| | 1158| 2.26k| isc_buffer_t *dbuf = *dbufp; 1159| 2.26k| isc_mem_t *mctx = dbuf->mctx; 1160| 2.26k| unsigned int extra = dbuf->extra; 1161| | 1162| 2.26k| *dbufp = NULL; /* destroy external reference */ 1163| | 1164| 2.26k| isc_buffer_clearmctx(dbuf); 1165| | 1166| 2.26k| isc_buffer_invalidate(dbuf); 1167| | isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra); ------------------ | | 171| 2.26k| do { \ | | 172| 2.26k| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2.26k| (p) = NULL; \ | | 174| 2.26k| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 2.26k] | | ------------------ ------------------ 1168| 2.26k|} message.c:isc_buffer_clearmctx: 1098| 2.26k|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1099| 2.26k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.52k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1100| | 1101| 2.26k| if (b->dynamic) { ------------------ | Branch (1101:6): [True: 0, False: 2.26k] ------------------ 1102| 0| isc_mem_put(b->mctx, b->base, b->length); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 1103| 0| b->dynamic = false; 1104| 0| } 1105| | 1106| | b->mctx = NULL; 1107| 2.26k|} message.c:isc_buffer_invalidate: 577| 2.26k|isc_buffer_invalidate(isc_buffer_t *restrict b) { 578| 2.26k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.52k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | | Branch (42:11): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 579| 2.26k| REQUIRE(!ISC_LINK_LINKED(b, link)); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 580| 2.26k| REQUIRE(b->mctx == NULL); ------------------ | | 198| 2.26k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.26k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.26k, False: 0] | | | | ------------------ | | | | 43| 2.26k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 581| | 582| 2.26k| *b = (isc_buffer_t){ 583| 2.26k| .magic = 0, 584| 2.26k| }; 585| 2.26k|} message.c:isc_buffer_usedregion: 616| 2.09k| isc_region_t *restrict r) { 617| 2.09k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.09k, False: 0] | | | | | Branch (42:11): [True: 2.09k, False: 0] | | | | ------------------ | | | | 43| 2.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 2.09k| REQUIRE(r != NULL); ------------------ | | 198| 2.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.09k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.09k, False: 0] | | | | ------------------ | | | | 43| 2.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 2.09k| r->base = b->base; 621| 2.09k| r->length = b->used; 622| 2.09k|} message.c:isc_buffer_remainingregion: 730| 9.55k|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 731| 9.55k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 9.55k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 19.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 9.55k, False: 0] | | | | | Branch (42:11): [True: 9.55k, False: 0] | | | | ------------------ | | | | 43| 9.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 9.55k| REQUIRE(r != NULL); ------------------ | | 198| 9.55k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.55k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 9.55k, False: 0] | | | | ------------------ | | | | 43| 9.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| | 734| 9.55k| r->base = isc_buffer_current(b); ------------------ | | 145| 9.55k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 735| 9.55k| r->length = isc_buffer_remaininglength(b); ------------------ | | 159| 9.55k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 736| 9.55k|} message.c:isc_buffer_getuint16: 888| 18.5k|isc_buffer_getuint16(isc_buffer_t *restrict b) { 889| 18.5k| uint16_t val = 0; 890| 18.5k| isc_result_t result = isc_buffer_peekuint16(b, &val); 891| 18.5k| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 18.5k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 18.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 18.5k, False: 0] | | | | ------------------ | | | | 49| 18.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 892| 18.5k| b->current += sizeof(val); 893| 18.5k| return val; 894| 18.5k|} message.c:isc_buffer_peekuint16: 878| 18.5k|isc_buffer_peekuint16(const isc_buffer_t *restrict b, uint16_t *valp) { 879| 18.5k| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 18.5k| { \ | | 832| 18.5k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 18.5k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 37.0k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 18.5k, False: 0] | | | | | | | Branch (42:11): [True: 18.5k, False: 0] | | | | | | ------------------ | | | | | | 43| 18.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 18.5k| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 18.5k] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 18.5k| } ------------------ 880| | 881| 18.5k| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 18.5k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 882| | 883| | SET_IF_NOT_NULL(valp, ISC_U8TO16_BE(cp)); ------------------ | | 104| 18.5k| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 18.5k, False: 0] | | ------------------ | | 105| 18.5k| *(obj) = (val); \ | | 106| 18.5k| } ------------------ 884| 18.5k| return ISC_R_SUCCESS; 885| 18.5k|} message.c:isc_buffer_add: 652| 1.08k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 1.08k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 1.08k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.08k, False: 0] | | | | | Branch (42:11): [True: 1.08k, False: 0] | | | | ------------------ | | | | 43| 1.08k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 1.08k| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 1.08k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.08k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 1.08k, False: 0] | | | | ------------------ | | | | 43| 1.08k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 1.08k| b->used += n; 657| 1.08k|} message.c:isc_buffer_reserve: 1110| 200|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1111| 200| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1112| | 1113| 200| size_t len; 1114| | 1115| 200| len = dbuf->length; 1116| 200| if ((len - dbuf->used) >= size) { ------------------ | Branch (1116:6): [True: 200, False: 0] ------------------ 1117| 200| return ISC_R_SUCCESS; 1118| 200| } 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); ------------------ | | 296| 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); ------------------ | | 144| 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, ------------------ | | 152| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 153| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 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.34k| const unsigned int length) { 525| 3.34k| REQUIRE(b != NULL); ------------------ | | 198| 3.34k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.34k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.34k, False: 0] | | | | ------------------ | | | | 43| 3.34k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 3.34k| *b = (isc_buffer_t){ 528| 3.34k| .base = base, 529| 3.34k| .length = length, 530| 3.34k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 3.34k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 3.34k| { \ | | | | 27| 3.34k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.34k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 3.34k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.34k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 3.34k| } | | ------------------ ------------------ 531| 3.34k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 3.34k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 3.34k| }; 533| 3.34k|} message.c:isc_buffer_putmem: 965| 200| const unsigned int length) { 966| 200| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 967| | 968| 200| if (b->mctx) { ------------------ | Branch (968:6): [True: 200, False: 0] ------------------ 969| 200| isc_result_t result = isc_buffer_reserve(b, length); 970| 200| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 971| 200| } 972| | 973| 200| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 200| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 974| | 975| 200| if (length > 0U) { ------------------ | Branch (975:6): [True: 200, False: 0] ------------------ 976| 200| memmove(isc_buffer_used(b), base, length); ------------------ | | 149| 200| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 977| 200| b->used += length; 978| 200| } 979| 200|} message.c:isc_buffer_getuint32: 916| 1.67k|isc_buffer_getuint32(isc_buffer_t *restrict b) { 917| 1.67k| uint32_t val = 0; 918| 1.67k| isc_result_t result = isc_buffer_peekuint32(b, &val); 919| 1.67k| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 1.67k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 1.67k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 1.67k, False: 0] | | | | ------------------ | | | | 49| 1.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 920| 1.67k| b->current += sizeof(val); 921| 1.67k| return val; 922| 1.67k|} message.c:isc_buffer_peekuint32: 906| 1.67k|isc_buffer_peekuint32(const isc_buffer_t *restrict b, uint32_t *valp) { 907| 1.67k| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 1.67k| { \ | | 832| 1.67k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 1.67k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 3.34k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 1.67k, False: 0] | | | | | | | Branch (42:11): [True: 1.67k, False: 0] | | | | | | ------------------ | | | | | | 43| 1.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 1.67k| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 1.67k] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 1.67k| } ------------------ 908| | 909| 1.67k| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 1.67k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 910| | 911| | SET_IF_NOT_NULL(valp, ISC_U8TO32_BE(cp)); ------------------ | | 104| 1.67k| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 1.67k, False: 0] | | ------------------ | | 105| 1.67k| *(obj) = (val); \ | | 106| 1.67k| } ------------------ 912| 1.67k| return ISC_R_SUCCESS; 913| 1.67k|} message.c:isc_buffer_setactive: 771| 5.02k|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 5.02k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 5.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.0k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.02k, False: 0] | | | | | Branch (42:11): [True: 5.02k, False: 0] | | | | ------------------ | | | | 43| 5.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 5.02k| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 5.02k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.02k, False: 0] | | | | ------------------ | | | | 43| 5.02k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 5.02k| b->active = b->current + n; 776| 5.02k|} name.c:isc_buffer_clear: 694| 786|isc_buffer_clear(isc_buffer_t *restrict b) { 695| 786| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 786|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 786, False: 0] | | | | | Branch (42:11): [True: 786, False: 0] | | | | ------------------ | | | | 43| 786| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| | 697| 786| b->used = 0; 698| 786| b->current = 0; 699| 786| b->active = 0; 700| 786|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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| 6.09k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 6.09k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 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))) | | ------------------ ------------------ 654| 6.09k| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 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))) | | ------------------ ------------------ 655| | 656| 6.09k| b->used += n; 657| 6.09k|} 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)); ------------------ | | 198| 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); ------------------ | | 296| 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); ------------------ | | 144| 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, ------------------ | | 152| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 153| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 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)); \ | | ------------------ | | | | 198| 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); \ | | ------------------ | | | | 200| 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); \ | | ------------------ | | | | 198| 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.50k|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 5.50k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 5.50k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 11.0k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.50k, False: 0] | | | | | Branch (42:11): [True: 5.50k, False: 0] | | | | ------------------ | | | | 43| 5.50k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 5.50k| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 5.50k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.50k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.50k, False: 0] | | | | ------------------ | | | | 43| 5.50k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 5.50k| b->current += n; 811| 5.50k|} name.c:isc_buffer_init: 524| 4| const unsigned int length) { 525| 4| REQUIRE(b != NULL); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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.96k|isc_buffer_activeregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 749| 2.96k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.96k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.93k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2.96k, False: 0] | | | | | Branch (42:11): [True: 2.96k, False: 0] | | | | ------------------ | | | | 43| 2.96k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 750| 2.96k| REQUIRE(r != NULL); ------------------ | | 198| 2.96k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.96k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.96k, False: 0] | | | | ------------------ | | | | 43| 2.96k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 751| | 752| 2.96k| if (b->current < b->active) { ------------------ | Branch (752:6): [True: 2.94k, False: 24] ------------------ 753| 2.94k| r->base = isc_buffer_current(b); ------------------ | | 145| 2.94k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 754| 2.94k| r->length = isc_buffer_activelength(b); ------------------ | | 160| 2.94k|#define isc_buffer_activelength(b) ((b)->active - (b)->current) /* c-b */ ------------------ 755| 2.94k| } else { 756| | r->base = NULL; 757| 24| r->length = 0; 758| 24| } 759| 2.96k|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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_forward: 806| 5.26k|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 5.26k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 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))) | | ------------------ ------------------ 808| 5.26k| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 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))) | | ------------------ ------------------ 809| | 810| 5.26k| b->current += n; 811| 5.26k|} rdata.c:isc_buffer_availableregion: 634| 5.38k|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 635| 5.38k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 5.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.38k, False: 0] | | | | | Branch (42:11): [True: 5.38k, False: 0] | | | | ------------------ | | | | 43| 5.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 636| 5.38k| REQUIRE(r != NULL); ------------------ | | 198| 5.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.38k, False: 0] | | | | ------------------ | | | | 43| 5.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 637| | 638| 5.38k| r->base = isc_buffer_used(b); ------------------ | | 149| 5.38k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 639| 5.38k| r->length = isc_buffer_availablelength(b); ------------------ | | 161| 5.38k|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 640| 5.38k|} rdata.c:isc_buffer_add: 652| 5.01k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 5.01k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 5.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10.0k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.01k, False: 0] | | | | | Branch (42:11): [True: 5.01k, False: 0] | | | | ------------------ | | | | 43| 5.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 5.01k| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 5.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.01k, False: 0] | | | | ------------------ | | | | 43| 5.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 5.01k| b->used += n; 657| 5.01k|} 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)); \ | | ------------------ | | | | 198| 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); \ | | ------------------ | | | | 200| 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); \ | | ------------------ | | | | 198| 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); ------------------ | | 223| 2| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 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)); \ | | ------------------ | | | | 198| 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); \ | | ------------------ | | | | 200| 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); \ | | ------------------ | | | | 198| 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); ------------------ | | 229| 10| (p)[0] = (uint8_t)((v) >> 24); \ | | 230| 10| (p)[1] = (uint8_t)((v) >> 16); \ | | 231| 10| (p)[2] = (uint8_t)((v) >> 8); \ | | 232| 10| (p)[3] = (uint8_t)((v)); ------------------ 932| 10|} rdata.c:isc_buffer_init: 524| 6| const unsigned int length) { 525| 6| REQUIRE(b != NULL); ------------------ | | 198| 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| 39| const unsigned int length) { 525| 39| REQUIRE(b != NULL); ------------------ | | 198| 39|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 39| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 39, False: 0] | | | | ------------------ | | | | 43| 39| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 39| *b = (isc_buffer_t){ 528| 39| .base = base, 529| 39| .length = length, 530| 39| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 39|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 39| { \ | | | | 27| 39| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 39|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 39| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 39|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 39| } | | ------------------ ------------------ 531| 39| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 39|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 39| }; 533| 39|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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| 34|isc_buffer_putuint48(isc_buffer_t *restrict b, const uint64_t val) { 955| 34| ISC_BUFFER_PUT_RESERVE(b, val, 6); /* 48-bits */ ------------------ | | 857| 34| { \ | | 858| 34| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 68| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 34, False: 0] | | | | | | | Branch (42:11): [True: 34, False: 0] | | | | | | ------------------ | | | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 34| \ | | 860| 34| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 34] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 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| 34| \ | | 865| 34| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 34| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 34, False: 0] | | | | | | ------------------ | | | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 34| } ------------------ 956| | 957| 34| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 34| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 958| 34| b->used += 6; 959| | 960| 34| ISC_U48TO8_BE(cp, val); ------------------ | | 239| 34| (p)[0] = (uint8_t)((v) >> 40); \ | | 240| 34| (p)[1] = (uint8_t)((v) >> 32); \ | | 241| 34| (p)[2] = (uint8_t)((v) >> 24); \ | | 242| 34| (p)[3] = (uint8_t)((v) >> 16); \ | | 243| 34| (p)[4] = (uint8_t)((v) >> 8); \ | | 244| 34| (p)[5] = (uint8_t)((v)); ------------------ 961| 34|} tsig.c:isc_buffer_putuint16: 897| 139|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 898| 139| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 139| { \ | | 858| 139| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 139|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 278| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 139, False: 0] | | | | | | | Branch (42:11): [True: 139, False: 0] | | | | | | ------------------ | | | | | | 43| 139| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 139| \ | | 860| 139| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 139] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 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| 139| \ | | 865| 139| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 139|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 139| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 139, False: 0] | | | | | | ------------------ | | | | | | 43| 139| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 139| } ------------------ 899| | 900| 139| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 139| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 901| 139| b->used += sizeof(val); 902| 139| ISC_U16TO8_BE(cp, val); ------------------ | | 223| 139| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 139| (p)[1] = (uint8_t)((v)); ------------------ 903| 139|} tsig.c:isc_buffer_usedregion: 616| 139| isc_region_t *restrict r) { 617| 139| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 139|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 278| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 139, False: 0] | | | | | Branch (42:11): [True: 139, False: 0] | | | | ------------------ | | | | 43| 139| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 139| REQUIRE(r != NULL); ------------------ | | 198| 139|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 139| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 139, False: 0] | | | | ------------------ | | | | 43| 139| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 139| r->base = b->base; 621| 139| r->length = b->used; 622| 139|} tsig.c:isc_buffer_clear: 694| 34|isc_buffer_clear(isc_buffer_t *restrict b) { 695| 34| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 68| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 34, False: 0] | | | | | Branch (42:11): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| | 697| 34| b->used = 0; 698| 34| b->current = 0; 699| 34| b->active = 0; 700| 34|} tsig.c:isc_buffer_putuint32: 925| 34|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 926| 34| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 34| { \ | | 858| 34| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 68| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 34, False: 0] | | | | | | | Branch (42:11): [True: 34, False: 0] | | | | | | ------------------ | | | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 34| \ | | 860| 34| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 0, False: 34] | | ------------------ | | 861| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 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| 34| \ | | 865| 34| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 34| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 34, False: 0] | | | | | | ------------------ | | | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 34| } ------------------ 927| | 928| 34| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 34| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 929| 34| b->used += sizeof(val); 930| | 931| 34| ISC_U32TO8_BE(cp, val); ------------------ | | 229| 34| (p)[0] = (uint8_t)((v) >> 24); \ | | 230| 34| (p)[1] = (uint8_t)((v) >> 16); \ | | 231| 34| (p)[2] = (uint8_t)((v) >> 8); \ | | 232| 34| (p)[3] = (uint8_t)((v)); ------------------ 932| 34|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 200| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); \ | | ------------------ | | | | 198| 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); \ | | ------------------ | | | | 200| 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); \ | | ------------------ | | | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 200| 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); ------------------ | | 198| 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| 91| const unsigned int length) { 525| 91| REQUIRE(b != NULL); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 91| *b = (isc_buffer_t){ 528| 91| .base = base, 529| 91| .length = length, 530| 91| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 91|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 91| { \ | | | | 27| 91| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 91|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 91| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 91|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 91| } | | ------------------ ------------------ 531| 91| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 91|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 91| }; 533| 91|} dnssec.c:isc_buffer_add: 652| 91|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 91| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 91, False: 0] | | | | | Branch (42:11): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 91| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 91| b->used += n; 657| 91|} dnssec.c:isc_buffer_usedregion: 616| 90| isc_region_t *restrict r) { 617| 90| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 90|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 180| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 90, False: 0] | | | | | Branch (42:11): [True: 90, False: 0] | | | | ------------------ | | | | 43| 90| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 90| REQUIRE(r != NULL); ------------------ | | 198| 90|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 90| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 90, False: 0] | | | | ------------------ | | | | 43| 90| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 90| r->base = b->base; 621| 90| r->length = b->used; 622| 90|} 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)); \ | | ------------------ | | | | 198| 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); \ | | ------------------ | | | | 200| 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); \ | | ------------------ | | | | 198| 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); ------------------ | | 198| 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)); \ | | ------------------ | | | | 198| 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); \ | | ------------------ | | | | 200| 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); \ | | ------------------ | | | | 198| 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); ------------------ | | 223| 2| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 2| (p)[1] = (uint8_t)((v)); ------------------ 903| 2|} dst_api.c:isc_buffer_remainingregion: 730| 91|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 731| 91| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 91, False: 0] | | | | | Branch (42:11): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 91| REQUIRE(r != NULL); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| | 734| 91| r->base = isc_buffer_current(b); ------------------ | | 145| 91| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 735| 91| r->length = isc_buffer_remaininglength(b); ------------------ | | 159| 91|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 736| 91|} dst_api.c:isc_buffer_getuint16: 888| 91|isc_buffer_getuint16(isc_buffer_t *restrict b) { 889| 91| uint16_t val = 0; 890| 91| isc_result_t result = isc_buffer_peekuint16(b, &val); 891| 91| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 91|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 91, False: 0] | | | | ------------------ | | | | 49| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 892| 91| b->current += sizeof(val); 893| 91| return val; 894| 91|} dst_api.c:isc_buffer_peekuint16: 878| 91|isc_buffer_peekuint16(const isc_buffer_t *restrict b, uint16_t *valp) { 879| 91| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 91| { \ | | 832| 91| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 182| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 91, False: 0] | | | | | | | Branch (42:11): [True: 91, False: 0] | | | | | | ------------------ | | | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 91| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 91] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 91| } ------------------ 880| | 881| 91| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 91| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 882| | 883| | SET_IF_NOT_NULL(valp, ISC_U8TO16_BE(cp)); ------------------ | | 104| 91| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 91, False: 0] | | ------------------ | | 105| 91| *(obj) = (val); \ | | 106| 91| } ------------------ 884| 91| return ISC_R_SUCCESS; 885| 91|} dst_api.c:isc_buffer_getuint8: 848| 182|isc_buffer_getuint8(isc_buffer_t *restrict b) { 849| 182| uint8_t val = 0; 850| 182| isc_result_t result = isc_buffer_peekuint8(b, &val); 851| 182| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 182|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 182, False: 0] | | | | ------------------ | | | | 49| 182| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 852| 182| b->current += sizeof(val); 853| 182| return val; 854| 182|} dst_api.c:isc_buffer_peekuint8: 839| 182|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 840| 182| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 182| { \ | | 832| 182| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 182|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 364| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 182, False: 0] | | | | | | | Branch (42:11): [True: 182, False: 0] | | | | | | ------------------ | | | | | | 43| 182| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 182| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 182] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 182| } ------------------ 841| | 842| 182| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 182| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 843| | SET_IF_NOT_NULL(valp, (uint8_t)(cp[0])); ------------------ | | 104| 182| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 182, False: 0] | | ------------------ | | 105| 182| *(obj) = (val); \ | | 106| 182| } ------------------ 844| 182| return ISC_R_SUCCESS; 845| 182|} dst_api.c:isc_buffer_usedregion: 616| 2| isc_region_t *restrict r) { 617| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 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); ------------------ | | 198| 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| 34| const unsigned int length) { 525| 34| REQUIRE(b != NULL); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 34| *b = (isc_buffer_t){ 528| 34| .base = base, 529| 34| .length = length, 530| 34| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 34|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 34| { \ | | | | 27| 34| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 34|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 34| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 34|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 34| } | | ------------------ ------------------ 531| 34| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 34|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 34| }; 533| 34|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 276| 0| { \ | | 277| 0| isc_result_t _r = (x); \ | | 278| 0| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 0] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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| 91|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 731| 91| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 91, False: 0] | | | | | Branch (42:11): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 732| 91| REQUIRE(r != NULL); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 733| | 734| 91| r->base = isc_buffer_current(b); ------------------ | | 145| 91| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 735| 91| r->length = isc_buffer_remaininglength(b); ------------------ | | 159| 91|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 736| 91|} opensslrsa_link.c:isc_buffer_forward: 806| 91|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 91| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 91, False: 0] | | | | | Branch (42:11): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 91| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 91, False: 0] | | | | ------------------ | | | | 43| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 91| b->current += n; 811| 91|} ossl3.c:isc_buffer_add: 652| 34|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 34| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 68| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 34, False: 0] | | | | | Branch (42:11): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 34| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 34|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 34, False: 0] | | | | ------------------ | | | | 43| 34| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 34| b->used += n; 657| 34|} 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 144| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174: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)); ------------------ | | 198| 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); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174: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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 296| 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); ------------------ | | 144| 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, ------------------ | | 152| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 153| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 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)); \ | | ------------------ | | | | 198| 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); \ | | ------------------ | | | | 200| 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); \ | | ------------------ | | | | 198| 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); ------------------ | | 200| 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)); \ | | ------------------ | | | | 198| 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])); ------------------ | | 104| 946| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 946, False: 0] | | ------------------ | | 105| 946| *(obj) = (val); \ | | 106| 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)); ------------------ | | 198| 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| 711|isc_hash32(const void *data, const size_t length, const bool case_sensitive) { 54| 711| isc_hash32_t state; 55| 711| isc_hash32_init(&state); 56| 711| isc_hash32_hash(&state, data, length, case_sensitive); 57| 711| return isc_hash32_finalize(&state); 58| 711|} hashmap.c:isc_hash_bits32: 114| 711|isc_hash_bits32(uint32_t val, unsigned int bits) { 115| 711| ISC_REQUIRE(bits <= ISC_HASH_MAX_BITS); ------------------ | | 42| 711| ((void)((cond) || \ | | ------------------ | | | Branch (42:10): [True: 711, False: 0] | | ------------------ | | 43| 711| ((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| 711| return val * ISC_HASH_GOLDENRATIO_32 >> (32 - bits); ------------------ | | 111| 711|#define ISC_HASH_GOLDENRATIO_32 0x61C88647 ------------------ 118| 711|} isc_lib_initialize: 57| 2|isc_lib_initialize(void) { 58| 2| isc__lib_initialize(); 59| 2|} dns_tsigkeyring_attach: 222| 1.14k| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 1.14k| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 1.14k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.29k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.14k, False: 0] | | | | | Branch (42:11): [True: 1.14k, False: 0] | | | | ------------------ | | | | 43| 1.14k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 1.14k| name##_ref(ptr); \ 225| 1.14k| *ptrp = ptr; \ 226| 1.14k| } \ dns_tsigkey_attach: 222| 260| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 260| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 260|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 520| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 260, False: 0] | | | | | Branch (42:11): [True: 260, False: 0] | | | | ------------------ | | | | 43| 260| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 260| name##_ref(ptr); \ 225| 260| *ptrp = ptr; \ 226| 260| } \ dns_zone_attach: 222| 200| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 200| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 200|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 400| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 200, False: 0] | | | | | Branch (42:11): [True: 200, False: 0] | | | | ------------------ | | | | 43| 200| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 200| name##_ref(ptr); \ 225| 200| *ptrp = ptr; \ 226| 200| } \ dns_db_attach: 222| 204| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 204| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 204|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 408| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 204, False: 0] | | | | | Branch (42:11): [True: 204, False: 0] | | | | ------------------ | | | | 43| 204| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 204| name##_ref(ptr); \ 225| 204| *ptrp = ptr; \ 226| 204| } \ isc_loop_attach: 222| 4| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 4| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 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.65k| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 5.65k| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 5.65k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 11.3k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.65k, False: 0] | | | | | Branch (42:11): [True: 5.65k, False: 0] | | | | ------------------ | | | | 43| 5.65k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 224| 5.65k| name##_ref(ptr); \ 225| 5.65k| *ptrp = ptr; \ 226| 5.65k| } \ hash.c:isc_halfsiphash13_init: 633| 711|isc_halfsiphash13_init(isc_halfsiphash24_t *restrict state, const uint8_t *k) { 634| 711| REQUIRE(k != NULL); ------------------ | | 198| 711|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 711| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 711, False: 0] | | | | ------------------ | | | | 43| 711| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 635| | 636| 711| uint32_t k0 = ISC_U8TO32_LE(k); ------------------ | | 188| 711| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 189| 711| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 637| 711| uint32_t k1 = ISC_U8TO32_LE(k + 4); ------------------ | | 188| 711| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 189| 711| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 638| | 639| 711| *state = (isc_halfsiphash24_t){ 640| 711| .k0 = k0, 641| 711| .k1 = k1, 642| 711| .v0 = UINT32_C(0x00000000) ^ k0, 643| 711| .v1 = UINT32_C(0x00000000) ^ k1, 644| 711| .v2 = UINT32_C(0x6c796765) ^ k0, 645| | .v3 = UINT32_C(0x74656462) ^ k1, 646| 711| }; 647| 711|} hash.c:isc_halfsiphash13_hash: 662| 711| const size_t inlen, const bool case_sensitive) { 663| 711| REQUIRE(inlen == 0 || in != NULL); ------------------ | | 198| 711|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.42k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 711] | | | | | Branch (42:11): [True: 711, False: 0] | | | | ------------------ | | | | 43| 711| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 664| | 665| 711| if (in == NULL || inlen == 0) { ------------------ | Branch (665:6): [True: 0, False: 711] | Branch (665:20): [True: 0, False: 711] ------------------ 666| 0| return; 667| 0| } 668| | 669| 711| size_t len = inlen; 670| 711| const int right = state->inlen & 3; 671| | 672| 711| switch (right) { 673| 711| case 0: ------------------ | Branch (673:2): [True: 711, False: 0] ------------------ 674| 711| break; 675| 0| case 1: ------------------ | Branch (675:2): [True: 0, False: 711] ------------------ 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: 711] ------------------ 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: 711] ------------------ 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: 711] ------------------ 706| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 707| 711| } 708| | 709| 711| const uint8_t *end = in + len - (len % sizeof(uint32_t)); 710| 711| const int left = len & 3; 711| | 712| 2.13k| for (; in != end; in += 4) { ------------------ | Branch (712:9): [True: 1.42k, False: 711] ------------------ 713| 1.42k| uint32_t m = case_sensitive ------------------ | Branch (713:16): [True: 0, False: 1.42k] ------------------ 714| 1.42k| ? ISC_U8TO32_LE(in) ------------------ | | 188| 0| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 189| 0| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 715| 1.42k| : isc_ascii_tolower4(ISC_U8TO32_LE(in)); ------------------ | | 188| 1.42k| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 189| 1.42k| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 716| | 717| 1.42k| isc_halfsiphash13_one(state, m); 718| 1.42k| } 719| | 720| 711| INSIST(state->b == 0); ------------------ | | 202| 711|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 711| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 711, False: 0] | | | | ------------------ | | | | 55| 711| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 721| 711| switch (left) { 722| 0| case 3: ------------------ | Branch (722:2): [True: 0, False: 711] ------------------ 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| 711| case 2: ------------------ | Branch (725:2): [True: 711, False: 0] ------------------ 726| 711| state->b |= U8TO32_ONE(case_sensitive, in[1]) << 8; ------------------ | | 77| 711| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 711] | | ------------------ ------------------ 727| 711| FALLTHROUGH; ------------------ | | 101| 711|#define FALLTHROUGH [[fallthrough]] ------------------ 728| 711| case 1: ------------------ | Branch (728:2): [True: 0, False: 711] ------------------ 729| 711| state->b |= U8TO32_ONE(case_sensitive, in[0]); ------------------ | | 77| 711| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 711] | | ------------------ ------------------ 730| 711| FALLTHROUGH; ------------------ | | 101| 711|#define FALLTHROUGH [[fallthrough]] ------------------ 731| 711| case 0: ------------------ | Branch (731:2): [True: 0, False: 711] ------------------ 732| 711| break; 733| 0| default: ------------------ | Branch (733:2): [True: 0, False: 711] ------------------ 734| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 735| 711| } 736| | 737| 711| state->inlen += len; 738| 711|} hash.c:isc_halfsiphash13_one: 650| 2.13k|isc_halfsiphash13_one(isc_halfsiphash13_t *restrict state, const uint32_t m) { 651| 2.13k| state->v3 ^= m; 652| | 653| 4.26k| for (size_t i = 0; i < cROUNDS_13; ++i) { ------------------ | | 47| 4.26k|#define cROUNDS_13 1 ------------------ | Branch (653:21): [True: 2.13k, False: 2.13k] ------------------ 654| 2.13k| HALFSIPROUND(state->v0, state->v1, state->v2, state->v3); ------------------ | | 74| 2.13k|#define HALFSIPROUND FULL_ROUND32 | | ------------------ | | | | 71| 2.13k| HALF_ROUND32(v0, v1, v2, v3, 5, 8); \ | | | | ------------------ | | | | | | 64| 2.13k| a += b; \ | | | | | | 65| 2.13k| c += d; \ | | | | | | 66| 2.13k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 2.13k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 2.13k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | | | 72| 2.13k| HALF_ROUND32(v2, v1, v0, v3, 13, 7); | | | | ------------------ | | | | | | 64| 2.13k| a += b; \ | | | | | | 65| 2.13k| c += d; \ | | | | | | 66| 2.13k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 2.13k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 2.13k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 655| 2.13k| } 656| | 657| 2.13k| state->v0 ^= m; 658| 2.13k|} hash.c:isc_halfsiphash13_finalize: 741| 711|isc_halfsiphash13_finalize(isc_halfsiphash13_t *restrict state, uint8_t *out) { 742| 711| REQUIRE(out != NULL); ------------------ | | 198| 711|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 711| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 711, False: 0] | | | | ------------------ | | | | 43| 711| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 743| | 744| 711| uint32_t b = ((uint32_t)state->inlen) << 24 | state->b; 745| | 746| 711| isc_halfsiphash13_one(state, b); 747| | 748| 711| state->v2 ^= 0xff; 749| | 750| 2.84k| for (size_t i = 0; i < dROUNDS_13; ++i) { ------------------ | | 48| 2.84k|#define dROUNDS_13 3 ------------------ | Branch (750:21): [True: 2.13k, False: 711] ------------------ 751| 2.13k| HALFSIPROUND(state->v0, state->v1, state->v2, state->v3); ------------------ | | 74| 2.13k|#define HALFSIPROUND FULL_ROUND32 | | ------------------ | | | | 71| 2.13k| HALF_ROUND32(v0, v1, v2, v3, 5, 8); \ | | | | ------------------ | | | | | | 64| 2.13k| a += b; \ | | | | | | 65| 2.13k| c += d; \ | | | | | | 66| 2.13k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 2.13k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 2.13k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | | | 72| 2.13k| HALF_ROUND32(v2, v1, v0, v3, 13, 7); | | | | ------------------ | | | | | | 64| 2.13k| a += b; \ | | | | | | 65| 2.13k| c += d; \ | | | | | | 66| 2.13k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 2.13k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 2.13k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 2.13k| _Generic((x), \ | | | | | | | | 134| 2.13k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 2.13k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 2.13k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 2.13k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 752| 2.13k| } 753| | 754| 711| b = state->v1 ^ state->v3; 755| 711| ISC_U32TO8_LE(out, b); ------------------ | | 182| 711| (p)[0] = (uint8_t)((v)); \ | | 183| 711| (p)[1] = (uint8_t)((v) >> 8); \ | | 184| 711| (p)[2] = (uint8_t)((v) >> 16); \ | | 185| 711| (p)[3] = (uint8_t)((v) >> 24); ------------------ 756| 711|} qp.c:isc_tid: 39| 1.26k|isc_tid(void) { 40| 1.26k| return isc__tid_local; 41| 1.26k|} mem.c:isc_tid: 39| 6.92M|isc_tid(void) { 40| 6.92M| return isc__tid_local; 41| 6.92M|} 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); ------------------ | | 202| 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); ------------------ | | 202| 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], ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 155| 2| NULL) == 1); 156| | initialized = true; 157| 2|} mem.c:mallocx: 109| 3.46M|mallocx(size_t size, int flags) { 110| 3.46M| size_t alignment = MALLOCX_ALIGN_GET(flags); ------------------ | | 74| 3.46M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 3.46M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 111| 3.46M| size_t header_size = get_header_size(flags); 112| 3.46M| size_info *si; 113| | 114| 3.46M| if (MALLOCX_NEEDS_ALIGN(flags)) { ------------------ | | 81| 3.46M| (MALLOCX_ALIGN_GET(flags) > _Alignof(max_align_t)) | | ------------------ | | | | 74| 3.46M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | | | ------------------ | | | | | | 64| 3.46M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | | | ------------------ | | ------------------ | | | Branch (81:2): [True: 12, False: 3.46M] | | ------------------ ------------------ 115| 12| size_t bytes = ISC_CHECKED_ADD( ------------------ | | 40| 12| ({ \ | | 41| 12| typeof(a) _c; \ | | 42| 12| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 12| INSIST(!_overflow); \ | | ------------------ | | | | 202| 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))) | | | | ------------------ | | ------------------ | | 44| 12| _c; \ | | 45| 12| }) ------------------ 116| 12| get_aligned_size(alignment, size), header_size); 117| 12| si = aligned_alloc(alignment, bytes); 118| 3.46M| } else { 119| 3.46M| si = malloc(ISC_CHECKED_ADD(size, header_size)); ------------------ | | 40| 3.46M| ({ \ | | 41| 3.46M| typeof(a) _c; \ | | 42| 3.46M| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 3.46M| INSIST(!_overflow); \ | | ------------------ | | | | 202| 3.46M|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 3.46M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 3.46M, False: 0] | | | | | | ------------------ | | | | | | 55| 3.46M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 3.46M| _c; \ | | 45| 3.46M| }) ------------------ 120| 3.46M| } 121| 3.46M| if (si == NULL) { ------------------ | Branch (121:6): [True: 0, False: 3.46M] ------------------ 122| 0| return NULL; 123| 0| } 124| 3.46M| si->size = size; 125| 3.46M| si->flags = flags; 126| | 127| 3.46M| void *ptr = (uint8_t *)si + header_size; 128| 3.46M| if (MALLOCX_ZERO_GET(flags)) { ------------------ | | 62| 3.46M|#define MALLOCX_ZERO_GET(flags) ((bool)(flags & MALLOCX_ZERO)) | | ------------------ | | | | 61| 3.46M|#define MALLOCX_ZERO ((int)0x40) | | ------------------ | | | Branch (62:33): [True: 22, False: 3.46M] | | ------------------ ------------------ 129| 22| memset(ptr, 0, size); 130| 22| } 131| | 132| 3.46M| return ptr; 133| 3.46M|} mem.c:get_header_size: 99| 10.3M|get_header_size(int flags) { 100| 10.3M| return get_aligned_size(MALLOCX_ALIGN_GET(flags), sizeof(size_info)); ------------------ | | 74| 10.3M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 10.3M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 101| 10.3M|} mem.c:get_aligned_size: 31| 10.3M|get_aligned_size(size_t alignment, size_t size) { 32| | /* 33| | * C23 dropped the requirement that size be an integral multiple of 34| | * alignment, but some implementations still enforce it at runtime, 35| | * so round the size up. 36| | */ 37| | return ISC_CHECKED_ADD(size, alignment - 1) & ~(alignment - 1); ------------------ | | 40| 10.3M| ({ \ | | 41| 10.3M| typeof(a) _c; \ | | 42| 10.3M| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 10.3M| INSIST(!_overflow); \ | | ------------------ | | | | 202| 10.3M|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 10.3M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 10.3M, False: 0] | | | | | | ------------------ | | | | | | 55| 10.3M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 10.3M| _c; \ | | 45| 10.3M| }) ------------------ 38| 10.3M|} mem.c:sdallocx: 136| 3.46M|sdallocx(void *ptr, size_t size, int flags) { 137| 3.46M| size_info *si = get_size_info(ptr, flags); 138| 3.46M| size_t alignment = MALLOCX_ALIGN_GET(flags); ------------------ | | 74| 3.46M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 3.46M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 139| 3.46M| size_t header_size = get_header_size(flags); 140| | 141| 3.46M| INSIST((flags & MALLOCX_LG_ALIGN_MASK) == ------------------ | | 202| 3.46M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 3.46M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 3.46M, False: 0] | | | | ------------------ | | | | 55| 3.46M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 142| 3.46M| (si->flags & MALLOCX_LG_ALIGN_MASK)); 143| | 144| 3.46M| if (MALLOCX_NEEDS_ALIGN(flags)) { ------------------ | | 81| 3.46M| (MALLOCX_ALIGN_GET(flags) > _Alignof(max_align_t)) | | ------------------ | | | | 74| 3.46M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | | | ------------------ | | | | | | 64| 3.46M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | | | ------------------ | | ------------------ | | | Branch (81:2): [True: 0, False: 3.46M] | | ------------------ ------------------ 145| 0| size_t bytes = ISC_CHECKED_ADD( ------------------ | | 40| 0| ({ \ | | 41| 0| typeof(a) _c; \ | | 42| 0| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 0| INSIST(!_overflow); \ | | ------------------ | | | | 202| 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))) | | | | ------------------ | | ------------------ | | 44| 0| _c; \ | | 45| 0| }) ------------------ 146| 0| get_aligned_size(alignment, size), header_size); 147| 0| free_aligned_sized(si, alignment, bytes); 148| 3.46M| } else { 149| | free_sized(si, ISC_CHECKED_ADD(si->size, header_size)); ------------------ | | 40| 3.46M| ({ \ | | 41| 3.46M| typeof(a) _c; \ | | 42| 3.46M| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 3.46M| INSIST(!_overflow); \ | | ------------------ | | | | 202| 3.46M|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 3.46M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 3.46M, False: 0] | | | | | | ------------------ | | | | | | 55| 3.46M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 3.46M| _c; \ | | 45| 3.46M| }) ------------------ 150| 3.46M| } 151| 3.46M|} mem.c:get_size_info: 104| 3.46M|get_size_info(void *ptr, int flags) { 105| 3.46M| return (size_info *)((uint8_t *)ptr - get_header_size(flags)); 106| 3.46M|} mem.c:free_sized: 42| 3.46M|free_sized(void *ptr, size_t size ISC_ATTR_UNUSED) { 43| 3.46M| free(ptr); 44| 3.46M|} mem.c:sallocx: 154| 78|sallocx(void *ptr, int flags) { 155| 78| size_info *si = get_size_info(ptr, flags); 156| | 157| 78| return si[0].size; 158| 78|} 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); ------------------ | | 198| 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)); ------------------ | | 144| 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); ------------------ | | 144| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245: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); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 2] | | ------------------ ------------------ 131| 2| } 132| 2| lex->magic = 0; 133| | isc_mem_put(lex->mctx, lex, sizeof(*lex)); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174: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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 276| 2| { \ | | 277| 2| isc_result_t _r = (x); \ | | 278| 2| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 2] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 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)); ------------------ | | 198| 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); ------------------ | | 197| 2| do { \ | | 198| 2| isc__mem_free((c), (p), 0 _ISC_MEM_FILELINE); \ | | 199| 2| (p) = NULL; \ | | 200| 2| } while (0) | | ------------------ | | | Branch (200:11): [Folded, False: 2] | | ------------------ ------------------ 271| 2| isc_buffer_free(&source->pushback); 272| 2| isc_mem_put(lex->mctx, source, sizeof(*source)); ------------------ | | 171| 2| do { \ | | 172| 2| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2| (p) = NULL; \ | | 174| 2| } while (0) | | ------------------ | | | Branch (174: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)); ------------------ | | 198| 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); ------------------ | | 198| 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 (c == '\0') { ------------------ | Branch (543:15): [True: 0, False: 66] ------------------ 544| 0| tokenp->type = isc_tokentype_unknown; 545| 0| tokenp->value.as_char = c; 546| 0| done = true; 547| 66| } else if (lex->specials[c]) { ------------------ | Branch (547:15): [True: 0, False: 66] ------------------ 548| 0| lex->last_was_eol = false; 549| 0| if ((c == '(' || c == ')') && ------------------ | Branch (549:10): [True: 0, False: 0] | Branch (549:22): [True: 0, False: 0] ------------------ 550| 0| (options & ISC_LEXOPT_DNSMULTILINE) != 0) ------------------ | | 77| 0|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (550:9): [True: 0, False: 0] ------------------ 551| 0| { 552| 0| if (c == '(') { ------------------ | Branch (552:10): [True: 0, False: 0] ------------------ 553| 0| if (lex->paren_count == 0) { ------------------ | Branch (553:11): [True: 0, False: 0] ------------------ 554| 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. */ | | ------------------ ------------------ 555| 0| } 556| 0| lex->paren_count++; 557| 0| } else { 558| 0| if (lex->paren_count == 0) { ------------------ | Branch (558:11): [True: 0, False: 0] ------------------ 559| 0| result = 560| 0| ISC_R_UNBALANCED; 561| 0| goto done; 562| 0| } 563| 0| lex->paren_count--; 564| 0| if (lex->paren_count == 0) { ------------------ | Branch (564:11): [True: 0, False: 0] ------------------ 565| 0| options = saved_options; 566| 0| } 567| 0| } 568| 0| continue; 569| 0| } else if (c == '{' && ------------------ | Branch (569:16): [True: 0, False: 0] ------------------ 570| 0| (options & ISC_LEXOPT_BTEXT) != 0) ------------------ | | 84| 0|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (570:9): [True: 0, False: 0] ------------------ 571| 0| { 572| 0| if (lex->brace_count != 0) { ------------------ | Branch (572:10): [True: 0, False: 0] ------------------ 573| 0| result = ISC_R_UNBALANCED; 574| 0| goto done; 575| 0| } 576| 0| lex->brace_count++; 577| 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. */ | | ------------------ ------------------ 578| 0| state = lexstate_btext; 579| 0| no_comments = true; 580| 0| continue; 581| 0| } 582| 0| tokenp->type = isc_tokentype_special; 583| 0| tokenp->value.as_char = c; 584| 0| done = true; 585| 66| } else if (isdigit((unsigned char)c) && ------------------ | Branch (585:15): [True: 24, False: 42] ------------------ 586| 24| (options & ISC_LEXOPT_NUMBER) != 0) ------------------ | | 65| 24|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ | Branch (586:8): [True: 2, False: 22] ------------------ 587| 2| { 588| 2| lex->last_was_eol = false; 589| 2| if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (589:9): [True: 0, False: 2] ------------------ 590| 0| (c == '8' || c == '9')) ------------------ | Branch (590:10): [True: 0, False: 0] | Branch (590:22): [True: 0, False: 0] ------------------ 591| 0| { 592| 0| state = lexstate_string; 593| 2| } else { 594| 2| state = lexstate_number; 595| 2| } 596| 2| goto no_read; 597| 64| } else { 598| 64| lex->last_was_eol = false; 599| 64| state = lexstate_string; 600| 64| goto no_read; 601| 64| } 602| 68| break; 603| 68| case lexstate_crlf: ------------------ | Branch (603:3): [True: 0, False: 1.01k] ------------------ 604| 0| if (c != '\n') { ------------------ | Branch (604:8): [True: 0, False: 0] ------------------ 605| 0| pushback(source, c); 606| 0| } 607| 0| tokenp->type = isc_tokentype_eol; 608| 0| done = true; 609| 0| lex->last_was_eol = true; 610| 0| break; 611| 4| case lexstate_number: ------------------ | Branch (611:3): [True: 4, False: 1.01k] ------------------ 612| 4| if (c == EOF || !isdigit((unsigned char)c)) { ------------------ | Branch (612:8): [True: 0, False: 4] | Branch (612:20): [True: 2, False: 2] ------------------ 613| 2| if (c == ' ' || c == '\t' || c == '\r' || ------------------ | Branch (613:9): [True: 2, False: 0] | Branch (613:21): [True: 0, False: 0] | Branch (613:34): [True: 0, False: 0] ------------------ 614| 0| c == '\n' || c == '\0' || c == EOF || ------------------ | Branch (614:9): [True: 0, False: 0] | Branch (614:22): [True: 0, False: 0] | Branch (614:35): [True: 0, False: 0] ------------------ 615| 0| lex->specials[c]) ------------------ | Branch (615:9): [True: 0, False: 0] ------------------ 616| 2| { 617| 2| int base; 618| 2| if ((options & ISC_LEXOPT_OCTAL) != 0) { ------------------ | | 83| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (618:10): [True: 0, False: 2] ------------------ 619| 0| base = 8; 620| 2| } else if ((options & ------------------ | Branch (620:17): [True: 0, False: 2] ------------------ 621| 2| ISC_LEXOPT_CNUMBER) != 0) ------------------ | | 80| 2|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ 622| 0| { 623| 0| base = 0; 624| 2| } else { 625| 2| base = 10; 626| 2| } 627| 2| pushback(source, c); 628| | 629| 2| result = isc_parse_uint32( 630| 2| &as_ulong, lex->data, base); 631| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (631:10): [True: 2, False: 0] ------------------ 632| 2| tokenp->type = 633| 2| isc_tokentype_number; 634| 2| tokenp->value.as_ulong = 635| 2| as_ulong; 636| 2| } else if (result == ISC_R_BADNUMBER) { ------------------ | Branch (636:17): [True: 0, False: 0] ------------------ 637| 0| isc_tokenvalue_t *v; 638| | 639| 0| tokenp->type = 640| 0| isc_tokentype_string; 641| 0| v = &(tokenp->value); 642| 0| v->as_textregion.base = 643| 0| lex->data; 644| 0| v->as_textregion.length = 645| 0| (unsigned int)(lex->max_token - 646| 0| remaining); 647| 0| } else { 648| 0| goto done; 649| 0| } 650| 2| done = true; 651| 2| continue; 652| 2| } else if ((options & ISC_LEXOPT_CNUMBER) == ------------------ | | 80| 0|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ | Branch (652:16): [True: 0, False: 0] ------------------ 653| 0| 0 || 654| 0| ((c != 'x' && c != 'X') || ------------------ | Branch (654:11): [True: 0, False: 0] | Branch (654:23): [True: 0, False: 0] ------------------ 655| 0| (curr != &lex->data[1]) || ------------------ | Branch (655:10): [True: 0, False: 0] ------------------ 656| 0| (lex->data[0] != '0'))) ------------------ | Branch (656:10): [True: 0, False: 0] ------------------ 657| 0| { 658| | /* Above test supports hex numbers */ 659| 0| state = lexstate_string; 660| 0| } 661| 2| } else if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (661:15): [True: 0, False: 2] ------------------ 662| 0| (c == '8' || c == '9')) ------------------ | Branch (662:9): [True: 0, False: 0] | Branch (662:21): [True: 0, False: 0] ------------------ 663| 0| { 664| 0| state = lexstate_string; 665| 0| } 666| 2| if (remaining == 0U) { ------------------ | Branch (666:8): [True: 0, False: 2] ------------------ 667| 0| grow_data(lex, &remaining, &curr, &prev); 668| 0| } 669| 2| INSIST(remaining > 0U); ------------------ | | 202| 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))) | | ------------------ ------------------ 670| 2| *curr++ = c; 671| 2| *curr = '\0'; 672| 2| remaining--; 673| 2| break; 674| 876| case lexstate_string: ------------------ | Branch (674:3): [True: 876, False: 138] ------------------ 675| 876| if (!escaped && c == '=' && ------------------ | Branch (675:8): [True: 876, False: 0] | Branch (675:20): [True: 2, False: 874] ------------------ 676| 2| (options & ISC_LEXOPT_VPAIR) != 0) ------------------ | | 85| 2|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ | Branch (676:8): [True: 0, False: 2] ------------------ 677| 0| { 678| 0| if (remaining == 0U) { ------------------ | Branch (678:9): [True: 0, False: 0] ------------------ 679| 0| grow_data(lex, &remaining, &curr, 680| 0| &prev); 681| 0| } 682| 0| INSIST(remaining > 0U); ------------------ | | 202| 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))) | | ------------------ ------------------ 683| 0| *curr++ = c; 684| 0| *curr = '\0'; 685| 0| remaining--; 686| 0| state = lexstate_vpairstart; 687| 0| break; 688| 0| } 689| 876| FALLTHROUGH; ------------------ | | 101| 876|#define FALLTHROUGH [[fallthrough]] ------------------ 690| 876| case lexstate_vpairstart: ------------------ | Branch (690:3): [True: 0, False: 1.01k] ------------------ 691| 876| if (state == lexstate_vpairstart) { ------------------ | Branch (691:8): [True: 0, False: 876] ------------------ 692| 0| if (c == '"' && ------------------ | Branch (692:9): [True: 0, False: 0] ------------------ 693| 0| (options & ISC_LEXOPT_QVPAIR) != 0) ------------------ | | 86| 0|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ | Branch (693:9): [True: 0, False: 0] ------------------ 694| 0| { 695| 0| no_comments = true; 696| 0| state = lexstate_qvpair; 697| 0| break; 698| 0| } 699| 0| state = lexstate_vpair; 700| 0| } 701| 876| FALLTHROUGH; ------------------ | | 101| 876|#define FALLTHROUGH [[fallthrough]] ------------------ 702| 876| case lexstate_vpair: ------------------ | Branch (702:3): [True: 0, False: 1.01k] ------------------ 703| | /* 704| | * EOF needs to be checked before lex->specials[c] 705| | * as lex->specials[EOF] is not a good idea. 706| | */ 707| 876| if (c == '\r' || c == '\n' || c == EOF || ------------------ | Branch (707:8): [True: 0, False: 876] | Branch (707:21): [True: 8, False: 868] | Branch (707:34): [True: 0, False: 868] ------------------ 708| 868| (!escaped && (c == ' ' || c == '\t' || c == '\0' || ------------------ | Branch (708:9): [True: 868, False: 0] | Branch (708:22): [True: 56, False: 812] | Branch (708:34): [True: 0, False: 812] | Branch (708:47): [True: 0, False: 812] ------------------ 709| 812| lex->specials[c]))) ------------------ | Branch (709:8): [True: 0, False: 812] ------------------ 710| 64| { 711| 64| pushback(source, c); 712| 64| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (712:9): [True: 0, False: 64] ------------------ 713| 0| result = source->result; 714| 0| goto done; 715| 0| } 716| 64| if (escaped && c == EOF) { ------------------ | Branch (716:9): [True: 0, False: 64] | Branch (716:20): [True: 0, False: 0] ------------------ 717| 0| result = ISC_R_UNEXPECTEDEND; 718| 0| goto done; 719| 0| } 720| 64| tokenp->type = (state == lexstate_string) ------------------ | Branch (720:20): [True: 64, False: 0] ------------------ 721| 64| ? isc_tokentype_string 722| 64| : isc_tokentype_vpair; 723| 64| tokenp->value.as_textregion.base = lex->data; 724| 64| tokenp->value.as_textregion.length = 725| 64| (unsigned int)(lex->max_token - 726| 64| remaining); 727| 64| done = true; 728| 64| continue; 729| 64| } 730| 812| if ((options & ISC_LEXOPT_ESCAPE) != 0) { ------------------ | | 81| 812|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ | Branch (730:8): [True: 812, False: 0] ------------------ 731| 812| escaped = (!escaped && c == '\\') ? true ------------------ | Branch (731:16): [True: 812, False: 0] | Branch (731:28): [True: 0, False: 812] ------------------ 732| 812| : false; 733| 812| } 734| 812| if (remaining == 0U) { ------------------ | Branch (734:8): [True: 0, False: 812] ------------------ 735| 0| grow_data(lex, &remaining, &curr, &prev); 736| 0| } 737| 812| INSIST(remaining > 0U); ------------------ | | 202| 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))) | | ------------------ ------------------ 738| 812| *curr++ = c; 739| 812| *curr = '\0'; 740| 812| remaining--; 741| 812| break; 742| 0| case lexstate_maybecomment: ------------------ | Branch (742:3): [True: 0, False: 1.01k] ------------------ 743| 0| if (c == '*' && (lex->comments & ISC_LEXCOMMENT_C) != 0) ------------------ | | 94| 0|#define ISC_LEXCOMMENT_C 0x01 ------------------ | Branch (743:8): [True: 0, False: 0] | Branch (743:20): [True: 0, False: 0] ------------------ 744| 0| { 745| 0| state = lexstate_ccomment; 746| 0| continue; 747| 0| } else if (c == '/' && (lex->comments & ------------------ | Branch (747:15): [True: 0, False: 0] | Branch (747:27): [True: 0, False: 0] ------------------ 748| 0| ISC_LEXCOMMENT_CPLUSPLUS) != 0) ------------------ | | 95| 0|#define ISC_LEXCOMMENT_CPLUSPLUS 0x02 ------------------ 749| 0| { 750| 0| state = lexstate_eatline; 751| 0| continue; 752| 0| } 753| 0| pushback(source, c); 754| 0| c = '/'; 755| 0| no_comments = false; 756| 0| state = saved_state; 757| 0| goto no_read; 758| 0| case lexstate_ccomment: ------------------ | Branch (758:3): [True: 0, False: 1.01k] ------------------ 759| 0| if (c == EOF) { ------------------ | Branch (759:8): [True: 0, False: 0] ------------------ 760| 0| result = ISC_R_UNEXPECTEDEND; 761| 0| goto done; 762| 0| } 763| 0| if (c == '*') { ------------------ | Branch (763:8): [True: 0, False: 0] ------------------ 764| 0| state = lexstate_ccommentend; 765| 0| } 766| 0| break; 767| 0| case lexstate_ccommentend: ------------------ | Branch (767:3): [True: 0, False: 1.01k] ------------------ 768| 0| if (c == EOF) { ------------------ | Branch (768:8): [True: 0, False: 0] ------------------ 769| 0| result = ISC_R_UNEXPECTEDEND; 770| 0| goto done; 771| 0| } 772| 0| if (c == '/') { ------------------ | Branch (772:8): [True: 0, False: 0] ------------------ 773| | /* 774| | * C-style comments become a single space. 775| | * We do this to ensure that a comment will 776| | * act as a delimiter for strings and 777| | * numbers. 778| | */ 779| 0| c = ' '; 780| 0| no_comments = false; 781| 0| state = saved_state; 782| 0| goto no_read; 783| 0| } else if (c != '*') { ------------------ | Branch (783:15): [True: 0, False: 0] ------------------ 784| 0| state = lexstate_ccomment; 785| 0| } 786| 0| break; 787| 0| case lexstate_eatline: ------------------ | Branch (787:3): [True: 0, False: 1.01k] ------------------ 788| 0| if ((c == '\n') || (c == EOF)) { ------------------ | Branch (788:8): [True: 0, False: 0] | Branch (788:23): [True: 0, False: 0] ------------------ 789| 0| no_comments = false; 790| 0| state = saved_state; 791| 0| goto no_read; 792| 0| } 793| 0| break; 794| 0| case lexstate_qstring: ------------------ | Branch (794:3): [True: 0, False: 1.01k] ------------------ 795| 0| case lexstate_qvpair: ------------------ | Branch (795:3): [True: 0, False: 1.01k] ------------------ 796| 0| if (c == EOF) { ------------------ | Branch (796:8): [True: 0, False: 0] ------------------ 797| 0| result = ISC_R_UNEXPECTEDEND; 798| 0| goto done; 799| 0| } 800| 0| if (c == '"') { ------------------ | Branch (800:8): [True: 0, False: 0] ------------------ 801| 0| if (escaped) { ------------------ | Branch (801:9): [True: 0, False: 0] ------------------ 802| 0| escaped = false; 803| | /* 804| | * Overwrite the preceding backslash. 805| | */ 806| 0| INSIST(prev != NULL); ------------------ | | 202| 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))) | | ------------------ ------------------ 807| 0| *prev = '"'; 808| 0| } else { 809| 0| tokenp->type = 810| 0| (state == lexstate_qstring) ------------------ | Branch (810:7): [True: 0, False: 0] ------------------ 811| 0| ? isc_tokentype_qstring 812| 0| : isc_tokentype_qvpair; 813| 0| tokenp->value.as_textregion.base = 814| 0| lex->data; 815| 0| tokenp->value.as_textregion.length = 816| 0| (unsigned int)(lex->max_token - 817| 0| remaining); 818| 0| no_comments = false; 819| 0| done = true; 820| 0| } 821| 0| } else { 822| 0| if (c == '\n' && !escaped && ------------------ | Branch (822:9): [True: 0, False: 0] | Branch (822:22): [True: 0, False: 0] ------------------ 823| 0| (options & ISC_LEXOPT_QSTRINGMULTILINE) == ------------------ | | 82| 0|#define ISC_LEXOPT_QSTRINGMULTILINE 0x0200 /*%< Allow multiline "" strings */ ------------------ | Branch (823:9): [True: 0, False: 0] ------------------ 824| 0| 0) 825| 0| { 826| 0| pushback(source, c); 827| 0| result = ISC_R_UNBALANCEDQUOTES; 828| 0| goto done; 829| 0| } 830| 0| if (c == '\\' && !escaped) { ------------------ | Branch (830:9): [True: 0, False: 0] | Branch (830:22): [True: 0, False: 0] ------------------ 831| 0| escaped = true; 832| 0| } else { 833| 0| escaped = false; 834| 0| } 835| 0| if (remaining == 0U) { ------------------ | Branch (835:9): [True: 0, False: 0] ------------------ 836| 0| grow_data(lex, &remaining, &curr, 837| 0| &prev); 838| 0| } 839| 0| INSIST(remaining > 0U); ------------------ | | 202| 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))) | | ------------------ ------------------ 840| 0| prev = curr; 841| 0| *curr++ = c; 842| 0| *curr = '\0'; 843| 0| remaining--; 844| 0| } 845| 0| break; 846| 0| case lexstate_btext: ------------------ | Branch (846:3): [True: 0, False: 1.01k] ------------------ 847| 0| if (c == EOF) { ------------------ | Branch (847:8): [True: 0, False: 0] ------------------ 848| 0| result = ISC_R_UNEXPECTEDEND; 849| 0| goto done; 850| 0| } 851| 0| if (c == '{') { ------------------ | Branch (851:8): [True: 0, False: 0] ------------------ 852| 0| if (escaped) { ------------------ | Branch (852:9): [True: 0, False: 0] ------------------ 853| 0| escaped = false; 854| 0| } else { 855| 0| lex->brace_count++; 856| 0| } 857| 0| } else if (c == '}') { ------------------ | Branch (857:15): [True: 0, False: 0] ------------------ 858| 0| if (escaped) { ------------------ | Branch (858:9): [True: 0, False: 0] ------------------ 859| 0| escaped = false; 860| 0| } else { 861| 0| INSIST(lex->brace_count > 0); ------------------ | | 202| 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))) | | ------------------ ------------------ 862| 0| lex->brace_count--; 863| 0| } 864| | 865| 0| if (lex->brace_count == 0) { ------------------ | Branch (865:9): [True: 0, False: 0] ------------------ 866| 0| tokenp->type = isc_tokentype_btext; 867| 0| tokenp->value.as_textregion.base = 868| 0| lex->data; 869| 0| tokenp->value.as_textregion.length = 870| 0| (unsigned int)(lex->max_token - 871| 0| remaining); 872| 0| no_comments = false; 873| 0| done = true; 874| 0| break; 875| 0| } 876| 0| } 877| | 878| 0| if (c == '\\' && !escaped) { ------------------ | Branch (878:8): [True: 0, False: 0] | Branch (878:21): [True: 0, False: 0] ------------------ 879| 0| escaped = true; 880| 0| } else { 881| 0| escaped = false; 882| 0| } 883| | 884| 0| if (remaining == 0U) { ------------------ | Branch (884:8): [True: 0, False: 0] ------------------ 885| 0| grow_data(lex, &remaining, &curr, &prev); 886| 0| } 887| 0| INSIST(remaining > 0U); ------------------ | | 202| 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))) | | ------------------ ------------------ 888| 0| prev = curr; 889| 0| *curr++ = c; 890| 0| *curr = '\0'; 891| 0| remaining--; 892| 0| break; 893| 0| default: ------------------ | Branch (893:3): [True: 0, False: 1.01k] ------------------ 894| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 895| 1.01k| } 896| 1.01k| } while (!done); ------------------ | Branch (896:11): [True: 874, False: 74] ------------------ 897| | 898| 74| result = ISC_R_SUCCESS; 899| 74|done: 900| 74|#ifdef HAVE_FLOCKFILE 901| 74| if (source->is_file) { ------------------ | Branch (901:6): [True: 74, False: 0] ------------------ 902| 74| funlockfile(source->input); 903| 74| } 904| 74|#endif /* ifdef HAVE_FLOCKFILE */ 905| 74| return result; 906| 74|} isc_lex_getmastertoken: 910| 42| isc_tokentype_t expect, bool eol) { 911| 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. */ ------------------ 912| 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. */ ------------------ 913| 42| isc_result_t result; 914| | 915| 42| if (expect == isc_tokentype_vpair) { ------------------ | Branch (915:6): [True: 0, False: 42] ------------------ 916| 0| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 0|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 917| 42| } else if (expect == isc_tokentype_qvpair) { ------------------ | Branch (917:13): [True: 0, False: 42] ------------------ 918| 0| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 0|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 919| 0| options |= ISC_LEXOPT_QVPAIR; ------------------ | | 86| 0|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ 920| 42| } else if (expect == isc_tokentype_qstring) { ------------------ | Branch (920:13): [True: 6, False: 36] ------------------ 921| 6| options |= ISC_LEXOPT_QSTRING; ------------------ | | 66| 6|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ 922| 36| } else if (expect == isc_tokentype_number) { ------------------ | Branch (922:13): [True: 2, False: 34] ------------------ 923| 2| options |= ISC_LEXOPT_NUMBER; ------------------ | | 65| 2|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ 924| 2| } 925| 42| result = isc_lex_gettoken(lex, options, token); 926| 42| if (result == ISC_R_RANGE) { ------------------ | Branch (926:6): [True: 0, False: 42] ------------------ 927| 0| isc_lex_ungettoken(lex, token); 928| 0| } 929| 42| if (result != ISC_R_SUCCESS) { ------------------ | Branch (929:6): [True: 0, False: 42] ------------------ 930| 0| return result; 931| 0| } 932| | 933| 42| if (eol && ((token->type == isc_tokentype_eol) || ------------------ | Branch (933:6): [True: 20, False: 22] | Branch (933:14): [True: 0, False: 20] ------------------ 934| 20| (token->type == isc_tokentype_eof))) ------------------ | Branch (934:7): [True: 0, False: 20] ------------------ 935| 0| { 936| 0| return ISC_R_SUCCESS; 937| 0| } 938| 42| if (token->type == isc_tokentype_string && ------------------ | Branch (938:6): [True: 40, False: 2] ------------------ 939| 40| (expect == isc_tokentype_qstring || expect == isc_tokentype_qvpair)) ------------------ | Branch (939:7): [True: 6, False: 34] | Branch (939:42): [True: 0, False: 34] ------------------ 940| 6| { 941| 6| return ISC_R_SUCCESS; 942| 6| } 943| 36| if (token->type == isc_tokentype_vpair && ------------------ | Branch (943:6): [True: 0, False: 36] ------------------ 944| 0| expect == isc_tokentype_qvpair) ------------------ | Branch (944:6): [True: 0, False: 0] ------------------ 945| 0| { 946| 0| return ISC_R_SUCCESS; 947| 0| } 948| 36| if (token->type != expect) { ------------------ | Branch (948:6): [True: 0, False: 36] ------------------ 949| 0| isc_lex_ungettoken(lex, token); 950| 0| if (token->type == isc_tokentype_eol || ------------------ | Branch (950:7): [True: 0, False: 0] ------------------ 951| 0| token->type == isc_tokentype_eof) ------------------ | Branch (951:7): [True: 0, False: 0] ------------------ 952| 0| { 953| 0| return ISC_R_UNEXPECTEDEND; 954| 0| } 955| 0| if (expect == isc_tokentype_number) { ------------------ | Branch (955:7): [True: 0, False: 0] ------------------ 956| 0| return ISC_R_BADNUMBER; 957| 0| } 958| 0| return ISC_R_UNEXPECTEDTOKEN; 959| 0| } 960| 36| return ISC_R_SUCCESS; 961| 36|} isc_lex_ungettoken: 996| 6|isc_lex_ungettoken(isc_lex_t *lex, isc_token_t *tokenp) { 997| 6| inputsource *source; 998| | /* 999| | * Unget the current token. 1000| | */ 1001| | 1002| 6| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1003| 6| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1004| 6| REQUIRE(source != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1005| 6| REQUIRE(tokenp != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 1006| 6| REQUIRE(isc_buffer_consumedlength(source->pushback) != 0 || ------------------ | | 198| 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))) | | ------------------ ------------------ 1007| 6| tokenp->type == isc_tokentype_eof); 1008| | 1009| 6| UNUSED(tokenp); ------------------ | | 69| 6|#define UNUSED(x) (void)(x) ------------------ 1010| | 1011| 6| isc_buffer_first(source->pushback); 1012| 6| lex->paren_count = lex->saved_paren_count; 1013| 6| source->line = source->saved_line; 1014| | source->at_eof = false; 1015| 6|} isc_lex_getsourcename: 1038| 8|isc_lex_getsourcename(isc_lex_t *lex) { 1039| 8| inputsource *source; 1040| | 1041| 8| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1042| 8| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 8|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1043| | 1044| 8| if (source == NULL) { ------------------ | Branch (1044:6): [True: 0, False: 8] ------------------ 1045| 0| return NULL; 1046| 0| } 1047| | 1048| 8| return source->name; 1049| 8|} isc_lex_getsourceline: 1052| 22|isc_lex_getsourceline(isc_lex_t *lex) { 1053| 22| inputsource *source; 1054| | 1055| 22| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 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))) | | ------------------ ------------------ 1056| 22| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 22|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1057| | 1058| 22| if (source == NULL) { ------------------ | Branch (1058:6): [True: 0, False: 22] ------------------ 1059| 0| return 0; 1060| 0| } 1061| | 1062| 22| return source->line; 1063| 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)); ------------------ | | 144| 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), ------------------ | | 167| 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); ------------------ | | 202| 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); ------------------ | | 198| 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); \ | | ------------------ | | | | 202| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 144| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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 || ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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)); ------------------ | | 198| 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)); ------------------ | | 144| 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); ------------------ | | 167| 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, ------------------ | | 167| 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(); ------------------ | | 206| 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| 950|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| 950| if (isc__lctx == NULL) { ------------------ | Branch (1208:6): [True: 0, False: 950] ------------------ 1209| 0| return false; 1210| 0| } 1211| 950| if (forcelog) { ------------------ | Branch (1211:6): [True: 0, False: 950] ------------------ 1212| 0| return true; 1213| 0| } 1214| | 1215| 950| int highest_level = atomic_load_acquire(&isc__lctx->highest_level); ------------------ | | 50| 950|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 1216| 950| if (level <= highest_level) { ------------------ | Branch (1216:6): [True: 4, False: 946] ------------------ 1217| 4| return true; 1218| 4| } 1219| 946| if (atomic_load_acquire(&isc__lctx->dynamic)) { ------------------ | | 50| 946|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (50:32): [True: 0, False: 946] | | ------------------ ------------------ 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| 946| return false; 1227| 946|} isc__log_initialize: 1532| 2|isc__log_initialize(void) { 1533| 2| REQUIRE(isc__lctx == NULL); ------------------ | | 198| 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); ------------------ | | 236| 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)); ------------------ | | 144| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 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)); ------------------ | | 198| 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 && ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); \ | | | | | | ------------------ | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 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); ------------------ | | 202| 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); \ | | | | | | ------------------ | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 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: 339| 2|isc_loopmgr_create(isc_mem_t *mctx, uint32_t nloops) { 340| 2| REQUIRE(isc__loopmgr == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 341| 2| REQUIRE(nloops > 0); ------------------ | | 198| 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))) | | ------------------ ------------------ 342| | 343| 2| isc_loopmgr_t *loopmgr = NULL; 344| | 345| 2| isc__tid_initcount(nloops); 346| | 347| 2| loopmgr = isc_mem_get(mctx, sizeof(*loopmgr)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 348| 2| *loopmgr = (isc_loopmgr_t){ 349| 2| .nloops = nloops, 350| 2| .magic = LOOPMGR_MAGIC, ------------------ | | 84| 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)) | | ------------------ ------------------ 351| 2| }; 352| | 353| 2| isc_mem_attach(mctx, &loopmgr->mctx); 354| | 355| | /* We need to double the number for loops */ 356| 2| isc_barrier_init(&loopmgr->pausing, loopmgr->nloops); ------------------ | | 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 357| 2| isc_barrier_init(&loopmgr->resuming, loopmgr->nloops); ------------------ | | 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 358| 2| isc_barrier_init(&loopmgr->starting, ------------------ | | 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 359| 2| loopmgr->nloops * (1 + ISC_WORKLANE_COUNT)); 360| 2| isc_barrier_init(&loopmgr->stopping, ------------------ | | 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 32| 2| } | | ------------------ ------------------ 361| 2| loopmgr->nloops * (1 + ISC_WORKLANE_COUNT)); 362| | 363| 2| loopmgr->loops = isc_mem_cget(loopmgr->mctx, loopmgr->nloops, ------------------ | | 146| 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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 147| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 364| 2| sizeof(loopmgr->loops[0])); 365| 4| for (size_t i = 0; i < loopmgr->nloops; i++) { ------------------ | Branch (365:21): [True: 2, False: 2] ------------------ 366| 2| isc_loop_t *loop = &loopmgr->loops[i]; 367| 2| loop_init(loop, i, "loop"); 368| 2| } 369| | 370| 2| isc__loopmgr = loopmgr; 371| | 372| 2| loopmgr->sigint = isc_signal_new(isc__loopmgr_signal, loopmgr, SIGINT); 373| 2| loopmgr->sigterm = isc_signal_new(isc__loopmgr_signal, loopmgr, 374| 2| SIGTERM); 375| | 376| 2| isc_signal_start(loopmgr->sigint); 377| 2| isc_signal_start(loopmgr->sigterm); 378| 2|} isc_loop_getmctx: 579| 4|isc_loop_getmctx(isc_loop_t *loop) { 580| 4| REQUIRE(VALID_LOOP(loop)); ------------------ | | 198| 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))) | | ------------------ ------------------ 581| | 582| 4| return loop->mctx; 583| 4|} isc_loop_main: 586| 4|isc_loop_main(void) { 587| 4| REQUIRE(VALID_LOOPMGR(isc__loopmgr)); ------------------ | | 198| 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))) | | ------------------ ------------------ 588| | 589| 4| return DEFAULT_LOOP(isc__loopmgr); ------------------ | | 136| 4|#define DEFAULT_LOOP(loopmgr) (&(loopmgr)->loops[0]) ------------------ 590| 4|} loop.c:loop_init: 205| 2|loop_init(isc_loop_t *loop, isc_tid_t tid, const char *kind) { 206| 2| *loop = (isc_loop_t){ 207| 2| .tid = tid, 208| 2| .run_jobs = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 209| 2| }; 210| | 211| 2| __cds_wfcq_init(&loop->async_jobs.head, &loop->async_jobs.tail); 212| 2| __cds_wfcq_init(&loop->setup_jobs.head, &loop->setup_jobs.tail); 213| 2| __cds_wfcq_init(&loop->teardown_jobs.head, &loop->teardown_jobs.tail); 214| | 215| 2| int r = uv_loop_init(&loop->loop); 216| 2| UV_RUNTIME_CHECK(uv_loop_init, 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 217| | 218| 2| r = uv_async_init(&loop->loop, &loop->pause_trigger, pauseresume_cb); 219| 2| UV_RUNTIME_CHECK(uv_async_init, 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 220| 2| uv_handle_set_data(&loop->pause_trigger, loop); ------------------ | | 71| 2| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 221| | 222| 2| r = uv_async_init(&loop->loop, &loop->shutdown_trigger, shutdown_cb); 223| 2| UV_RUNTIME_CHECK(uv_async_init, 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 224| 2| uv_handle_set_data(&loop->shutdown_trigger, loop); ------------------ | | 71| 2| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 225| | 226| 2| r = uv_async_init(&loop->loop, &loop->async_trigger, isc__async_cb); 227| 2| UV_RUNTIME_CHECK(uv_async_init, 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 228| 2| uv_handle_set_data(&loop->async_trigger, loop); ------------------ | | 71| 2| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 229| | 230| 2| r = uv_idle_init(&loop->loop, &loop->run_trigger); 231| 2| UV_RUNTIME_CHECK(uv_idle_init, 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 232| 2| uv_handle_set_data(&loop->run_trigger, loop); ------------------ | | 71| 2| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 233| | 234| 2| r = uv_async_init(&loop->loop, &loop->destroy_trigger, destroy_cb); 235| 2| UV_RUNTIME_CHECK(uv_async_init, 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 236| 2| uv_handle_set_data(&loop->destroy_trigger, loop); ------------------ | | 71| 2| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 237| | 238| 2| r = uv_prepare_init(&loop->loop, &loop->quiescent); 239| 2| UV_RUNTIME_CHECK(uv_prepare_init, 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 240| 2| uv_handle_set_data(&loop->quiescent, loop); ------------------ | | 71| 2| uv_handle_set_data((uv_handle_t *)(handle), (data)) ------------------ 241| | 242| 2| isc_mem_create(kind, &loop->mctx); ------------------ | | 236| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 243| | 244| 2| isc_refcount_init(&loop->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 245| | 246| 2| loop->magic = LOOP_MAGIC; ------------------ | | 38| 2|#define LOOP_MAGIC ISC_MAGIC('L', 'O', 'O', 'P') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 247| 2|} 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); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245: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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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); ------------------ | | 198| 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: 508| 2|isc__mem_initialize(void) { 509| | /* 510| | * Check if the values copied from jemalloc still match; the 511| | * shim defines the MALLOCX_* macros too, so this holds on 512| | * every allocator path. 513| | */ 514| 2| RUNTIME_CHECK(ISC_MEM_ZERO == MALLOCX_ZERO); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, Folded] | | ------------------ ------------------ 515| 2| RUNTIME_CHECK(ISC_MEM_ALIGN(sizeof(void *)) == ------------------ | | 245| 8| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | | Branch (245:4): [True: 2, Folded] | | | Branch (245:4): [True: 2, Folded] | | ------------------ ------------------ 516| 2| MALLOCX_ALIGN(sizeof(void *))); 517| 2| RUNTIME_CHECK(ISC_MEM_ALIGN(ISC_OS_CACHELINE_SIZE) == ------------------ | | 245| 8| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | | Branch (245:4): [True: 2, Folded] | | | Branch (245:4): [True: 2, Folded] | | ------------------ ------------------ 518| 2| MALLOCX_ALIGN(ISC_OS_CACHELINE_SIZE)); 519| | 520| |#ifdef JEMALLOC_API_SUPPORTED 521| | /* 522| | * ignore errors — volumetric-based purge in mem_put handles the rest 523| | * regardless 524| | */ 525| | 526| | (void)mallctl("background_thread", NULL, NULL, &(bool){ true }, 527| | sizeof(bool)); 528| | 529| | (void)mallctl("arenas.dirty_decay_ms", NULL, NULL, 530| | &default_dirty_decay_ms, sizeof(default_dirty_decay_ms)); 531| | 532| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".dirty_decay_ms", 533| | NULL, NULL, &default_dirty_decay_ms, 534| | sizeof(default_dirty_decay_ms)); 535| | 536| |#endif /* JEMALLOC_API_SUPPORTED */ 537| | 538| 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); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 539| 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] | | ------------------ ------------------ 540| | 541| 2| if (debugging_enabled("ISC_MEM_DEBUGTRACE")) { ------------------ | Branch (541:6): [True: 0, False: 2] ------------------ 542| 0| mem_debugging |= ISC_MEM_DEBUGTRACE; ------------------ | | 41| 0|#define ISC_MEM_DEBUGTRACE 0x00000001U ------------------ 543| 0| } 544| | 545| 2| if (debugging_enabled("ISC_MEM_DEBUGRECORD")) { ------------------ | Branch (545:6): [True: 0, False: 2] ------------------ 546| 0| mem_debugging |= ISC_MEM_DEBUGRECORD; ------------------ | | 42| 0|#define ISC_MEM_DEBUGRECORD 0x00000002U ------------------ 547| 0| } 548| | 549| 2| if (debugging_enabled("ISC_MEM_DEBUGUSAGE")) { ------------------ | Branch (549:6): [True: 0, False: 2] ------------------ 550| 0| mem_debugging |= ISC_MEM_DEBUGUSAGE; ------------------ | | 43| 0|#define ISC_MEM_DEBUGUSAGE 0x00000004U ------------------ 551| 0| } 552| | 553| 2| isc_mem_create("default", &isc_g_mctx); ------------------ | | 236| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 554| 2|} isc_mem_setdebugging: 576| 4|isc_mem_setdebugging(isc_mem_t *ctx, unsigned int debugging) { 577| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 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))) | | ------------------ ------------------ 578| 4| REQUIRE(isc_mem_inuse(ctx) == 0); ------------------ | | 198| 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))) | | ------------------ ------------------ 579| | 580| 4| ctx->debugging = debugging; 581| 4|} isc__mem_putanddetach: 741| 5.58k| int flags FLARG) { 742| 5.58k| REQUIRE(ctxp != NULL && VALID_CONTEXT(*ctxp)); ------------------ | | 198| 5.58k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 22.3k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 5.58k, False: 0] | | | | | Branch (42:11): [True: 5.58k, False: 0] | | | | | Branch (42:11): [True: 5.58k, False: 0] | | | | ------------------ | | | | 43| 5.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 743| 5.58k| REQUIRE(ptr != NULL); ------------------ | | 198| 5.58k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.58k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.58k, False: 0] | | | | ------------------ | | | | 43| 5.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 744| 5.58k| REQUIRE(size != 0); ------------------ | | 198| 5.58k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.58k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.58k, False: 0] | | | | ------------------ | | | | 43| 5.58k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 745| | 746| 5.58k| isc_mem_t *ctx = *ctxp; 747| 5.58k| *ctxp = NULL; 748| | 749| 5.58k| isc__mem_put(ctx, ptr, size, flags FLARG_PASS); 750| |#if ISC_MEM_TRACE 751| | isc_mem__detach(&ctx, func, file, line); 752| |#else 753| 5.58k| isc_mem_detach(&ctx); 754| 5.58k|#endif 755| 5.58k|} isc__mem_get: 758| 11.5k|isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) { 759| 11.5k| void *ptr = NULL; 760| | 761| 11.5k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 11.5k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 23.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 11.5k, False: 0] | | | | | Branch (42:11): [True: 11.5k, False: 0] | | | | ------------------ | | | | 43| 11.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 762| | 763| 11.5k| ptr = mem_get(ctx, size, flags); 764| | 765| 11.5k| mem_getstats(ctx, size); 766| 11.5k| ADD_TRACE(ctx, ptr, size, func, file, line); 767| | 768| 11.5k| return ptr; 769| 11.5k|} isc__mem_put: 772| 11.4k|isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size, int flags FLARG) { 773| 11.4k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 11.4k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 22.8k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 11.4k, False: 0] | | | | | Branch (42:11): [True: 11.4k, False: 0] | | | | ------------------ | | | | 43| 11.4k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 11.4k| DELETE_TRACE(ctx, ptr, size, func, file, line); 776| | 777| 11.4k| mem_putstats(ctx, size); 778| 11.4k| mem_put(ctx, ptr, size, flags); 779| 11.4k|} isc__mem_allocate: 850| 64|isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) { 851| 64| void *ptr = NULL; 852| | 853| 64| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 64|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 128| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 64, False: 0] | | | | | Branch (42:11): [True: 64, False: 0] | | | | ------------------ | | | | 43| 64| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 854| | 855| 64| ptr = mem_get(ctx, size, flags); 856| | 857| | /* Recalculate the real allocated size */ 858| 64| size = sallocx(ptr, flags | ctx->jemalloc_flags); 859| | 860| 64| mem_getstats(ctx, size); 861| 64| ADD_TRACE(ctx, ptr, size, func, file, line); 862| | 863| 64| return ptr; 864| 64|} isc__mem_reallocate: 899| 14| int flags FLARG) { 900| 14| void *new_ptr = NULL; 901| | 902| 14| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 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))) | | ------------------ ------------------ 903| | 904| 14| if (old_ptr == NULL) { ------------------ | Branch (904:6): [True: 14, False: 0] ------------------ 905| 14| new_ptr = isc__mem_allocate(ctx, new_size, flags FLARG_PASS); 906| 14| } else if (new_size == 0) { ------------------ | Branch (906:13): [True: 0, False: 0] ------------------ 907| 0| isc__mem_free(ctx, old_ptr, flags FLARG_PASS); 908| 0| } else { 909| 0| size_t size = sallocx(old_ptr, flags | ctx->jemalloc_flags); 910| | 911| 0| DELETE_TRACE(ctx, old_ptr, size, func, file, line); 912| 0| mem_putstats(ctx, size); 913| | 914| 0| new_ptr = mem_realloc(ctx, old_ptr, new_size, flags); 915| | 916| | /* Recalculate the real allocated size */ 917| 0| size = sallocx(new_ptr, flags | ctx->jemalloc_flags); 918| | 919| 0| mem_getstats(ctx, size); 920| 0| ADD_TRACE(ctx, new_ptr, size, func, file, line); 921| 0| } 922| | 923| 14| return new_ptr; 924| 14|} isc__mem_free: 927| 14|isc__mem_free(isc_mem_t *ctx, void *ptr, int flags FLARG) { 928| 14| size_t size = 0; 929| | 930| 14| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 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))) | | ------------------ ------------------ 931| 14| REQUIRE(ptr != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 932| | 933| 14| size = sallocx(ptr, flags | ctx->jemalloc_flags); 934| | 935| 14| DELETE_TRACE(ctx, ptr, size, func, file, line); 936| | 937| 14| mem_putstats(ctx, size); 938| 14| mem_put(ctx, ptr, size, flags); 939| 14|} isc__mem_strdup: 946| 40|isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) { 947| 40| size_t len; 948| 40| char *ns = NULL; 949| | 950| 40| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 198| 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))) | | ------------------ ------------------ 951| 40| REQUIRE(s != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 952| | 953| 40| len = strlen(s) + 1; 954| | 955| 40| ns = isc__mem_allocate(mctx, len, 0 FLARG_PASS); 956| | 957| 40| strlcpy(ns, s, len); 958| | 959| 40| return ns; 960| 40|} isc_mem_setdestroycheck: 963| 2|isc_mem_setdestroycheck(isc_mem_t *ctx, bool flag) { 964| 2| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 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))) | | ------------------ ------------------ 965| | 966| 2| MCTXLOCK(ctx); ------------------ | | 69| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ ------------------ 967| | 968| 2| ctx->checkfree = flag; 969| | 970| 2| MCTXUNLOCK(ctx); ------------------ | | 70| 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); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ ------------------ 971| 2|} isc_mem_inuse: 974| 4|isc_mem_inuse(isc_mem_t *ctx) { 975| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 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))) | | ------------------ ------------------ 976| | 977| 4| int_fast64_t inuse = 0; 978| | 979| 8| for (ssize_t i = -1; i < isc_tid_count(); i++) { ------------------ | Branch (979:23): [True: 4, False: 4] ------------------ 980| 4| inuse += atomic_load_relaxed(&ctx->stat[i].inuse); ------------------ | | 28| 4|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 981| 4| } 982| 4| INSIST(inuse >= 0); ------------------ | | 202| 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))) | | ------------------ ------------------ 983| | 984| 4| return (size_t)inuse; 985| 4|} isc__mempool_create: 1050| 3.38k| const char *name, isc_mempool_t **restrict mpctxp FLARG) { 1051| 3.38k| isc_mempool_t *restrict mpctx = NULL; 1052| 3.38k| size_t size = element_size; 1053| | 1054| 3.38k| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.76k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1055| 3.38k| REQUIRE(size > 0U); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1056| 3.38k| REQUIRE(mpctxp != NULL && *mpctxp == NULL); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.76k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1057| 3.38k| REQUIRE(name != NULL); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1058| | 1059| | /* 1060| | * Mempools are stored as a linked list of element. 1061| | */ 1062| 3.38k| if (size < sizeof(element)) { ------------------ | Branch (1062:6): [True: 0, False: 3.38k] ------------------ 1063| 0| size = sizeof(element); 1064| 0| } 1065| | 1066| | /* 1067| | * Allocate space for this pool, initialize values, and if all 1068| | * works well, attach to the memory context. 1069| | */ 1070| 3.38k| mpctx = isc_mem_get(mctx, sizeof(isc_mempool_t)); ------------------ | | 144| 3.38k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1071| | 1072| 3.38k| *mpctx = (isc_mempool_t){ 1073| 3.38k| .size = size, 1074| 3.38k| .freemax = 1, 1075| 3.38k| .fillcount = 1, 1076| 3.38k| .name = strdup(name), 1077| 3.38k| }; 1078| | 1079| |#if ISC_MEM_TRACKLINES 1080| | if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) { 1081| | fprintf(stderr, 1082| | "create pool %p func %s file %s line %u mctx %p\n", 1083| | mpctx, func, file, line, mctx); 1084| | } 1085| |#endif /* ISC_MEM_TRACKLINES */ 1086| | 1087| 3.38k| isc_mem_attach(mctx, &mpctx->mctx); 1088| 3.38k| mpctx->magic = MEMPOOL_MAGIC; ------------------ | | 161| 3.38k|#define MEMPOOL_MAGIC ISC_MAGIC('M', 'E', 'M', 'p') | | ------------------ | | | | 31| 3.38k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1089| | 1090| 3.38k| *mpctxp = (isc_mempool_t *)mpctx; 1091| | 1092| 3.38k| MCTXLOCK(mctx); ------------------ | | 69| 3.38k|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 3.38k| { \ | | | | 27| 3.38k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 3.38k| __FILE__, __LINE__)); \ | | | | 29| 3.38k| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 3.38k|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 3.38k| { \ | | | | | | | | 86| 3.38k| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 3.38k| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.38k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.38k] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 3.38k| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 3.38k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 3.38k| __FILE__, __LINE__)); \ | | | | 32| 3.38k| } | | ------------------ ------------------ 1093| 3.38k| ISC_LIST_INITANDAPPEND(mctx->pools, mpctx, link); ------------------ | | 106| 3.38k| __ISC_LIST_APPENDUNSAFE(list, elt, link) | | ------------------ | | | | 88| 3.38k| do { \ | | | | 89| 3.38k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 1.69k, False: 1.69k] | | | | ------------------ | | | | 90| 1.69k| (list).tail->link.next = (elt); \ | | | | 91| 1.69k| } else { \ | | | | 92| 1.69k| (list).head = (elt); \ | | | | 93| 1.69k| } \ | | | | 94| 3.38k| (elt)->link.prev = (list).tail; \ | | | | 95| 3.38k| (elt)->link.next = NULL; \ | | | | 96| 3.38k| (list).tail = (elt); \ | | | | 97| 3.38k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 3.38k] | | | | ------------------ | | ------------------ ------------------ 1094| 3.38k| mctx->poolcnt++; 1095| 3.38k| MCTXUNLOCK(mctx); ------------------ | | 70| 3.38k|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 3.38k| { \ | | | | 35| 3.38k| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 3.38k|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 3.38k| { \ | | | | | | | | 92| 3.38k| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 3.38k| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.38k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.38k] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 3.38k| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 3.38k| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 3.38k| __FILE__, __LINE__)); \ | | | | 38| 3.38k| } | | ------------------ ------------------ 1096| 3.38k|} isc__mempool_destroy: 1099| 3.38k|isc__mempool_destroy(isc_mempool_t **restrict mpctxp FLARG) { 1100| 3.38k| isc_mempool_t *restrict mpctx = NULL; 1101| 3.38k| isc_mem_t *mctx = NULL; 1102| 3.38k| element *restrict item = NULL; 1103| | 1104| 3.38k| REQUIRE(mpctxp != NULL); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1105| 3.38k| REQUIRE(VALID_MEMPOOL(*mpctxp)); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.76k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1106| | 1107| 3.38k| mpctx = *mpctxp; 1108| 3.38k| *mpctxp = NULL; 1109| | 1110| 3.38k| mctx = mpctx->mctx; 1111| | 1112| |#if ISC_MEM_TRACKLINES 1113| | if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) { 1114| | fprintf(stderr, 1115| | "destroy pool %p func %s file %s line %u mctx %p\n", 1116| | mpctx, func, file, line, mctx); 1117| | } 1118| |#endif 1119| | 1120| 3.38k| if (mpctx->allocated > 0) { ------------------ | Branch (1120:6): [True: 0, False: 3.38k] ------------------ 1121| 0| UNEXPECTED_ERROR("mempool %s leaked memory", mpctx->name); ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1122| 0| } 1123| 3.38k| REQUIRE(mpctx->allocated == 0); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1124| | 1125| | /* 1126| | * Return any items on the free list 1127| | */ 1128| 3.45M| while (mpctx->items != NULL) { ------------------ | Branch (1128:9): [True: 3.44M, False: 3.38k] ------------------ 1129| 3.44M| INSIST(mpctx->freecount > 0); ------------------ | | 202| 3.44M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 3.44M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 3.44M, False: 0] | | | | ------------------ | | | | 55| 3.44M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1130| 3.44M| mpctx->freecount--; 1131| | 1132| 3.44M| item = mpctx->items; 1133| 3.44M| mpctx->items = item->next; 1134| | 1135| 3.44M| mem_putstats(mctx, mpctx->size); 1136| 3.44M| mem_put(mctx, item, mpctx->size, 0); 1137| 3.44M| } 1138| | 1139| | /* 1140| | * Remove our linked list entry from the memory context. 1141| | */ 1142| 3.38k| MCTXLOCK(mctx); ------------------ | | 69| 3.38k|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 3.38k| { \ | | | | 27| 3.38k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 3.38k| __FILE__, __LINE__)); \ | | | | 29| 3.38k| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 3.38k|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 3.38k| { \ | | | | | | | | 86| 3.38k| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 3.38k| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.38k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.38k] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 3.38k| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 3.38k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 3.38k| __FILE__, __LINE__)); \ | | | | 32| 3.38k| } | | ------------------ ------------------ 1143| 3.38k| ISC_LIST_UNLINK(mctx->pools, mpctx, link); ------------------ | | 137| 3.38k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 3.38k| do { \ | | | | 133| 3.38k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 3.38k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 3.38k| do { \ | | | | | | 110| 3.38k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 3.38k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 3.38k| } else { \ | | | | | | 113| 3.38k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 3.38k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 3.38k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 114| 3.38k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 3.38k| } \ | | | | | | 116| 3.38k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 1.69k, False: 1.69k] | | | | | | ------------------ | | | | | | 117| 1.69k| (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| 3.38k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 3.38k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 3.38k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 3.38k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 3.38k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 3.38k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 3.38k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 125| 3.38k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 54| 3.38k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 3.38k, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | | | 126| 3.38k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 3.38k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 3.38k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 3.38k] | | | | ------------------ | | ------------------ ------------------ 1144| 3.38k| mctx->poolcnt--; 1145| 3.38k| MCTXUNLOCK(mctx); ------------------ | | 70| 3.38k|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 3.38k| { \ | | | | 35| 3.38k| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 3.38k|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 3.38k| { \ | | | | | | | | 92| 3.38k| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 3.38k| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.38k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.38k] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 3.38k| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 3.38k| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 3.38k| __FILE__, __LINE__)); \ | | | | 38| 3.38k| } | | ------------------ ------------------ 1146| | 1147| 3.38k| free(mpctx->name); 1148| | 1149| 3.38k| mpctx->magic = 0; 1150| | 1151| | isc_mem_putanddetach(&mpctx->mctx, mpctx, sizeof(isc_mempool_t)); ------------------ | | 187| 3.38k| do { \ | | 188| 3.38k| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 3.38k| (p) = NULL; \ | | 190| 3.38k| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 3.38k] | | ------------------ ------------------ 1152| 3.38k|} isc__mempool_get: 1155| 6.37k|isc__mempool_get(isc_mempool_t *restrict mpctx FLARG) { 1156| 6.37k| element *restrict item = NULL; 1157| | 1158| 6.37k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 6.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6.37k, False: 0] | | | | | Branch (42:11): [True: 6.37k, False: 0] | | | | ------------------ | | | | 43| 6.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1159| | 1160| 6.37k| mpctx->allocated++; 1161| | 1162| 6.37k| if (mpctx->items == NULL) { ------------------ | Branch (1162:6): [True: 3.36k, False: 3.00k] ------------------ 1163| 3.36k| isc_mem_t *mctx = mpctx->mctx; 1164| 3.36k|#if !__SANITIZE_ADDRESS__ 1165| 3.36k| const size_t fillcount = mpctx->fillcount; 1166| |#else 1167| | const size_t fillcount = 1; 1168| |#endif 1169| | /* 1170| | * We need to dip into the well. Fill up our free list. 1171| | */ 1172| 3.45M| for (size_t i = 0; i < fillcount; i++) { ------------------ | Branch (1172:22): [True: 3.44M, False: 3.36k] ------------------ 1173| 3.44M| item = mem_get(mctx, mpctx->size, 0); 1174| 3.44M| mem_getstats(mctx, mpctx->size); 1175| 3.44M| item->next = mpctx->items; 1176| 3.44M| mpctx->items = item; 1177| 3.44M| mpctx->freecount++; 1178| 3.44M| } 1179| 3.36k| } 1180| | 1181| 6.37k| INSIST(mpctx->items != NULL); ------------------ | | 202| 6.37k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6.37k, False: 0] | | | | ------------------ | | | | 55| 6.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1182| 6.37k| item = mpctx->items; 1183| | 1184| 6.37k| mpctx->items = item->next; 1185| | 1186| 6.37k| INSIST(mpctx->freecount > 0); ------------------ | | 202| 6.37k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6.37k, False: 0] | | | | ------------------ | | | | 55| 6.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1187| 6.37k| mpctx->freecount--; 1188| 6.37k| mpctx->gets++; 1189| | 1190| 6.37k| ADD_TRACE(mpctx->mctx, item, mpctx->size, func, file, line); 1191| | 1192| 6.37k| return item; 1193| 6.37k|} isc__mempool_put: 1197| 6.37k|isc__mempool_put(isc_mempool_t *restrict mpctx, void *mem FLARG) { 1198| 6.37k| element *restrict item = NULL; 1199| | 1200| 6.37k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 6.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6.37k, False: 0] | | | | | Branch (42:11): [True: 6.37k, False: 0] | | | | ------------------ | | | | 43| 6.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1201| 6.37k| REQUIRE(mem != NULL); ------------------ | | 198| 6.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 6.37k, False: 0] | | | | ------------------ | | | | 43| 6.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1202| | 1203| 6.37k| isc_mem_t *mctx = mpctx->mctx; 1204| 6.37k| const size_t freecount = mpctx->freecount; 1205| 6.37k|#if !__SANITIZE_ADDRESS__ 1206| 6.37k| const size_t freemax = mpctx->freemax; 1207| |#else 1208| | const size_t freemax = 0; 1209| |#endif 1210| | 1211| 6.37k| INSIST(mpctx->allocated > 0); ------------------ | | 202| 6.37k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 6.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 6.37k, False: 0] | | | | ------------------ | | | | 55| 6.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1212| 6.37k| mpctx->allocated--; 1213| | 1214| 6.37k| DELETE_TRACE(mctx, mem, mpctx->size, func, file, line); 1215| | 1216| | /* 1217| | * If our free list is full, return this to the mctx directly. 1218| | */ 1219| 6.37k| if (freecount >= freemax) { ------------------ | Branch (1219:6): [True: 0, False: 6.37k] ------------------ 1220| 0| mem_putstats(mctx, mpctx->size); 1221| 0| mem_put(mctx, mem, mpctx->size, 0); 1222| 0| return; 1223| 0| } 1224| | 1225| | /* 1226| | * Otherwise, attach it to our free list and bump the counter. 1227| | */ 1228| 6.37k| item = (element *)mem; 1229| 6.37k| item->next = mpctx->items; 1230| 6.37k| mpctx->items = item; 1231| 6.37k| mpctx->freecount++; 1232| 6.37k|} isc_mempool_setfreemax: 1240| 3.38k| const unsigned int limit) { 1241| 3.38k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.76k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1242| 3.38k| mpctx->freemax = limit; 1243| 3.38k|} isc_mempool_getallocated: 1260| 3.38k|isc_mempool_getallocated(isc_mempool_t *restrict mpctx) { 1261| 3.38k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.76k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1262| | 1263| 3.38k| return mpctx->allocated; 1264| 3.38k|} isc_mempool_setfillcount: 1268| 3.38k| unsigned int const limit) { 1269| 3.38k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 6.76k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | | Branch (42:11): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1270| 3.38k| REQUIRE(limit > 0); ------------------ | | 198| 3.38k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 3.38k, False: 0] | | | | ------------------ | | | | 43| 3.38k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1271| | 1272| 3.38k| mpctx->fillcount = limit; 1273| 3.38k|} isc__mem_create: 1535| 12|isc__mem_create(const char *name, isc_mem_t **mctxp FLARG) { 1536| 12| mem_create(name, mctxp, mem_debugging, 0); 1537| |#if ISC_MEM_TRACKLINES 1538| | if ((mem_debugging & ISC_MEM_DEBUGTRACE) != 0) { 1539| | fprintf(stderr, "create mctx %p func %s file %s line %u\n", 1540| | *mctxp, func, file, line); 1541| | } 1542| |#endif /* ISC_MEM_TRACKLINES */ 1543| 12|} mem.c:debugging_enabled: 491| 6|debugging_enabled(const char *name) { 492| 6| char env_buf[256]; 493| 6| size_t env_size = sizeof(env_buf); 494| | 495| 6| int r = uv_os_getenv(name, env_buf, &env_size); 496| 6| switch (r) { 497| 0| case 0: ------------------ | Branch (497:2): [True: 0, False: 6] ------------------ 498| 0| return true; 499| 6| case UV_ENOENT: ------------------ | Branch (499:2): [True: 6, False: 0] ------------------ 500| 6| return false; 501| 0| default: ------------------ | Branch (501:2): [True: 0, False: 6] ------------------ 502| 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)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 503| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 504| 6| } 505| 6|} mem.c:mem_get: 398| 3.46M|mem_get(isc_mem_t *ctx, size_t size, int flags) { 399| 3.46M| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 390| 3.46M| if (s == 0) { \ | | ------------------ | | | Branch (390:6): [True: 4, False: 3.46M] | | ------------------ | | 391| 4| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 86| 4|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 392| 4| } ------------------ 400| | 401| 3.46M| void *ptr = mallocx(size, flags | ctx->jemalloc_flags); 402| 3.46M| CHECK_OOM(ptr, size); ------------------ | | 244| 3.46M|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (244:37): [True: 3.46M, False: 0] | | | Branch (244:54): [True: 0, False: 0] | | ------------------ ------------------ 403| | 404| 3.46M| return ptr; 405| 3.46M|} mem.c:mem_getstats: 474| 3.46M|mem_getstats(isc_mem_t *ctx, size_t size) { 475| | atomic_fetch_add_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 30| 3.46M| atomic_fetch_add_explicit((o), (v), memory_order_relaxed) ------------------ 476| 3.46M|} mem.c:mem_putstats: 482| 3.46M|mem_putstats(isc_mem_t *ctx, size_t size) { 483| | atomic_fetch_sub_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 32| 3.46M| atomic_fetch_sub_explicit((o), (v), memory_order_relaxed) ------------------ 484| 3.46M|} mem.c:mem_put: 445| 3.46M|mem_put(isc_mem_t *ctx, void *mem, size_t size, int flags) { 446| 3.46M| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 390| 3.46M| if (s == 0) { \ | | ------------------ | | | Branch (390:6): [True: 0, False: 3.46M] | | ------------------ | | 391| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 86| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 392| 0| } ------------------ 447| | 448| 3.46M| sdallocx(mem, size, flags | ctx->jemalloc_flags); 449| | 450| 3.46M| freed_bytes += size; 451| | 452| 3.46M| if (freed_bytes >= purge_threshold) { ------------------ | Branch (452:6): [True: 50, False: 3.46M] ------------------ 453| 50| freed_bytes = 0; 454| 50| mem_purge(); 455| 50| } 456| 3.46M|} mem.c:mem_purge: 416| 50|mem_purge(void) { 417| 50| isc_stdtime_t now = isc_stdtime_now(); 418| 50| isc_stdtime_t last = atomic_load_relaxed(&last_purge); ------------------ | | 28| 50|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 419| | 420| 50| if (now > last && ------------------ | Branch (420:6): [True: 1, False: 49] ------------------ 421| 50| atomic_compare_exchange_strong_acq_rel(&last_purge, &last, now)) ------------------ | | 71| 50| atomic_compare_exchange_strong_explicit( \ | | ------------------ | | | Branch (71:2): [True: 1, False: 0] | | ------------------ | | 72| 1| (o), (e), (d), memory_order_acq_rel, memory_order_acquire) ------------------ 422| 1| { 423| |#if defined(JEMALLOC_API_SUPPORTED) 424| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".decay", 425| | NULL, NULL, NULL, 0); 426| |#elif defined(__GLIBC__) 427| | (void)malloc_trim(0); 428| 1|#endif 429| 1| } 430| 50|} mem.c:mem_create: 611| 12| unsigned int jemalloc_flags) { 612| 12| isc_mem_t *ctx = NULL; 613| | 614| 12| REQUIRE(ctxp != NULL && *ctxp == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 615| 12| REQUIRE(name != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 616| | 617| 12| ctx = mallocx(sizeof(*ctx), 618| 12| jemalloc_flags | ISC_MEM_ALIGN(isc_os_cacheline())); ------------------ | | 138| 12| ((int)(((size_t)(a) < (size_t)INT_MAX) \ | | ------------------ | | | Branch (138:9): [True: 12, False: 0] | | ------------------ | | 139| 12| ? ffs((int)(a)) - 1 \ | | 140| 12| : ffs((int)(((size_t)(a)) >> 32)) + 31)) ------------------ 619| 12| CHECK_OOM(ctx, sizeof(*ctx)); ------------------ | | 244| 12|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (244:37): [True: 12, False: 0] | | | Branch (244:54): [True: 0, False: 0] | | ------------------ ------------------ 620| | 621| 12| *ctx = (isc_mem_t){ 622| 12| .magic = MEM_MAGIC, ------------------ | | 121| 12|#define MEM_MAGIC ISC_MAGIC('M', 'e', 'm', 'C') | | ------------------ | | | | 31| 12|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 623| 12| .debugging = debugging, 624| 12| .jemalloc_flags = jemalloc_flags, 625| 12| .checkfree = true, 626| 12| .name = strdup(name), 627| 12| }; 628| | 629| 12| isc_mutex_init(&ctx->lock); ------------------ | | 68| 12|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 12| { \ | | | | 80| 12| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 12| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 12| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 12] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 12| } | | ------------------ ------------------ 630| 12| isc_refcount_init(&ctx->references, 1); ------------------ | | 44| 12|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 631| | 632| 6.16k| for (size_t i = 0; i < ARRAY_SIZE(ctx->stat_s); i++) { ------------------ | | 98| 6.16k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (632:21): [True: 6.15k, False: 12] ------------------ 633| 6.15k| atomic_init(&ctx->stat_s[i].inuse, 0); 634| 6.15k| } 635| | 636| | /* Reserve the [-1] index for ISC_TID_UNKNOWN */ 637| 12| ctx->stat = &ctx->stat_s[1]; 638| | 639| 12| atomic_init(&ctx->hi_water, 0); 640| 12| atomic_init(&ctx->lo_water, 0); 641| | 642| 12| ISC_LIST_INIT(ctx->pools); ------------------ | | 43| 12| do { \ | | 44| 12| (list).head = NULL; \ | | 45| 12| (list).tail = NULL; \ | | 46| 12| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 12] | | ------------------ ------------------ 643| | 644| |#if ISC_MEM_TRACKLINES 645| | if ((ctx->debugging & ISC_MEM_DEBUGRECORD) != 0) { 646| | unsigned int i; 647| | size_t debuglist_size = ISC_CHECKED_MUL(DEBUG_TABLE_COUNT, 648| | sizeof(debuglist_t)); 649| | 650| | ctx->debuglist = mallocx(debuglist_size, jemalloc_flags); 651| | CHECK_OOM(ctx->debuglist, debuglist_size); 652| | 653| | for (i = 0; i < DEBUG_TABLE_COUNT; i++) { 654| | ISC_LIST_INIT(ctx->debuglist[i]); 655| | } 656| | } 657| |#endif /* if ISC_MEM_TRACKLINES */ 658| | 659| 12| LOCK(&contextslock); ------------------ | | 26| 12| { \ | | 27| 12| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 12| __FILE__, __LINE__)); \ | | 29| 12| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 12|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 12| { \ | | | | | | 86| 12| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 12| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 288| 12| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 12| } | | | | ------------------ | | ------------------ | | 30| 12| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 12| __FILE__, __LINE__)); \ | | 32| 12| } ------------------ 660| 12| ISC_LIST_INITANDAPPEND(contexts, ctx, link); ------------------ | | 106| 12| __ISC_LIST_APPENDUNSAFE(list, elt, link) | | ------------------ | | | | 88| 12| do { \ | | | | 89| 12| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 10, False: 2] | | | | ------------------ | | | | 90| 10| (list).tail->link.next = (elt); \ | | | | 91| 10| } else { \ | | | | 92| 2| (list).head = (elt); \ | | | | 93| 2| } \ | | | | 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] | | | | ------------------ | | ------------------ ------------------ 661| 12| UNLOCK(&contextslock); ------------------ | | 34| 12| { \ | | 35| 12| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 12|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 12| { \ | | | | | | 92| 12| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 12| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 288| 12| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 12| } | | | | ------------------ | | ------------------ | | 36| 12| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 12| __FILE__, __LINE__)); \ | | 38| 12| } ------------------ 662| | 663| 12| *ctxp = ctx; 664| 12|} isc__mutex_initialize: 33| 2|isc__mutex_initialize(void) { 34| 2| RUNTIME_CHECK(pthread_mutexattr_init(&isc__mutex_init_attr) == 0); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245: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, ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245: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_cacheline: 204| 24|isc_os_cacheline(void) { 205| 24| return isc__os_cacheline; 206| 24|} 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_exponent_is_allowed: 631| 9|isc_ossl_wrap_rsa_exponent_is_allowed(EVP_PKEY *pkey) { 632| 9| BIGNUM *e = NULL; 633| 9| BIGNUM *emin = NULL; 634| 9| BIGNUM *emax = NULL; 635| 9| bool ok = false; 636| | 637| 9| if (EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &e) != 1) { ------------------ | Branch (637:6): [True: 0, False: 9] ------------------ 638| 0| goto cleanup; 639| 0| } 640| | 641| 9| emin = BN_new(); 642| 9| if (emin == NULL || !BN_set_word(emin, 3)) { ------------------ | Branch (642:6): [True: 0, False: 9] | Branch (642:22): [True: 0, False: 9] ------------------ 643| 0| goto cleanup; 644| 0| } 645| 9| if (BN_hex2bn(&emax, "100000001") == 0) { ------------------ | Branch (645:6): [True: 0, False: 9] ------------------ 646| 0| goto cleanup; 647| 0| } 648| | 649| 9| ok = BN_is_odd(e) && BN_cmp(e, emin) >= 0 && BN_cmp(e, emax) <= 0; ------------------ | Branch (649:7): [True: 9, False: 0] | Branch (649:23): [True: 9, False: 0] | Branch (649:47): [True: 9, False: 0] ------------------ 650| | 651| 9|cleanup: 652| 9| BN_free(e); 653| 9| BN_free(emin); 654| 9| BN_free(emax); 655| 9| return ok; 656| 9|} isc_ossl_wrap_rsa_modulus_bits_in_range: 660| 9| size_t max) { 661| 9| REQUIRE(pkey != NULL); ------------------ | | 198| 9|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 9, False: 0] | | | | ------------------ | | | | 43| 9| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 662| | 663| 9| int bits = EVP_PKEY_bits(pkey); 664| 9| return bits > 0 && (size_t)bits >= min && (size_t)bits <= max; ------------------ | Branch (664:9): [True: 9, False: 0] | Branch (664:21): [True: 9, False: 0] | Branch (664:44): [True: 9, False: 0] ------------------ 665| 9|} isc_ossl_wrap_load_rsa_public_from_components: 727| 103| EVP_PKEY **pkeyp) { 728| 103| OSSL_PARAM_BLD *bld = NULL; 729| 103| EVP_PKEY_CTX *pctx = NULL; 730| 103| OSSL_PARAM *params = NULL; 731| 103| isc_result_t result; 732| | 733| 103| REQUIRE(pkeyp != NULL && *pkeyp == NULL); ------------------ | | 198| 103|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 206| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 103, False: 0] | | | | | Branch (42:11): [True: 103, False: 0] | | | | ------------------ | | | | 43| 103| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 734| 103| REQUIRE(c != NULL && c->n != NULL && c->e != NULL); ------------------ | | 198| 103|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 412| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 103, False: 0] | | | | | Branch (42:11): [True: 103, False: 0] | | | | | Branch (42:11): [True: 103, False: 0] | | | | ------------------ | | | | 43| 103| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 735| | 736| 103| bld = OSSL_PARAM_BLD_new(); 737| 103| if (bld == NULL) { ------------------ | Branch (737:6): [True: 0, False: 103] ------------------ 738| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_new")); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 739| 0| } 740| | 741| 103| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, c->n) != 1) { ------------------ | Branch (741:6): [True: 0, False: 103] ------------------ 742| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_push_BN")); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 743| 0| } 744| | 745| 103| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, c->e) != 1) { ------------------ | Branch (745:6): [True: 0, False: 103] ------------------ 746| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_push_BN")); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 747| 0| } 748| | 749| 103| params = OSSL_PARAM_BLD_to_param(bld); 750| 103| if (params == NULL) { ------------------ | Branch (750:6): [True: 0, False: 103] ------------------ 751| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_to_param")); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 752| 0| } 753| | 754| 103| pctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); 755| 103| if (pctx == NULL) { ------------------ | Branch (755:6): [True: 0, False: 103] ------------------ 756| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_CTX_new_from_name")); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 757| 0| } 758| | 759| 103| if (EVP_PKEY_fromdata_init(pctx) != 1) { ------------------ | Branch (759:6): [True: 0, False: 103] ------------------ 760| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_fromdata_init")); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 761| 0| } 762| | 763| 103| if (EVP_PKEY_fromdata(pctx, pkeyp, EVP_PKEY_PUBLIC_KEY, params) != 1) { ------------------ | Branch (763:6): [True: 0, False: 103] ------------------ 764| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_fromdata")); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 765| 0| } 766| | 767| 103| result = ISC_R_SUCCESS; 768| | 769| 103|cleanup: 770| 103| EVP_PKEY_CTX_free(pctx); 771| 103| OSSL_PARAM_free(params); 772| 103| OSSL_PARAM_BLD_free(bld); 773| 103| return result; 774| 103|} isc_ossl_wrap_rsa_components_cleanup: 23| 103|isc_ossl_wrap_rsa_components_cleanup(isc_ossl_wrap_rsa_components_t *c) { 24| 103| REQUIRE(c != NULL); ------------------ | | 198| 103|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 103| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 103, False: 0] | | | | ------------------ | | | | 43| 103| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 25| | 26| 103| if (!c->needs_cleanup) { ------------------ | Branch (26:6): [True: 0, False: 103] ------------------ 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| 103| BN_free(c->e); 37| 103| BN_free(c->n); 38| 103| BN_clear_free(c->d); 39| 103| BN_clear_free(c->p); 40| 103| BN_clear_free(c->q); 41| 103| BN_clear_free(c->dmp1); 42| 103| BN_clear_free(c->dmq1); 43| 103| BN_clear_free(c->iqmp); 44| | 45| | c->needs_cleanup = false; 46| 103|} isc_ossl_wrap_toresult: 49| 8|isc_ossl_wrap_toresult(isc_result_t fallback) { 50| 8| isc_result_t result = fallback; 51| 8| 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| 8| int reason = ERR_GET_REASON(err); 56| | 57| 8| 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: 8] ------------------ 63| 0| result = ISC_R_NOMEMORY; 64| 0| break; 65| 8| default: ------------------ | Branch (65:2): [True: 8, 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| 8| break; 75| 8| } 76| | 77| 8| return result; 78| 8|} isc__ossl_wrap_logged_toresult: 84| 8| int line) { 85| 8| 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| 8| if (category == ISC_LOGCATEGORY_INVALID) { ------------------ | Branch (92:6): [True: 8, False: 0] ------------------ 93| 8| goto done; 94| 8| } 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| 8|done: 122| 8| ERR_clear_error(); 123| 8| 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: 56| 4|isc_radix_create(isc_mem_t *mctx, isc_radix_tree_t **target, uint8_t maxbits) { 57| 4| REQUIRE(target != NULL && *target == NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 58| 4| RUNTIME_CHECK(maxbits <= RADIX_MAXBITS); ------------------ | | 245| 4| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 4, False: 0] | | ------------------ ------------------ 59| | 60| 4| isc_radix_tree_t *radix = isc_mem_get(mctx, sizeof(isc_radix_tree_t)); ------------------ | | 144| 4|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 61| 4| *radix = (isc_radix_tree_t){ 62| 4| .maxbits = maxbits, 63| 4| .magic = RADIX_TREE_MAGIC, ------------------ | | 96| 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)) | | ------------------ ------------------ 64| 4| }; 65| 4| isc_mem_attach(mctx, &radix->mctx); 66| 4| *target = radix; 67| 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: 158| 1.49k|isc_rwlock_rdlock(isc_rwlock_t *rwl) { 159| 1.49k| uint32_t cnt = 0; 160| 1.49k| bool barrier_raised = false; 161| | 162| 1.49k| LIBISC_RWLOCK_RDLOCK_REQ(rwl); 163| | 164| 1.49k| while (true) { ------------------ | Branch (164:9): [True: 1.49k, Folded] ------------------ 165| 1.49k| read_indicator_arrive(rwl); 166| | 167| 1.49k| if (!writers_lock_islocked(rwl)) { ------------------ | Branch (167:7): [True: 1.49k, False: 0] ------------------ 168| | /* Acquired lock in read-only mode */ 169| 1.49k| break; 170| 1.49k| } 171| | 172| | /* Writer has acquired the lock, must reset to 0 and wait */ 173| 0| read_indicator_depart(rwl); 174| | 175| 0| while (writers_lock_islocked(rwl)) { ------------------ | Branch (175:10): [True: 0, False: 0] ------------------ 176| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 177| 0| if (ran_out_of_patience(cnt++) && !barrier_raised) { ------------------ | | 155| 0|#define ran_out_of_patience(cnt) (cnt >= RWLOCK_MAX_READER_PATIENCE) | | ------------------ | | | | 77| 0|#define RWLOCK_MAX_READER_PATIENCE 500 | | ------------------ | | | Branch (155:34): [True: 0, False: 0] | | ------------------ ------------------ | Branch (177:38): [True: 0, False: 0] ------------------ 178| 0| writers_barrier_raise(rwl); 179| 0| barrier_raised = true; 180| 0| } 181| 0| } 182| 0| } 183| 1.49k| if (barrier_raised) { ------------------ | Branch (183:6): [True: 0, False: 1.49k] ------------------ 184| 0| writers_barrier_lower(rwl); 185| 0| } 186| | 187| 1.49k| LIBISC_RWLOCK_RDLOCK_ACQ(rwl); 188| 1.49k|} isc_rwlock_rdunlock: 208| 1.49k|isc_rwlock_rdunlock(isc_rwlock_t *rwl) { 209| 1.49k| read_indicator_depart(rwl); 210| 1.49k| LIBISC_RWLOCK_RDUNLOCK(rwl); 211| 1.49k|} isc_rwlock_wrlock: 255| 20|isc_rwlock_wrlock(isc_rwlock_t *rwl) { 256| 20| LIBISC_RWLOCK_WRLOCK_REQ(rwl); 257| | 258| | /* Write Barriers has been raised, wait */ 259| 20| while (writers_barrier_israised(rwl)) { ------------------ | Branch (259:9): [True: 0, False: 20] ------------------ 260| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 261| 0| } 262| | 263| | /* Try to acquire the write-lock */ 264| 20| while (!writers_lock_acquire(rwl)) { ------------------ | Branch (264:9): [True: 0, False: 20] ------------------ 265| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 266| 0| } 267| | 268| 20| read_indicator_wait_until_empty(rwl); 269| | 270| 20| LIBISC_RWLOCK_WRLOCK_ACQ(rwl); 271| 20|} isc_rwlock_wrunlock: 274| 20|isc_rwlock_wrunlock(isc_rwlock_t *rwl) { 275| 20| writers_lock_release(rwl); 276| 20| LIBISC_RWLOCK_WRUNLOCK(rwl); 277| 20|} isc_rwlock_init: 315| 2.06k|isc_rwlock_init(isc_rwlock_t *rwl) { 316| 2.06k| REQUIRE(rwl != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 317| | 318| 2.06k| atomic_init(&rwl->writers_lock, ISC_RWLOCK_UNLOCKED); ------------------ | | 69| 2.06k|#define ISC_RWLOCK_UNLOCKED false ------------------ 319| 2.06k| atomic_init(&rwl->writers_barrier, 0); 320| 2.06k| atomic_init(&rwl->readers_ingress, 0); 321| | atomic_init(&rwl->readers_egress, 0); 322| 2.06k| LIBISC_RWLOCK_INIT(rwl); 323| 2.06k|} rwlock.c:read_indicator_arrive: 97| 1.49k|read_indicator_arrive(isc_rwlock_t *rwl) { 98| | (void)atomic_fetch_add_explicit(&rwl->readers_ingress, 1, 99| 1.49k| memory_order_seq_cst); 100| 1.49k|} rwlock.c:writers_lock_islocked: 135| 1.49k|writers_lock_islocked(isc_rwlock_t *rwl) { 136| 1.49k| return atomic_load_explicit(&rwl->writers_lock, memory_order_seq_cst) == 137| | ISC_RWLOCK_LOCKED; ------------------ | | 70| 1.49k|#define ISC_RWLOCK_LOCKED true ------------------ 138| 1.49k|} rwlock.c:read_indicator_depart: 103| 1.49k|read_indicator_depart(isc_rwlock_t *rwl) { 104| | (void)atomic_fetch_add_explicit(&rwl->readers_egress, 1, 105| 1.49k| memory_order_seq_cst); 106| 1.49k|} rwlock.c:writers_barrier_israised: 129| 20|writers_barrier_israised(isc_rwlock_t *rwl) { 130| | return atomic_load_explicit(&rwl->writers_barrier, 131| 20| memory_order_seq_cst) > 0; 132| 20|} rwlock.c:writers_lock_acquire: 141| 20|writers_lock_acquire(isc_rwlock_t *rwl) { 142| 20| return atomic_compare_exchange_weak_explicit( 143| 20| &rwl->writers_lock, &(bool){ ISC_RWLOCK_UNLOCKED }, ------------------ | | 69| 20|#define ISC_RWLOCK_UNLOCKED false ------------------ 144| | ISC_RWLOCK_LOCKED, memory_order_seq_cst, memory_order_seq_cst); ------------------ | | 70| 20|#define ISC_RWLOCK_LOCKED true ------------------ 145| 20|} rwlock.c:read_indicator_isempty: 109| 20|read_indicator_isempty(isc_rwlock_t *rwl) { 110| 20| return atomic_load_explicit(&rwl->readers_egress, 111| 20| memory_order_seq_cst) == 112| | atomic_load_explicit(&rwl->readers_ingress, 113| 20| memory_order_seq_cst); 114| 20|} rwlock.c:writers_lock_release: 148| 20|writers_lock_release(isc_rwlock_t *rwl) { 149| 20| REQUIRE(atomic_compare_exchange_strong_explicit( ------------------ | | 198| 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))) | | ------------------ ------------------ 150| 20| &rwl->writers_lock, &(bool){ ISC_RWLOCK_LOCKED }, 151| 20| ISC_RWLOCK_UNLOCKED, memory_order_seq_cst, 152| 20| memory_order_seq_cst)); 153| 20|} rwlock.c:read_indicator_wait_until_empty: 244| 20|read_indicator_wait_until_empty(isc_rwlock_t *rwl) { 245| | /* Write-lock was acquired, now wait for running Readers to finish */ 246| 20| while (true) { ------------------ | Branch (246:9): [True: 20, Folded] ------------------ 247| 20| if (read_indicator_isempty(rwl)) { ------------------ | Branch (247:7): [True: 20, False: 0] ------------------ 248| 20| break; 249| 20| } 250| 0| isc_pause(); ------------------ | | 18| 0|#define isc_pause() _mm_pause() ------------------ 251| 0| } 252| 20|} isc_safe_memequal: 19| 34|isc_safe_memequal(const void *s1, const void *s2, size_t len) { 20| 34| return !CRYPTO_memcmp(s1, s2, len); 21| 34|} isc_safe_memwipe: 24| 91|isc_safe_memwipe(void *ptr, size_t len) { 25| 91| OPENSSL_cleanse(ptr, len); 26| 91|} isc_serial_lt: 22| 146|isc_serial_lt(uint32_t a, uint32_t b) { 23| | /* 24| | * Undefined => false 25| | */ 26| 146| if (a == (b ^ 0x80000000U)) { ------------------ | Branch (26:6): [True: 3, False: 143] ------------------ 27| 3| return false; 28| 3| } 29| 143| return ((int32_t)(a - b) < 0) ? true : false; ------------------ | Branch (29:9): [True: 74, False: 69] ------------------ 30| 146|} 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), ------------------ | | 144| 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, ------------------ | | 118| 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)); \ | | ------------------ | | | | 220| 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)); ------------------ | | 198| 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)); \ | | ------------------ | | | | 220| 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)); ------------------ | | 198| 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); ------------------ | | 198| 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); \ | | ------------------ | | | | 202| 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); ------------------ | | 198| 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)); ------------------ | | 144| 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); ------------------ | | 144| 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| 761|isc_stdtime_now(void) { 38| 761| struct timespec ts; 39| | 40| 761| if (clock_gettime(CLOCKSOURCE, &ts) == -1) { ------------------ | | 29| 761|#define CLOCKSOURCE CLOCK_REALTIME_COARSE ------------------ | Branch (40:6): [True: 0, False: 761] ------------------ 41| 0| FATAL_SYSERROR(errno, "clock_gettime()"); ------------------ | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | ------------------ | | | | 223| 0| { \ | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | ------------------ | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | ------------------ | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | 228| 0| } | | ------------------ ------------------ 42| 0| } 43| 761| INSIST(ts.tv_sec > 0 && ts.tv_nsec >= 0 && ------------------ | | 202| 761|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 3.04k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:11): [True: 761, False: 0] | | | | | Branch (54:11): [True: 761, False: 0] | | | | | Branch (54:11): [True: 761, False: 0] | | | | ------------------ | | | | 55| 761| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 44| 761| ts.tv_nsec < (long)NS_PER_SEC); 45| | 46| 761| return (isc_stdtime_t)ts.tv_sec; 47| 761|} 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); ------------------ | | 288| 2| if ((ret) != 0) { \ | | ------------------ | | | Branch (288:6): [True: 0, False: 2] | | ------------------ | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | ------------------ | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | ------------------ | | | | | | 223| 0| { \ | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | ------------------ | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | ------------------ | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | 228| 0| } | | | | ------------------ | | ------------------ | | 290| 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); ------------------ | | 198| 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); ------------------ | | 198| 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: 59| 2|isc_time_set(isc_time_t *t, unsigned int seconds, unsigned int nanoseconds) { 60| 2| REQUIRE(t != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 61| 2| REQUIRE(nanoseconds < NS_PER_SEC); ------------------ | | 198| 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))) | | ------------------ ------------------ 62| | 63| 2| t->seconds = seconds; 64| 2| t->nanoseconds = nanoseconds; 65| 2|} isc_time_isepoch: 76| 2|isc_time_isepoch(const isc_time_t *t) { 77| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 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))) | | ------------------ ------------------ 78| | 79| 2| if (t->seconds == 0 && t->nanoseconds == 0) { ------------------ | Branch (79:6): [True: 2, False: 0] | Branch (79:25): [True: 2, False: 0] ------------------ 80| 2| return true; 81| 2| } 82| | 83| 0| return false; 84| 2|} isc_time_now: 113| 10|isc_time_now(void) { 114| | return time_now(CLOCKSOURCE); ------------------ | | 42| 10|#define CLOCKSOURCE CLOCK_REALTIME_COARSE ------------------ 115| 10|} isc_time_compare: 170| 2|isc_time_compare(const isc_time_t *t1, const isc_time_t *t2) { 171| 2| REQUIRE(ISC_VALID_TIME(t1)); ------------------ | | 198| 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))) | | ------------------ ------------------ 172| 2| REQUIRE(ISC_VALID_TIME(t2)); ------------------ | | 198| 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))) | | ------------------ ------------------ 173| | 174| 2| if (t1->seconds < t2->seconds) { ------------------ | Branch (174:6): [True: 0, False: 2] ------------------ 175| 0| return -1; 176| 0| } 177| 2| if (t1->seconds > t2->seconds) { ------------------ | Branch (177:6): [True: 0, False: 2] ------------------ 178| 0| return 1; 179| 0| } 180| 2| if (t1->nanoseconds < t2->nanoseconds) { ------------------ | Branch (180:6): [True: 0, False: 2] ------------------ 181| 0| return -1; 182| 0| } 183| 2| if (t1->nanoseconds > t2->nanoseconds) { ------------------ | Branch (183:6): [True: 0, False: 2] ------------------ 184| 0| return 1; 185| 0| } 186| 2| return 0; 187| 2|} isc_time_formattimestamp: 323| 2|isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) { 324| 2| time_t now; 325| 2| unsigned int flen; 326| 2| struct tm tm; 327| | 328| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 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))) | | ------------------ ------------------ 329| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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| REQUIRE(len >= ISC_FORMATTIMESTAMP_SIZE); ------------------ | | 198| 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))) | | ------------------ ------------------ 331| | 332| 2| now = (time_t)t->seconds; 333| 2| flen = strftime(buf, len, "%d-%b-%Y %X", localtime_r(&now, &tm)); 334| 2| if (flen == 0) { ------------------ | Branch (334:6): [True: 0, False: 2] ------------------ 335| 0| strlcpy(buf, "99-Bad-9999 99:99:99.999", len); 336| 2| } else { 337| 2| snprintf(buf + flen, len - flen, ".%03u", 338| 2| t->nanoseconds / NS_PER_MS); 339| 2| } 340| 2|} isc_time_formatISO8601Lms: 386| 2|isc_time_formatISO8601Lms(const isc_time_t *t, char *buf, unsigned int len) { 387| 2| time_t now; 388| 2| unsigned int flen; 389| 2| struct tm tm; 390| | 391| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 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))) | | ------------------ ------------------ 392| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 393| 2| REQUIRE(len >= ISC_FORMATISO8601LMS_SIZE); ------------------ | | 198| 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| | 395| 2| now = (time_t)t->seconds; 396| 2| flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", localtime_r(&now, &tm)); 397| 2| if (flen == 0) { ------------------ | Branch (397:6): [True: 0, False: 2] ------------------ 398| 0| strlcpy(buf, "9999-99-99T99:99:99.999", len); 399| 2| } else { 400| 2| snprintf(buf + flen, len - flen, ".%03u", 401| 2| t->nanoseconds / NS_PER_MS); 402| 2| } 403| 2|} isc_time_formatISO8601TZms: 406| 2|isc_time_formatISO8601TZms(const isc_time_t *t, char *buf, unsigned int len) { 407| 2| char strftime_buf[64] = { 0 }; 408| 2| char ms_buf[8] = { 0 }; 409| 2| time_t now; 410| 2| unsigned int flen; 411| 2| struct tm tm; 412| | 413| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 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))) | | ------------------ ------------------ 414| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 415| 2| REQUIRE(len >= ISC_FORMATISO8601TZMS_SIZE); ------------------ | | 198| 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| | 417| 2| now = (time_t)t->seconds; 418| 2| flen = strftime(strftime_buf, len, "%Y-%m-%dT%H:%M:%S.xxx%z", 419| 2| localtime_r(&now, &tm)); 420| 2| snprintf(ms_buf, sizeof(ms_buf), ".%03u", t->nanoseconds / NS_PER_MS); 421| | 422| 2| INSIST(flen < len); ------------------ | | 202| 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))) | | ------------------ ------------------ 423| 2| size_t local_date_len = sizeof("yyyy-mm-ddThh:mm:ss") - 1ul; 424| 2| size_t ms_date_len = local_date_len + 4; 425| | 426| 2| memmove(buf, strftime_buf, local_date_len); 427| 2| memmove(buf + local_date_len, ms_buf, 4); 428| 2| memmove(buf + ms_date_len, strftime_buf + ms_date_len, 3); 429| 2| buf[ms_date_len + 3] = ':'; 430| 2| memmove(buf + ms_date_len + 4, strftime_buf + ms_date_len + 3, 3); 431| 2|} isc_time_formatISO8601ms: 450| 2|isc_time_formatISO8601ms(const isc_time_t *t, char *buf, unsigned int len) { 451| 2| time_t now; 452| 2| unsigned int flen; 453| 2| struct tm tm; 454| | 455| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 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))) | | ------------------ ------------------ 456| 2| REQUIRE(buf != NULL); ------------------ | | 198| 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))) | | ------------------ ------------------ 457| 2| REQUIRE(len >= ISC_FORMATISO8601MS_SIZE); ------------------ | | 198| 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| | 459| 2| now = (time_t)t->seconds; 460| 2| flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", gmtime_r(&now, &tm)); 461| 2| if (flen == 0) { ------------------ | Branch (461:6): [True: 0, False: 2] ------------------ 462| 0| strlcpy(buf, "9999-99-99T99:99:99.999Z", len); 463| 2| } else { 464| 2| snprintf(buf + flen, len - flen, ".%03uZ", 465| 2| t->nanoseconds / NS_PER_MS); 466| 2| } 467| 2|} time.c:time_now: 87| 10|time_now(clockid_t clock) { 88| 10| isc_time_t t; 89| 10| struct timespec ts; 90| | 91| 10| RUNTIME_CHECK(clock_gettime(clock, &ts) == 0); ------------------ | | 245| 10| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 10, False: 0] | | ------------------ ------------------ 92| 10| INSIST(ts.tv_sec >= 0 && ts.tv_nsec >= 0 && ------------------ | | 202| 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))) | | ------------------ ------------------ 93| 10| ts.tv_nsec < (long)NS_PER_SEC); 94| | 95| | /* 96| | * Ensure the tv_sec value fits in t->seconds. 97| | */ 98| 10| INSIST(sizeof(ts.tv_sec) <= sizeof(t.seconds) || ------------------ | | 202| 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))) | | ------------------ ------------------ 99| 10| ((ts.tv_sec | (unsigned int)-1) ^ (unsigned int)-1) == 0U); 100| | 101| 10| t.seconds = ts.tv_sec; 102| 10| t.nanoseconds = ts.tv_nsec; 103| | 104| 10| return t; 105| 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); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245: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); ------------------ | | 236| 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)); \ | | ------------------ | | | | 220| 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| 2|isc__uv_realloc(void *ptr, size_t size) { 114| 2| return isc_mem_reallocate(isc__uv_mctx, ptr, size); ------------------ | | 164| 2| isc__mem_reallocate((c), (p), (s), 0 _ISC_MEM_FILELINE) ------------------ 115| 2|} uv.c:isc__uv_calloc: 118| 2|isc__uv_calloc(size_t count, size_t size) { 119| | return isc_mem_callocate(isc__uv_mctx, count, size); ------------------ | | 161| 2| isc__mem_allocate((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); \ | | | | ------------------ | | | | | | 202| 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| }) | | ------------------ | | 162| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 120| 2|} 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|}