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.57k|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 318| 1.57k| isc_result_t result; 319| 1.57k| dns_message_t *message = NULL; 320| 1.57k| unsigned char query_tsig[23 + 32 + 6] = { 0 }; 321| 1.57k| bool addasig = false; 322| 1.57k| bool addtime = false; 323| 1.57k| bool addtsig = false; 324| 1.57k| bool setquerytsig = false; 325| 1.57k| bool settsigkey = false; 326| 1.57k| bool subtime = false; 327| 1.57k| bool withring = false; 328| 1.57k| 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.57k| if (size > 65535 || size < 2) { ------------------ | Branch (341:6): [True: 1, False: 1.57k] | Branch (341:22): [True: 1, False: 1.57k] ------------------ 342| 2| return 0; 343| 2| } 344| | 345| 1.57k| addasig = (*data & 0x80) != 0; 346| 1.57k| addtime = (*data & 0x40) != 0; 347| 1.57k| addtsig = (*data & 0x20) != 0; 348| 1.57k| setquerytsig = (*data & 0x10) != 0; 349| 1.57k| settsigkey = (*data & 0x08) != 0; 350| 1.57k| subtime = (*data & 0x04) != 0; 351| 1.57k| withring = (*data & 0x02) != 0; 352| 1.57k| withview = (*data & 0x01) != 0; 353| | 354| 1.57k| data++; 355| 1.57k| size--; 356| | 357| 1.57k| if (debug) { ------------------ | Branch (357:6): [True: 0, False: 1.57k] ------------------ 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.57k| result = create_message(&message, data, size, addasig, addtsig); 366| 1.57k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (366:6): [True: 486, False: 1.09k] ------------------ 367| 486| return 0; 368| 486| } 369| | 370| | /* 371| | * Make time calculations consistent. 372| | */ 373| 1.09k| message->fuzzing = 1; 374| 1.09k| message->fuzztime = fuzztime; 375| 1.09k| if (addtime) { ------------------ | Branch (375:6): [True: 295, False: 796] ------------------ 376| 295| message->fuzztime += 1200; 377| 295| } 378| 1.09k| if (subtime) { ------------------ | Branch (378:6): [True: 666, False: 425] ------------------ 379| 666| message->fuzztime -= 1200; 380| 666| } 381| | 382| 1.09k| if ((message->flags & DNS_MESSAGEFLAG_QR) != 0) { ------------------ | Branch (382:6): [True: 367, False: 724] ------------------ 383| 367| if (setquerytsig) { ------------------ | Branch (383:7): [True: 249, False: 118] ------------------ 384| 249| isc_buffer_t b; 385| 249| unsigned char hmacname[] = HMACSHA256; ------------------ | | 87| 249|#define HMACSHA256 "\x0bhmac-sha256" ------------------ 386| 249| unsigned char hmacvalue[32] = { 387| 249| 0x22, 0x4d, 0x58, 0x07, 0x64, 0x8d, 0x14, 0x00, 388| 249| 0x9d, 0x8e, 0xfc, 0x1c, 0xd0, 0x49, 0x55, 0xe9, 389| 249| 0xcc, 0x90, 0x21, 0x87, 0x3b, 0x5f, 0xaf, 0x5c, 390| 249| 0x88, 0x99, 0xdc, 0x27, 0xc8, 0xdf, 0xb3, 0x4b 391| 249| }; 392| | 393| | /* 394| | * Valid TSIG rdata for tsig-key over a plain 395| | * DNS QUERY for ./SOA/IN with no flags set. 396| | */ 397| 249| isc_buffer_init(&b, query_tsig, sizeof(query_tsig)); 398| 249| isc_buffer_putmem(&b, hmacname, sizeof(hmacname)); 399| 249| isc_buffer_putuint16(&b, 0); /* time high */ 400| 249| isc_buffer_putuint32(&b, 0x622abec0); /* time low */ 401| 249| isc_buffer_putuint16(&b, 300); /* Fudge */ 402| 249| isc_buffer_putuint16(&b, 32); /* Mac Length */ 403| | /* Mac */ 404| 249| isc_buffer_putmem(&b, hmacvalue, 32); 405| 249| isc_buffer_putuint16(&b, 7674); /* Original Id */ 406| 249| isc_buffer_putuint16(&b, 0); /* Error */ 407| 249| isc_buffer_putuint16(&b, 0); /* Other len */ 408| | 409| 249| dns_message_setquerytsig(message, &b); 410| 249| } 411| 367| } 412| | 413| 1.09k| if (settsigkey) { ------------------ | Branch (413:6): [True: 294, False: 797] ------------------ 414| 294| result = dns_message_settsigkey(message, tsigkey); 415| 294| if (debug) { ------------------ | Branch (415:7): [True: 0, False: 294] ------------------ 416| 0| fprintf(stderr, "dns_message_settsigkey => %s\n", 417| 0| isc_result_totext(result)); 418| 0| } 419| 294| } 420| | 421| 1.09k| dns_view_setkeyring(view, withring ? ring : emptyring); ------------------ | Branch (421:28): [True: 698, False: 393] ------------------ 422| | 423| 1.09k| result = dns_message_checksig(message, withview ? view : NULL); ------------------ | Branch (423:41): [True: 907, False: 184] ------------------ 424| 1.09k| if (debug) { ------------------ | Branch (424:6): [True: 0, False: 1.09k] ------------------ 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.09k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (437:6): [True: 1.01k, False: 76] ------------------ 438| 1.01k| goto cleanup; 439| 1.01k| } 440| | 441| 1.09k|cleanup: 442| 1.09k| if (message != NULL) { ------------------ | Branch (442:6): [True: 1.09k, False: 0] ------------------ 443| 1.09k| dns_message_detach(&message); 444| 1.09k| } 445| | 446| 1.09k| return 0; 447| 1.09k|} dns_message_checksig.c:create_message: 242| 1.57k| bool addasig, bool addtsig) { 243| 1.57k| isc_result_t result; 244| 1.57k| dns_message_t *message = NULL; 245| 1.57k| isc_buffer_t b; 246| 1.57k| static unsigned char buf[65535]; 247| | 248| 1.57k| isc_buffer_init(&b, buf, sizeof(buf)); 249| | 250| | /* Message ID */ 251| 1.57k| isc_buffer_putuint16(&b, 0); 252| | 253| | /* QR, Opcode, other flags = 0, rcode = 0 */ 254| 1.57k| isc_buffer_putuint16(&b, (*data & 0x1f) << 11); 255| | /* Counts */ 256| 1.57k| isc_buffer_putuint16(&b, 1); 257| 1.57k| isc_buffer_putuint16(&b, 0); 258| 1.57k| isc_buffer_putuint16(&b, 0); 259| 1.57k| isc_buffer_putuint16(&b, addasig ? 1 : 0); ------------------ | Branch (259:27): [True: 1.55k, False: 19] ------------------ 260| | 261| | /* Question ./IN/SOA */ 262| 1.57k| isc_buffer_putuint8(&b, 0); 263| 1.57k| isc_buffer_putuint16(&b, 6); 264| 1.57k| isc_buffer_putuint16(&b, 1); 265| | 266| 1.57k| if (addasig) { ------------------ | Branch (266:6): [True: 1.55k, False: 19] ------------------ 267| | /* Signature */ 268| 1.55k| if (addtsig) { ------------------ | Branch (268:7): [True: 924, False: 634] ------------------ 269| 924| const unsigned char keyname[] = "\x08tsig-key"; 270| 924| isc_buffer_putmem(&b, keyname, sizeof(keyname)); 271| 924| isc_buffer_putuint16(&b, dns_rdatatype_tsig); ------------------ | | 191| 924|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ 272| 924| isc_buffer_putuint16(&b, dns_rdataclass_any); ------------------ | | 34| 924|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ 273| 924| } else { 274| 634| isc_buffer_putuint8(&b, 0); /* '.' */ 275| 634| isc_buffer_putuint16(&b, dns_rdatatype_sig); ------------------ | | 139| 634|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ 276| 634| isc_buffer_putuint16(&b, dns_rdataclass_in); ------------------ | | 24| 634|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ 277| 634| } 278| 1.55k| isc_buffer_putuint32(&b, 0); /* ttl */ 279| 1.55k| data++; 280| 1.55k| size--; 281| 1.55k| if (size > isc_buffer_availablelength(&b) - 2) { ------------------ | | 162| 1.55k|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (281:7): [True: 8, False: 1.55k] ------------------ 282| 8| size = isc_buffer_availablelength(&b) - 2; ------------------ | | 162| 8|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 283| 8| } 284| 1.55k| isc_buffer_putuint16(&b, size); 285| 1.55k| isc_buffer_putmem(&b, data, size); 286| 1.55k| } 287| | 288| 1.57k| dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &message); 289| | 290| 1.57k| result = dns_message_parse(message, &b, 0); 291| 1.57k| if (debug) { ------------------ | Branch (291:6): [True: 0, False: 1.57k] ------------------ 292| 0| fprintf(stderr, "dns_message_parse => %s\n", 293| 0| isc_result_totext(result)); 294| 0| } 295| 1.57k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (295:6): [True: 486, False: 1.09k] ------------------ 296| 486| dns_message_detach(&message); 297| 1.09k| } else { 298| 1.09k| if (debug) { ------------------ | Branch (298:7): [True: 0, False: 1.09k] ------------------ 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.09k| *messagep = message; 312| 1.09k| } 313| 1.57k| return result; 314| 1.57k|} 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | | | | | ------------------ | | | | | | | | 53| 4| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 4, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 130| 2| REQUIRE(dns_name_isabsolute(origin)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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| | 145| 2| if (result == ISC_R_SUCCESS && type != dns_dbtype_cache && ------------------ | Branch (145:7): [True: 2, False: 0] | Branch (145:34): [True: 2, False: 0] ------------------ 146| 2| (*dbp)->methods->addglue == NULL) ------------------ | Branch (146:7): [True: 0, False: 2] ------------------ 147| 0| { 148| 0| isc_log_write(DNS_LOGCATEGORY_DATABASE, 149| 0| DNS_LOGMODULE_DB, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 150| 0| "database type '%s' does not implement " 151| 0| "required addglue method", 152| 0| db_type); 153| 0| dns_db_detach(dbp); 154| 0| result = ISC_R_NOTIMPLEMENTED; 155| 0| } 156| 2| return result; 157| 2| } 158| | 159| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 160| | 161| 0| isc_log_write(DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DB, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 162| 0| "unsupported database type '%s'", db_type); 163| | 164| 0| return ISC_R_NOTFOUND; 165| 0|} dns_db_iscache: 179| 208|dns_db_iscache(dns_db_t *db) { 180| | /* 181| | * Does 'db' have cache semantics? 182| | */ 183| | 184| 208| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 185| | 186| 208| if ((db->attributes & DNS_DBATTR_CACHE) != 0) { ------------------ | Branch (186:6): [True: 0, False: 208] ------------------ 187| 0| return true; 188| 0| } 189| | 190| 208| return false; 191| 208|} dns_db_iszone: 194| 4|dns_db_iszone(dns_db_t *db) { 195| | /* 196| | * Does 'db' have zone semantics? 197| | */ 198| | 199| 4| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 200| | 201| 4| if ((db->attributes & (DNS_DBATTR_CACHE | DNS_DBATTR_STUB)) == 0) { ------------------ | Branch (201:6): [True: 4, False: 0] ------------------ 202| 4| return true; 203| 4| } 204| | 205| 0| return false; 206| 4|} dns_db_issecure: 224| 2|dns_db_issecure(dns_db_t *db) { 225| | /* 226| | * Is 'db' secure? 227| | */ 228| | 229| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 230| 2| REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 231| | 232| 2| if (db->methods->issecure != NULL) { ------------------ | Branch (232:6): [True: 2, False: 0] ------------------ 233| 2| return (db->methods->issecure)(db); 234| 2| } 235| 0| return false; 236| 2|} dns_db_ispersistent: 239| 4|dns_db_ispersistent(dns_db_t *db) { 240| | /* 241| | * Is 'db' persistent? 242| | */ 243| | 244| 4| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 245| | 246| 4| if (db->methods->beginload == NULL) { ------------------ | Branch (246:6): [True: 0, False: 4] ------------------ 247| | /* If the database can't be loaded, assume it's persistent */ 248| 0| return true; 249| 0| } 250| | 251| 4| return false; 252| 4|} dns_db_beginload: 277| 2|dns_db_beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 278| | /* 279| | * Begin loading 'db'. 280| | */ 281| | 282| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 283| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 284| | 285| 2| if (db->methods->beginload != NULL) { ------------------ | Branch (285:6): [True: 2, False: 0] ------------------ 286| 2| return (db->methods->beginload)(db, callbacks); 287| 2| } 288| 0| return ISC_R_NOTIMPLEMENTED; 289| 2|} dns_db_endload: 292| 2|dns_db_endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 293| | /* 294| | * Finish loading 'db'. 295| | */ 296| | 297| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 298| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 299| 2| REQUIRE(callbacks->add_private != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 300| | 301| | /* 302| | * When dns_db_endload() is called, we call the onupdate function 303| | * for all registered listeners, regardless of whether the underlying 304| | * database has an 'endload' implementation. 305| | */ 306| 2| call_updatenotify(db); 307| | 308| 2| if (db->methods->endload != NULL) { ------------------ | Branch (308:6): [True: 2, False: 0] ------------------ 309| 2| return (db->methods->endload)(db, callbacks); 310| 2| } 311| | 312| 0| return ISC_R_NOTIMPLEMENTED; 313| 2|} dns_db_currentversion: 407| 6|dns_db_currentversion(dns_db_t *db, dns_dbversion_t **versionp) { 408| | /* 409| | * Open the current version for reading. 410| | */ 411| | 412| 6| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 413| 6| REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 414| 6| REQUIRE(versionp != NULL && *versionp == NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 415| | 416| 6| (db->methods->currentversion)(db, versionp); 417| 6|} dns__db_closeversion: 454| 6| bool commit DNS__DB_FLARG) { 455| | /* 456| | * Close version '*versionp'. 457| | */ 458| | 459| 6| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 460| 6| REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 461| 6| REQUIRE(versionp != NULL && *versionp != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 462| | 463| 6| (db->methods->closeversion)(db, versionp, commit DNS__DB_FLARG_PASS); 464| | 465| 6| if (commit) { ------------------ | Branch (465:6): [True: 0, False: 6] ------------------ 466| 0| call_updatenotify(db); 467| 0| } 468| | 469| 6| ENSURE(*versionp == NULL); ------------------ | | 200| 6|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 6, False: 0] | | | | ------------------ | | | | 48| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 470| 6|} dns__db_findnode: 479| 6| dns_dbnode_t **nodep DNS__DB_FLARG) { 480| | /* 481| | * Find the node with name 'name', passing 'arg' to the database 482| | * implementation. 483| | */ 484| | 485| 6| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 486| 6| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 487| | 488| 6| if (db->methods->findnode != NULL) { ------------------ | Branch (488:6): [True: 6, False: 0] ------------------ 489| 6| return (db->methods->findnode)(db, name, create, methods, 490| 6| clientinfo, 491| 6| nodep DNS__DB_FLARG_PASS); 492| 6| } 493| 0| return ISC_R_NOTIMPLEMENTED; 494| 6|} dns__db_find: 515| 208| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 516| | /* 517| | * Find the best match for 'name' and 'type' in version 'version' 518| | * of 'db', passing in 'arg'. 519| | */ 520| | 521| 208| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 522| 208| REQUIRE(type != dns_rdatatype_rrsig); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 523| 208| REQUIRE(dns_name_hasbuffer(foundname)); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 524| 208| REQUIRE(rdataset == NULL || (DNS_RDATASET_VALID(rdataset) && ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 0, False: 208] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 525| 208| !dns_rdataset_isassociated(rdataset))); 526| 208| REQUIRE(sigrdataset == NULL || ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 527| 208| (DNS_RDATASET_VALID(sigrdataset) && 528| 208| !dns_rdataset_isassociated(sigrdataset))); 529| | 530| 208| if (db->methods->find != NULL) { ------------------ | Branch (530:6): [True: 208, False: 0] ------------------ 531| 208| return (db->methods->find)(db, name, version, type, options, 532| 208| now, foundname, methods, clientinfo, 533| 208| rdataset, 534| 208| sigrdataset DNS__DB_FLARG_PASS); 535| 208| } 536| 0| return ISC_R_NOTIMPLEMENTED; 537| 208|} dns__db_detachnode: 553| 8|dns__db_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) { 554| | /* 555| | * Detach *nodep from its node. 556| | */ 557| | 558| 8| REQUIRE(nodep != NULL && *nodep != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 559| 8| dns_dbnode_t *node = *nodep; 560| 8| REQUIRE(node->methods != NULL && node->methods->detachnode != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 561| | 562| 8| (node->methods->detachnode)(nodep DNS__DB_FLARG_PASS); 563| | 564| 8| ENSURE(*nodep == NULL); ------------------ | | 200| 8|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 8, False: 0] | | | | ------------------ | | | | 48| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 565| 8|} dns__db_findrdataset: 608| 14| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 609| 14| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 610| 14| REQUIRE(node != NULL); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 611| 14| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 612| 14| REQUIRE(!dns_rdataset_isassociated(rdataset)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 613| 14| REQUIRE(covers == dns_rdatatype_none || dns_rdatatype_issig(type)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 614| 14| REQUIRE(type != dns_rdatatype_any); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 615| 14| REQUIRE(sigrdataset == NULL || ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 616| 14| (DNS_RDATASET_VALID(sigrdataset) && 617| 14| !dns_rdataset_isassociated(sigrdataset))); 618| | 619| 14| return (db->methods->findrdataset)(db, node, version, type, covers, now, 620| 14| rdataset, 621| 14| sigrdataset DNS__DB_FLARG_PASS); 622| 14|} dns_db_nodecount: 764| 2|dns_db_nodecount(dns_db_t *db) { 765| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 766| | 767| 2| if (db->methods->nodecount != NULL) { ------------------ | Branch (767:6): [True: 2, False: 0] ------------------ 768| 2| return (db->methods->nodecount)(db); 769| 2| } 770| 0| return 0; 771| 2|} dns__db_getoriginnode: 819| 2|dns__db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { 820| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 821| 2| REQUIRE(dns_db_iszone(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 822| 2| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 823| | 824| 2| if (db->methods->getoriginnode != NULL) { ------------------ | Branch (824:6): [True: 2, False: 0] ------------------ 825| 2| return (db->methods->getoriginnode)(db, 826| 2| nodep DNS__DB_FLARG_PASS); 827| 2| } else if (db->methods->findnode != NULL) { ------------------ | Branch (827:13): [True: 0, False: 0] ------------------ 828| 0| return (db->methods->findnode)(db, &db->origin, false, NULL, 829| 0| NULL, nodep DNS__DB_FLARG_PASS); 830| 0| } 831| | 832| 0| return ISC_R_NOTFOUND; 833| 2|} dns_db_setgluecachestats: 1045| 2|dns_db_setgluecachestats(dns_db_t *db, isc_stats_t *stats) { 1046| 2| REQUIRE(dns_db_iszone(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1047| 2| REQUIRE(stats != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1048| | 1049| 2| if (db->methods->setgluecachestats != NULL) { ------------------ | Branch (1049:6): [True: 2, False: 0] ------------------ 1050| 2| return (db->methods->setgluecachestats)(db, stats); 1051| 2| } 1052| | 1053| 0| return ISC_R_NOTIMPLEMENTED; 1054| 2|} dns_db_setmaxrrperset: 1081| 2|dns_db_setmaxrrperset(dns_db_t *db, uint32_t value) { 1082| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1083| | 1084| 2| if (db->methods->setmaxrrperset != NULL) { ------------------ | Branch (1084:6): [True: 2, False: 0] ------------------ 1085| 2| (db->methods->setmaxrrperset)(db, value); 1086| 2| } 1087| 2|} dns_db_setmaxtypepername: 1090| 2|dns_db_setmaxtypepername(dns_db_t *db, uint32_t value) { 1091| 2| REQUIRE(DNS_DB_VALID(db)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1092| | 1093| 2| if (db->methods->setmaxtypepername != NULL) { ------------------ | Branch (1093:6): [True: 2, False: 0] ------------------ 1094| 2| (db->methods->setmaxtypepername)(db, value); 1095| 2| } 1096| 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: 908| 2|call_updatenotify(dns_db_t *db) { 909| 2| rcu_read_lock(); 910| 2| struct cds_lfht *update_listeners = 911| 2| rcu_dereference(db->update_listeners); 912| 2| if (update_listeners != NULL) { ------------------ | Branch (912:6): [True: 2, False: 0] ------------------ 913| 2| struct cds_lfht_iter iter; 914| 2| dns_dbonupdatelistener_t *listener; 915| 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)) ------------------ 916| 2| ht_node) { 917| 0| if (!cds_lfht_is_node_deleted(&listener->ht_node)) { ------------------ | Branch (917:8): [True: 0, False: 0] ------------------ 918| 0| listener->onupdate(db, listener->onupdate_arg); 919| 0| } 920| 0| } 921| 2| } 922| | rcu_read_unlock(); 923| 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: ------------------ | | 121| 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: ------------------ | | 116| 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: ------------------ | | 130| 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: ------------------ | | 143| 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: ------------------ | | 162| 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: ------------------ | | 165| 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: ------------------ | | 117| 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: ------------------ | | 158| 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: ------------------ | | 120| 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: ------------------ | | 154| 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: ------------------ | | 178| 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: ------------------ | | 179| 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: ------------------ | | 163| 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: ------------------ | | 148| 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: ------------------ | | 131| 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: ------------------ | | 127| 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: ------------------ | | 150| 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: 87| 2|dns__dlz_initialize(void) { 88| 2| isc_rwlock_init(&dlz_implock); 89| | 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] | | ------------------ ------------------ 90| 2|} dns_dnssec_keyfromrdata: 126| 82| isc_mem_t *mctx, dst_key_t **key) { 127| 82| isc_buffer_t b; 128| 82| isc_region_t r; 129| | 130| 82| INSIST(DNS_NAME_VALID(name)); ------------------ | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 82, False: 0] | | | | | Branch (53:11): [True: 82, False: 0] | | | | ------------------ | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 131| 82| INSIST(rdata != NULL); ------------------ | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 82, False: 0] | | | | ------------------ | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 132| 82| INSIST(mctx != NULL); ------------------ | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 82, False: 0] | | | | ------------------ | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 133| 82| INSIST(key != NULL); ------------------ | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 82, False: 0] | | | | ------------------ | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 134| 82| INSIST(*key == NULL); ------------------ | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 82, False: 0] | | | | ------------------ | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 135| 82| REQUIRE(rdata->type == dns_rdatatype_key || ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 82, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 136| 82| rdata->type == dns_rdatatype_dnskey); 137| | 138| | /* 139| | * Extract the algorithm from the raw data to perform validation before 140| | * actually converting it to a key. Expecting at least 4 bytes: flags 141| | * (2b), protocol (1b), algorithm (1b). 142| | */ 143| 82| if (rdata->length < 4) { ------------------ | Branch (143:6): [True: 0, False: 82] ------------------ 144| 0| return DST_R_INVALIDPUBLICKEY; 145| 0| } 146| 82| const unsigned int alg = rdata->data[3]; 147| | 148| 82| switch (rdata->type) { 149| 0| case dns_rdatatype_dnskey: ------------------ | | 163| 0|#define dns_rdatatype_dnskey ((dns_rdatatype_t)dns_rdatatype_dnskey) ------------------ | Branch (149:2): [True: 0, False: 82] ------------------ 150| | /* 151| | * Reject non DNSSEC code points (includes appropriated 152| | * code points). 153| | */ 154| 0| if (!dst_dnssec_algorithm(alg)) { ------------------ | Branch (154:7): [True: 0, False: 0] ------------------ 155| 0| return DST_R_UNSUPPORTEDALG; 156| 0| } 157| 0| break; 158| 82| case dns_rdatatype_key: ------------------ | | 140| 82|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ | Branch (158:2): [True: 82, False: 0] ------------------ 159| | /* 160| | * Reject non SIG(0) code points (includes appropriated 161| | * code points). 162| | */ 163| 82| if (alg == DST_ALG_DH || ------------------ | Branch (163:7): [True: 0, False: 82] ------------------ 164| 82| (alg >= DST_ALG_HMAC_FIRST && alg <= DST_ALG_HMAC_LAST)) ------------------ | Branch (164:8): [True: 0, False: 82] | Branch (164:37): [True: 0, False: 0] ------------------ 165| 0| { 166| 0| return DST_R_UNSUPPORTEDALG; 167| 0| } 168| 82| break; 169| 82| default: ------------------ | Branch (169:2): [True: 0, False: 82] ------------------ 170| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 171| 82| } 172| | 173| 82| dns_rdata_toregion(rdata, &r); 174| 82| isc_buffer_init(&b, r.base, r.length); 175| 82| isc_buffer_add(&b, r.length); 176| 82| return dst_key_fromdns(name, rdata->rdclass, &b, mctx, key); 177| 82|} dns_dnssec_verifymessage: 928| 82| dst_key_t *key) { 929| 82| dns_rdata_sig_t sig; /* SIG(0) */ 930| 82| unsigned char header[DNS_MESSAGE_HEADERLEN]; 931| 82| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 82| { \ | | 150| 82| .data = NULL, \ | | 151| 82| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 82|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 82| { \ | | | | | | 27| 82| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 82|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 82| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 82|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 82| } | | | | ------------------ | | ------------------ | | 152| 82| } ------------------ 932| 82| isc_region_t r, source_r, sig_r, header_r; 933| 82| isc_stdtime_t now; 934| 82| dst_context_t *ctx = NULL; 935| 82| isc_mem_t *mctx; 936| 82| isc_result_t result; 937| 82| uint16_t addcount, addcount_n; 938| | 939| 82| REQUIRE(source != NULL); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 940| 82| REQUIRE(msg != NULL); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 941| 82| REQUIRE(key != NULL); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 942| | 943| 82| mctx = msg->mctx; 944| | 945| 82| msg->verify_attempted = 1; 946| 82| msg->verified_sig = 0; 947| 82| msg->sig0status = dns_tsigerror_badsig; 948| | 949| 82| if (is_response(msg)) { ------------------ | | 44| 82|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) | | ------------------ | | | Branch (44:26): [True: 2, False: 80] | | ------------------ ------------------ 950| 2| if (msg->query.base == NULL) { ------------------ | Branch (950:7): [True: 2, False: 0] ------------------ 951| 2| return DNS_R_UNEXPECTEDTSIG; 952| 2| } 953| 2| } 954| | 955| 80| isc_buffer_usedregion(source, &source_r); 956| | 957| 80| CHECK(dns_rdataset_first(msg->sig0)); ------------------ | | 255| 80| { \ | | 256| 80| result = (r); \ | | 257| 80| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 80] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 80| } ------------------ 958| 80| dns_rdataset_current(msg->sig0, &rdata); 959| | 960| 80| CHECK(dns_rdata_tostruct(&rdata, &sig)); ------------------ | | 255| 80| { \ | | 256| 80| result = (r); \ | | 257| 80| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 80] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 80| } ------------------ 961| | 962| 80| if (sig.labels != 0) { ------------------ | Branch (962:6): [True: 6, False: 74] ------------------ 963| 6| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 266| 6| { \ | | 267| 6| result = (r); \ | | 268| 6| goto cleanup; \ | | 269| 6| } ------------------ 964| 0| } 965| | 966| 74| if (isc_serial_lt(sig.timeexpire, sig.timesigned)) { ------------------ | Branch (966:6): [True: 42, False: 32] ------------------ 967| 42| msg->sig0status = dns_tsigerror_badtime; 968| 42| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 266| 42| { \ | | 267| 42| result = (r); \ | | 268| 42| goto cleanup; \ | | 269| 42| } ------------------ 969| 0| } 970| | 971| 32| if (msg->fuzzing) { ------------------ | Branch (971:6): [True: 32, False: 0] ------------------ 972| 32| now = msg->fuzztime; 973| 32| } else { 974| 0| now = isc_stdtime_now(); 975| 0| } 976| | 977| 32| if (isc_serial_lt((uint32_t)now, sig.timesigned)) { ------------------ | Branch (977:6): [True: 7, False: 25] ------------------ 978| 7| msg->sig0status = dns_tsigerror_badtime; 979| 7| CLEANUP(DNS_R_SIGFUTURE); ------------------ | | 266| 7| { \ | | 267| 7| result = (r); \ | | 268| 7| goto cleanup; \ | | 269| 7| } ------------------ 980| 25| } else if (isc_serial_lt(sig.timeexpire, (uint32_t)now)) { ------------------ | Branch (980:13): [True: 13, False: 12] ------------------ 981| 13| msg->sig0status = dns_tsigerror_badtime; 982| 13| CLEANUP(DNS_R_SIGEXPIRED); ------------------ | | 266| 13| { \ | | 267| 13| result = (r); \ | | 268| 13| goto cleanup; \ | | 269| 13| } ------------------ 983| 0| } 984| | 985| 12| if (!dns_name_equal(dst_key_name(key), &sig.signer)) { ------------------ | | 1541| 12| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 12| _Generic((arg), \ | | | | 1508| 12| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 12| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 12| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 12| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 12| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 12| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 12| _Generic((arg), \ | | | | 1508| 12| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 12| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 12| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 12| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 12| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 12| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (985:6): [True: 0, False: 12] ------------------ 986| 0| msg->sig0status = dns_tsigerror_badkey; 987| 0| CLEANUP(DNS_R_SIGINVALID); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 988| 0| } 989| | 990| 12| CHECK(dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, false, ------------------ | | 255| 12| { \ | | 256| 12| result = (r); \ | | 257| 12| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 12] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 12| } ------------------ 991| 12| &ctx)); 992| | 993| | /* 994| | * Digest the SIG(0) record, except for the signature. 995| | */ 996| 12| dns_rdata_toregion(&rdata, &r); 997| 12| r.length -= sig.siglen; 998| 12| CHECK(dst_context_adddata(ctx, &r)); ------------------ | | 255| 12| { \ | | 256| 12| result = (r); \ | | 257| 12| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 12] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 12| } ------------------ 999| | 1000| | /* 1001| | * If this is a response, digest the query. 1002| | */ 1003| 12| if (is_response(msg)) { ------------------ | | 44| 12|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) | | ------------------ | | | Branch (44:26): [True: 0, False: 12] | | ------------------ ------------------ 1004| 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| } ------------------ 1005| 0| } 1006| | 1007| | /* 1008| | * Extract the header. 1009| | */ 1010| 12| memmove(header, source_r.base, DNS_MESSAGE_HEADERLEN); ------------------ | | 145| 12|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1011| | 1012| | /* 1013| | * Decrement the additional field counter. 1014| | */ 1015| 12| memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2); ------------------ | | 145| 12|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1016| 12| addcount_n = ntohs(addcount); 1017| 12| addcount = htons((uint16_t)(addcount_n - 1)); 1018| 12| memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2); ------------------ | | 145| 12|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1019| | 1020| | /* 1021| | * Digest the modified header. 1022| | */ 1023| 12| header_r.base = (unsigned char *)header; 1024| 12| header_r.length = DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 12|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1025| 12| CHECK(dst_context_adddata(ctx, &header_r)); ------------------ | | 255| 12| { \ | | 256| 12| result = (r); \ | | 257| 12| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 12] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 12| } ------------------ 1026| | 1027| | /* 1028| | * Digest all non-SIG(0) records. 1029| | */ 1030| 12| r.base = source_r.base + DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 12|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1031| 12| r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 12|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1032| 12| CHECK(dst_context_adddata(ctx, &r)); ------------------ | | 255| 12| { \ | | 256| 12| result = (r); \ | | 257| 12| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 12] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 12| } ------------------ 1033| | 1034| 12| sig_r.base = sig.signature; 1035| 12| sig_r.length = sig.siglen; 1036| 12| result = dst_context_verify(ctx, &sig_r); 1037| 12| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1037:6): [True: 11, False: 1] ------------------ 1038| 11| msg->sig0status = dns_tsigerror_badsig; 1039| 11| goto cleanup; 1040| 11| } 1041| | 1042| 1| msg->verified_sig = 1; 1043| 1| msg->sig0status = dns_rcode_noerror; ------------------ | | 270| 1|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 1044| | 1045| 1| dst_context_destroy(&ctx); 1046| | 1047| 1| return ISC_R_SUCCESS; 1048| | 1049| 79|cleanup: 1050| 79| if (ctx != NULL) { ------------------ | Branch (1050:6): [True: 11, False: 68] ------------------ 1051| 11| dst_context_destroy(&ctx); 1052| 11| } 1053| | 1054| 79| return result; 1055| 12|} 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| 127|dst_algorithm_supported(unsigned int alg) { 247| 127| if (alg >= DST_MAX_ALGS || dst_t_func[alg] == NULL) { ------------------ | Branch (247:6): [True: 0, False: 127] | Branch (247:29): [True: 0, False: 127] ------------------ 248| 0| return false; 249| 0| } 250| 127| return true; 251| 127|} dst_context_create: 280| 41| bool useforsigning, dst_context_t **dctxp) { 281| 41| dst_context_t *dctx; 282| 41| isc_result_t result; 283| | 284| 41| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 41|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 41, False: 0] | | | | | Branch (41:11): [True: 41, False: 0] | | | | ------------------ | | | | 42| 41| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 285| 41| REQUIRE(mctx != NULL); ------------------ | | 198| 41|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 41| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 41, False: 0] | | | | ------------------ | | | | 42| 41| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 286| 41| REQUIRE(dctxp != NULL && *dctxp == NULL); ------------------ | | 198| 41|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 41, False: 0] | | | | | Branch (41:11): [True: 41, False: 0] | | | | ------------------ | | | | 42| 41| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 287| | 288| 41| if (key->func->createctx == NULL) { ------------------ | Branch (288:6): [True: 0, False: 41] ------------------ 289| 0| return DST_R_UNSUPPORTEDALG; 290| 0| } 291| 41| if (key->keydata.generic == NULL) { ------------------ | Branch (291:6): [True: 0, False: 41] ------------------ 292| 0| return DST_R_NULLKEY; 293| 0| } 294| | 295| 41| dctx = isc_mem_get(mctx, sizeof(*dctx)); ------------------ | | 144| 41|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 296| 41| *dctx = (dst_context_t){ 297| 41| .category = category, 298| 41| .use = (useforsigning) ? DO_SIGN : DO_VERIFY, ------------------ | Branch (298:10): [True: 0, False: 41] ------------------ 299| 41| }; 300| | 301| 41| dst_key_attach(key, &dctx->key); 302| 41| isc_mem_attach(mctx, &dctx->mctx); 303| 41| result = key->func->createctx(key, dctx); 304| 41| if (result != ISC_R_SUCCESS) { ------------------ | Branch (304:6): [True: 0, False: 41] ------------------ 305| 0| if (dctx->key != NULL) { ------------------ | Branch (305:7): [True: 0, False: 0] ------------------ 306| 0| dst_key_free(&dctx->key); 307| 0| } 308| 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] | | ------------------ ------------------ 309| 0| return result; 310| 0| } 311| 41| dctx->magic = CTX_MAGIC; ------------------ | | 54| 41|#define CTX_MAGIC ISC_MAGIC('D', 'S', 'T', 'C') | | ------------------ | | | | 31| 41|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 312| 41| *dctxp = dctx; 313| 41| return ISC_R_SUCCESS; 314| 41|} dst_context_destroy: 317| 41|dst_context_destroy(dst_context_t **dctxp) { 318| 41| dst_context_t *dctx; 319| | 320| 41| REQUIRE(dctxp != NULL && VALID_CTX(*dctxp)); ------------------ | | 198| 41|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 41, False: 0] | | | | | Branch (41:11): [True: 41, False: 0] | | | | | Branch (41:11): [True: 41, False: 0] | | | | ------------------ | | | | 42| 41| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 321| | 322| 41| dctx = *dctxp; 323| 41| *dctxp = NULL; 324| 41| INSIST(dctx->key->func->destroyctx != NULL); ------------------ | | 202| 41|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 41| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 41, False: 0] | | | | ------------------ | | | | 54| 41| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 325| 41| dctx->key->func->destroyctx(dctx); 326| 41| if (dctx->key != NULL) { ------------------ | Branch (326:6): [True: 41, False: 0] ------------------ 327| 41| dst_key_free(&dctx->key); 328| 41| } 329| 41| dctx->magic = 0; 330| | isc_mem_putanddetach(&dctx->mctx, dctx, sizeof(dst_context_t)); ------------------ | | 187| 41| do { \ | | 188| 41| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 41| (p) = NULL; \ | | 190| 41| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 41] | | ------------------ ------------------ 331| 41|} dst_context_adddata: 334| 245|dst_context_adddata(dst_context_t *dctx, const isc_region_t *data) { 335| 245| REQUIRE(VALID_CTX(dctx)); ------------------ | | 198| 245|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 490| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 245, False: 0] | | | | | Branch (41:11): [True: 245, False: 0] | | | | ------------------ | | | | 42| 245| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 336| 245| REQUIRE(data != NULL); ------------------ | | 198| 245|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 245| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 245, False: 0] | | | | ------------------ | | | | 42| 245| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 337| 245| INSIST(dctx->key->func->adddata != NULL); ------------------ | | 202| 245|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 245| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 245, False: 0] | | | | ------------------ | | | | 54| 245| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 338| | 339| 245| return dctx->key->func->adddata(dctx, data); 340| 245|} dst_context_verify: 366| 41|dst_context_verify(dst_context_t *dctx, isc_region_t *sig) { 367| 41| REQUIRE(VALID_CTX(dctx)); ------------------ | | 198| 41|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 41, False: 0] | | | | | Branch (41:11): [True: 41, False: 0] | | | | ------------------ | | | | 42| 41| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 368| 41| REQUIRE(sig != NULL); ------------------ | | 198| 41|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 41| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 41, False: 0] | | | | ------------------ | | | | 42| 41| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 369| | 370| 41| CHECKALG(dctx->key->key_alg); ------------------ | | 188| 41| do { \ | | 189| 41| isc_result_t _r; \ | | 190| 41| _r = algorithm_status(alg); \ | | 191| 41| if (_r != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (191:7): [True: 0, False: 41] | | ------------------ | | 192| 41| return ((_r)); \ | | 193| 41| } while (0); | | ------------------ | | | Branch (193:11): [Folded, False: 41] | | ------------------ ------------------ 371| 41| if (dctx->key->keydata.generic == NULL) { ------------------ | Branch (371:6): [True: 0, False: 41] ------------------ 372| 0| return DST_R_NULLKEY; 373| 0| } 374| | 375| 41| if (dctx->key->func->verify == NULL) { ------------------ | Branch (375:6): [True: 0, False: 41] ------------------ 376| 0| return DST_R_NOTPUBLICKEY; 377| 0| } 378| | 379| 41| return dctx->key->func->verify(dctx, sig); 380| 41|} dst_key_todns: 647| 2|dst_key_todns(const dst_key_t *key, isc_buffer_t *target) { 648| 2| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 649| 2| REQUIRE(target != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 650| | 651| 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] | | ------------------ ------------------ 652| | 653| 2| if (key->func->todns == NULL) { ------------------ | Branch (653:6): [True: 0, False: 2] ------------------ 654| 0| return DST_R_UNSUPPORTEDALG; 655| 0| } 656| | 657| 2| if (isc_buffer_availablelength(target) < 4) { ------------------ | | 162| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (657:6): [True: 0, False: 2] ------------------ 658| 0| return ISC_R_NOSPACE; 659| 0| } 660| 2| isc_buffer_putuint16(target, (uint16_t)(key->key_flags & 0xffff)); 661| 2| isc_buffer_putuint8(target, (uint8_t)key->key_proto); 662| 2| isc_buffer_putuint8(target, 663| 2| (uint8_t)dst_algorithm_tosecalg(key->key_alg)); 664| | 665| 2| if (key->keydata.generic == NULL) { ------------------ | Branch (665:6): [True: 0, False: 2] ------------------ 666| 0| return ISC_R_SUCCESS; 667| 0| } 668| | 669| 2| return key->func->todns(key, target); 670| 2|} dst_key_fromdns: 674| 82| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 675| 82| uint8_t alg, proto; 676| 82| uint32_t flags; 677| 82| dst_key_t *key = NULL; 678| 82| dns_keytag_t id, rid; 679| 82| isc_region_t r; 680| | 681| 82| isc_buffer_remainingregion(source, &r); 682| | 683| 82| if (isc_buffer_remaininglength(source) < 4) { ------------------ | | 160| 82|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (683:6): [True: 0, False: 82] ------------------ 684| 0| return DST_R_INVALIDPUBLICKEY; 685| 0| } 686| 82| flags = isc_buffer_getuint16(source); 687| 82| proto = isc_buffer_getuint8(source); 688| 82| alg = isc_buffer_getuint8(source); 689| | 690| 82| id = dst_region_computeid(&r); 691| 82| rid = dst_region_computerid(&r); 692| | 693| 82| RETERR(frombuffer(name, alg, flags, proto, rdclass, source, mctx, ------------------ | | 276| 82| { \ | | 277| 82| isc_result_t _r = (x); \ | | 278| 82| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 82] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 82| } ------------------ 694| 82| &key)); 695| 82| key->key_id = id; 696| 82| key->key_rid = rid; 697| | 698| 82| *keyp = key; 699| 82| return ISC_R_SUCCESS; 700| 82|} dst_key_frombuffer: 705| 2| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 706| 2| dst_key_t *key = NULL; 707| 2| isc_result_t result; 708| | 709| 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| } ------------------ 710| 2| &key)); 711| | 712| 2| result = computeid(key); 713| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (713:6): [True: 0, False: 2] ------------------ 714| 0| dst_key_free(&key); 715| 0| return result; 716| 0| } 717| | 718| 2| *keyp = key; 719| 2| return ISC_R_SUCCESS; 720| 2|} dst_key_attach: 1207| 43|dst_key_attach(dst_key_t *source, dst_key_t **target) { 1208| 43| REQUIRE(target != NULL && *target == NULL); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 86| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 43, False: 0] | | | | | Branch (41:11): [True: 43, False: 0] | | | | ------------------ | | | | 42| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1209| 43| REQUIRE(VALID_KEY(source)); ------------------ | | 198| 43|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 86| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 43, False: 0] | | | | | Branch (41:11): [True: 43, False: 0] | | | | ------------------ | | | | 42| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1210| | 1211| | isc_refcount_increment(&source->refs); ------------------ | | 81| 43| ({ \ | | 82| 43| uint_fast32_t __v; \ | | 83| 43| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 43| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 43| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 202| 43|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 86| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:11): [True: 43, False: 0] | | | | | | | Branch (53:11): [True: 43, False: 0] | | | | | | ------------------ | | | | | | 54| 43| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 43| __v; \ | | 86| 43| }) ------------------ 1212| 43| *target = source; 1213| 43|} dst_key_free: 1216| 125|dst_key_free(dst_key_t **keyp) { 1217| 125| REQUIRE(keyp != NULL && VALID_KEY(*keyp)); ------------------ | | 198| 125|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 500| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 125, False: 0] | | | | | Branch (41:11): [True: 125, False: 0] | | | | | Branch (41:11): [True: 125, False: 0] | | | | ------------------ | | | | 42| 125| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1218| 125| dst_key_t *key = *keyp; 1219| 125| *keyp = NULL; 1220| | 1221| 125| if (isc_refcount_decrement(&key->refs) == 1) { ------------------ | | 94| 125| ({ \ | | 95| 125| uint_fast32_t __v; \ | | 96| 125| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 125| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 125| INSIST(__v > 0); \ | | ------------------ | | | | 202| 125|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 125| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 125, False: 0] | | | | | | ------------------ | | | | | | 54| 125| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 125| __v; \ | | 99| 125| }) ------------------ | Branch (1221:6): [True: 82, False: 43] ------------------ 1222| 82| isc_refcount_destroy(&key->refs); ------------------ | | 60| 82| ISC_REQUIRE(isc_refcount_current(target) == 0) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1223| 82| isc_mem_t *mctx = key->mctx; 1224| 82| if (key->keydata.generic != NULL) { ------------------ | Branch (1224:7): [True: 82, False: 0] ------------------ 1225| 82| INSIST(key->func->destroy != NULL); ------------------ | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 82, False: 0] | | | | ------------------ | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1226| 82| key->func->destroy(key); 1227| 82| } 1228| 82| if (key->directory != NULL) { ------------------ | Branch (1228:7): [True: 0, False: 82] ------------------ 1229| 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] | | ------------------ ------------------ 1230| 0| } 1231| 82| if (key->label != NULL) { ------------------ | Branch (1231:7): [True: 0, False: 82] ------------------ 1232| 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] | | ------------------ ------------------ 1233| 0| } 1234| 82| dns_name_free(key->key_name, mctx); 1235| 82| isc_mem_put(mctx, key->key_name, sizeof(dns_name_t)); ------------------ | | 171| 82| do { \ | | 172| 82| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 82| (p) = NULL; \ | | 174| 82| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 82] | | ------------------ ------------------ 1236| 82| if (key->key_tkeytoken) { ------------------ | Branch (1236:7): [True: 0, False: 82] ------------------ 1237| 0| isc_buffer_free(&key->key_tkeytoken); 1238| 0| } 1239| 82| isc_mutex_destroy(&key->mdlock); ------------------ | | 72| 82|#define isc_mutex_destroy(mp) isc__mutex_destroy(mp) | | ------------------ | | | | 100| 82| { \ | | | | 101| 82| int _ret = pthread_mutex_destroy(mp); \ | | | | 102| 82| PTHREADS_RUNTIME_CHECK(pthread_mutex_destroy, _ret); \ | | | | ------------------ | | | | | | 288| 82| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 82] | | | | | | ------------------ | | | | | | 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 103| 82| } | | ------------------ ------------------ 1240| 82| isc_safe_memwipe(key, sizeof(*key)); 1241| | isc_mem_putanddetach(&mctx, key, sizeof(*key)); ------------------ | | 187| 82| do { \ | | 188| 82| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 82| (p) = NULL; \ | | 190| 82| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 82] | | ------------------ ------------------ 1242| 82| } 1243| 125|} dst_key_sigsize: 1265| 245|dst_key_sigsize(const dst_key_t *key, unsigned int *n) { 1266| 245| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 245|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 490| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 245, False: 0] | | | | | Branch (41:11): [True: 245, False: 0] | | | | ------------------ | | | | 42| 245| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1267| 245| REQUIRE(n != NULL); ------------------ | | 198| 245|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 245| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 245, False: 0] | | | | ------------------ | | | | 42| 245| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1268| | 1269| 245| switch (key->key_alg) { 1270| 0| case DST_ALG_RSASHA1: ------------------ | Branch (1270:2): [True: 0, False: 245] ------------------ 1271| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (1271:2): [True: 0, False: 245] ------------------ 1272| 0| case DST_ALG_RSASHA256: ------------------ | Branch (1272:2): [True: 0, False: 245] ------------------ 1273| 0| case DST_ALG_RSASHA512: ------------------ | Branch (1273:2): [True: 0, False: 245] ------------------ 1274| 0| *n = (key->key_size + 7) / 8; 1275| 0| break; 1276| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (1276:2): [True: 0, False: 245] ------------------ 1277| 0| *n = (key->key_size + 7) / 8 + sizeof(oid_rsasha256); 1278| 0| break; 1279| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (1279:2): [True: 0, False: 245] ------------------ 1280| 0| *n = (key->key_size + 7) / 8 + sizeof(oid_rsasha512); 1281| 0| break; 1282| 0| case DST_ALG_ECDSA256: ------------------ | Branch (1282:2): [True: 0, False: 245] ------------------ 1283| 0| *n = DNS_SIG_ECDSA256SIZE; ------------------ | | 69| 0|#define DNS_SIG_ECDSA256SIZE 64 ------------------ 1284| 0| break; 1285| 0| case DST_ALG_ECDSA384: ------------------ | Branch (1285:2): [True: 0, False: 245] ------------------ 1286| 0| *n = DNS_SIG_ECDSA384SIZE; ------------------ | | 72| 0|#define DNS_SIG_ECDSA384SIZE 96 ------------------ 1287| 0| break; 1288| 0| case DST_ALG_ED25519: ------------------ | Branch (1288:2): [True: 0, False: 245] ------------------ 1289| 0| *n = DNS_SIG_ED25519SIZE; ------------------ | | 75| 0|#define DNS_SIG_ED25519SIZE 64 ------------------ 1290| 0| break; 1291| 0| case DST_ALG_ED448: ------------------ | Branch (1291:2): [True: 0, False: 245] ------------------ 1292| 0| *n = DNS_SIG_ED448SIZE; ------------------ | | 78| 0|#define DNS_SIG_ED448SIZE 114 ------------------ 1293| 0| break; 1294| 0| case DST_ALG_HMACMD5: ------------------ | Branch (1294:2): [True: 0, False: 245] ------------------ 1295| 0| *n = ISC_MD5_DIGESTLENGTH; ------------------ | | 48| 0|#define ISC_MD5_DIGESTLENGTH 16 ------------------ 1296| 0| break; 1297| 0| case DST_ALG_HMACSHA1: ------------------ | Branch (1297:2): [True: 0, False: 245] ------------------ 1298| 0| *n = ISC_SHA1_DIGESTLENGTH; ------------------ | | 50| 0|#define ISC_SHA1_DIGESTLENGTH 20 ------------------ 1299| 0| break; 1300| 0| case DST_ALG_HMACSHA224: ------------------ | Branch (1300:2): [True: 0, False: 245] ------------------ 1301| 0| *n = ISC_SHA224_DIGESTLENGTH; ------------------ | | 52| 0|#define ISC_SHA224_DIGESTLENGTH 28 ------------------ 1302| 0| break; 1303| 245| case DST_ALG_HMACSHA256: ------------------ | Branch (1303:2): [True: 245, False: 0] ------------------ 1304| 245| *n = ISC_SHA256_DIGESTLENGTH; ------------------ | | 54| 245|#define ISC_SHA256_DIGESTLENGTH 32 ------------------ 1305| 245| break; 1306| 0| case DST_ALG_HMACSHA384: ------------------ | Branch (1306:2): [True: 0, False: 245] ------------------ 1307| 0| *n = ISC_SHA384_DIGESTLENGTH; ------------------ | | 56| 0|#define ISC_SHA384_DIGESTLENGTH 48 ------------------ 1308| 0| break; 1309| 0| case DST_ALG_HMACSHA512: ------------------ | Branch (1309:2): [True: 0, False: 245] ------------------ 1310| 0| *n = ISC_SHA512_DIGESTLENGTH; ------------------ | | 58| 0|#define ISC_SHA512_DIGESTLENGTH 64 ------------------ 1311| 0| break; 1312| 0| case DST_ALG_GSSAPI: ------------------ | Branch (1312:2): [True: 0, False: 245] ------------------ 1313| 0| *n = 128; /*%< XXX */ 1314| 0| break; 1315| 0| default: ------------------ | Branch (1315:2): [True: 0, False: 245] ------------------ 1316| 0| return DST_R_UNSUPPORTEDALG; 1317| 245| } 1318| 245| return ISC_R_SUCCESS; 1319| 245|} dst_algorithm_tosecalg: 2612| 2|dst_algorithm_tosecalg(dst_algorithm_t dst_alg) { 2613| 2| static dns_secalg_t dns_alg[DST_MAX_ALGS] = { 2614| 2| [DST_ALG_RSASHA256PRIVATEOID] = DNS_KEYALG_PRIVATEOID, 2615| 2| [DST_ALG_RSASHA512PRIVATEOID] = DNS_KEYALG_PRIVATEOID, 2616| |#if TEST_PRIVATEDNS 2617| | [DST_ALG_RSASHA256PRIVATEDNS] = DNS_KEYALG_PRIVATEDNS, 2618| | [DST_ALG_RSASHA512PRIVATEDNS] = DNS_KEYALG_PRIVATEDNS, 2619| |#endif 2620| 2| }; 2621| | 2622| 2| if (dst_alg < 256) { ------------------ | Branch (2622:6): [True: 2, False: 0] ------------------ 2623| 2| return dst_alg; 2624| 2| } 2625| 0| if (dst_alg < DST_MAX_ALGS) { ------------------ | Branch (2625:6): [True: 0, False: 0] ------------------ 2626| 0| return dns_alg[dst_alg]; 2627| 0| } 2628| 0| return 0; 2629| 0|} dst_api.c:get_key_struct: 1393| 84| dns_rdataclass_t rdclass, dns_ttl_t ttl, isc_mem_t *mctx) { 1394| 84| dst_key_t *key; 1395| | 1396| 84| key = isc_mem_get(mctx, sizeof(dst_key_t)); ------------------ | | 144| 84|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1397| 84| *key = (dst_key_t){ 1398| 84| .key_name = isc_mem_get(mctx, sizeof(dns_name_t)), ------------------ | | 144| 84|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1399| 84| .key_alg = alg, 1400| 84| .key_flags = flags, 1401| 84| .key_proto = protocol, 1402| 84| .key_size = bits, 1403| 84| .key_class = rdclass, 1404| 84| .key_ttl = ttl, 1405| 84| .func = dst_t_func[alg], 1406| 84| }; 1407| | 1408| 84| dns_name_init(key->key_name); 1409| 84| dns_name_dup(name, mctx, key->key_name); ------------------ | | 1522| 84| dns_name__dup(DNS_NAME__RO_ARG(source), mctx, target) | | ------------------ | | | | 1507| 84| _Generic((arg), \ | | | | 1508| 84| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 84| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 84| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 84| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 84| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 84| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1410| | 1411| 84| isc_refcount_init(&key->refs, 1); ------------------ | | 44| 84|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 1412| 84| isc_mem_attach(mctx, &key->mctx); 1413| | 1414| 84| isc_mutex_init(&key->mdlock); ------------------ | | 68| 84|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 84| { \ | | | | 80| 84| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 84| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 84| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 84] | | | | | | ------------------ | | | | | | 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 84| } | | ------------------ ------------------ 1415| | 1416| 84| key->magic = KEY_MAGIC; ------------------ | | 53| 84|#define KEY_MAGIC ISC_MAGIC('D', 'S', 'T', 'K') | | ------------------ | | | | 31| 84|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1417| 84| return key; 1418| 84|} dst_api.c:computeid: 2086| 2|computeid(dst_key_t *key) { 2087| 2| isc_buffer_t dnsbuf; 2088| 2| unsigned char dns_array[DNS_RDATA_MAXLENGTH]; 2089| 2| isc_region_t r; 2090| | 2091| 2| isc_buffer_init(&dnsbuf, dns_array, sizeof(dns_array)); 2092| 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| } ------------------ 2093| | 2094| 2| isc_buffer_usedregion(&dnsbuf, &r); 2095| 2| key->key_id = dst_region_computeid(&r); 2096| 2| key->key_rid = dst_region_computerid(&r); 2097| 2| return ISC_R_SUCCESS; 2098| 2|} dst_api.c:frombuffer: 2103| 84| isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp) { 2104| 84| dst_key_t *key; 2105| 84| isc_result_t result; 2106| | 2107| 84| REQUIRE(dns_name_isabsolute(name)); ------------------ | | 198| 84|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 84| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 84, False: 0] | | | | ------------------ | | | | 42| 84| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2108| 84| REQUIRE(source != NULL); ------------------ | | 198| 84|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 84| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 84, False: 0] | | | | ------------------ | | | | 42| 84| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2109| 84| REQUIRE(mctx != NULL); ------------------ | | 198| 84|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 84| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 84, False: 0] | | | | ------------------ | | | | 42| 84| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2110| 84| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 198| 84|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 168| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 84, False: 0] | | | | | Branch (41:11): [True: 84, False: 0] | | | | ------------------ | | | | 42| 84| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2111| | 2112| 84| if (alg == DNS_KEYALG_PRIVATEDNS) { ------------------ | Branch (2112:6): [True: 0, False: 84] ------------------ 2113| 0| isc_buffer_t b = *source; 2114| 0| isc_buffer_setactive(&b, isc_buffer_remaininglength(&b)); ------------------ | | 160| 0|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 2115| 0| alg = dst_algorithm_fromprivatedns(&b); 2116| 0| if (alg == 0) { ------------------ | Branch (2116:7): [True: 0, False: 0] ------------------ 2117| 0| return DST_R_UNSUPPORTEDALG; 2118| 0| } 2119| 0| } 2120| | 2121| 84| if (alg == DNS_KEYALG_PRIVATEOID) { ------------------ | Branch (2121:6): [True: 0, False: 84] ------------------ 2122| 0| isc_buffer_t b = *source; 2123| 0| alg = dst_algorithm_fromprivateoid(&b); 2124| 0| if (alg == 0) { ------------------ | Branch (2124:7): [True: 0, False: 0] ------------------ 2125| 0| return DST_R_UNSUPPORTEDALG; 2126| 0| } 2127| 0| } 2128| | 2129| 84| RETERR(algorithm_status(alg)); ------------------ | | 276| 84| { \ | | 277| 84| isc_result_t _r = (x); \ | | 278| 84| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 84] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 84| } ------------------ 2130| | 2131| 84| key = get_key_struct(name, alg, flags, protocol, 0, rdclass, 0, mctx); 2132| | 2133| 84| if (isc_buffer_remaininglength(source) > 0) { ------------------ | | 160| 84|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (2133:6): [True: 84, False: 0] ------------------ 2134| 84| if (key->func->fromdns == NULL) { ------------------ | Branch (2134:7): [True: 0, False: 84] ------------------ 2135| 0| dst_key_free(&key); 2136| 0| return DST_R_UNSUPPORTEDALG; 2137| 0| } 2138| | 2139| 84| result = key->func->fromdns(key, source); 2140| 84| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2140:7): [True: 0, False: 84] ------------------ 2141| 0| dst_key_free(&key); 2142| 0| return result; 2143| 0| } 2144| 84| } 2145| | 2146| 84| *keyp = key; 2147| 84| return ISC_R_SUCCESS; 2148| 84|} dst_api.c:algorithm_status: 2151| 127|algorithm_status(unsigned int alg) { 2152| 127| if (dst_algorithm_supported(alg)) { ------------------ | Branch (2152:6): [True: 127, False: 0] ------------------ 2153| 127| return ISC_R_SUCCESS; 2154| 127| } 2155| 0| return DST_R_UNSUPPORTEDALG; 2156| 127|} 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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: 65| 4.24k|dns_fixedname_init(dns_fixedname_t *fixed) { 66| 4.24k| dns_linkedname_init(&fixed->name_wl); 67| 4.24k| isc_buffer_init(&fixed->buffer, fixed->data, DNS_NAME_MAXWIRE); ------------------ | | 245| 4.24k|#define DNS_NAME_MAXWIRE 255 ------------------ 68| 4.24k| dns_name_setbuffer(dns_name(&fixed->name_wl), &fixed->buffer); ------------------ | | 1515| 4.24k|#define dns_name(source) DNS_NAME__RO_ARG(source) | | ------------------ | | | | 1507| 4.24k| _Generic((arg), \ | | | | 1508| 4.24k| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 4.24k| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 4.24k| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 4.24k| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 4.24k| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 4.24k| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 69| 4.24k|} dns_fixedname_name: 77| 902|dns_fixedname_name(dns_fixedname_t *fixed) { 78| 902| return dns_linkedname_name(&fixed->name_wl); 79| 902|} dns_fixedname_initname: 87| 511|dns_fixedname_initname(dns_fixedname_t *fixed) { 88| 511| dns_fixedname_init(fixed); 89| 511| return dns_fixedname_name(fixed); 90| 511|} 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 29|hmac_createctx(const dst_key_t *key, dst_context_t *dctx) { 162| 29| isc_result_t result; 163| 29| isc_hmac_t *ctx = isc_hmac_new(); /* Either returns or abort()s */ 164| | 165| 29| result = isc_hmac_init(ctx, key->keydata.hmac_key); 166| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (166:6): [True: 0, False: 29] ------------------ 167| 0| isc_hmac_free(ctx); 168| 0| return DST_R_UNSUPPORTEDALG; 169| 0| } 170| | 171| 29| dctx->ctxdata.hmac_ctx = ctx; 172| 29| return ISC_R_SUCCESS; 173| 29|} hmac_link.c:hmac_destroyctx: 176| 29|hmac_destroyctx(dst_context_t *dctx) { 177| 29| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 178| 29| REQUIRE(ctx != NULL); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 29| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 179| | 180| 29| isc_hmac_free(ctx); 181| | dctx->ctxdata.hmac_ctx = NULL; 182| 29|} hmac_link.c:hmac_adddata: 185| 209|hmac_adddata(const dst_context_t *dctx, const isc_region_t *data) { 186| 209| isc_result_t result; 187| 209| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 188| | 189| 209| REQUIRE(ctx != NULL); ------------------ | | 198| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 209| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 209, False: 0] | | | | ------------------ | | | | 42| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 190| | 191| 209| result = isc_hmac_update(ctx, data->base, data->length); 192| 209| if (result != ISC_R_SUCCESS) { ------------------ | Branch (192:6): [True: 0, False: 209] ------------------ 193| 0| return DST_R_OPENSSLFAILURE; 194| 0| } 195| | 196| 209| return ISC_R_SUCCESS; 197| 209|} hmac_link.c:hmac_verify: 209| 29|hmac_verify(const dst_context_t *dctx, const isc_region_t *sig) { 210| 29| isc_hmac_t *ctx = dctx->ctxdata.hmac_ctx; 211| 29| unsigned char digest[ISC_MAX_MD_SIZE]; 212| 29| isc_buffer_t hmac; 213| 29| unsigned int sig_expected_length = ISC_MAX_MD_SIZE; ------------------ | | 61| 29|#define ISC_MAX_MD_SIZE 64U /* EVP_MAX_MD_SIZE */ ------------------ 214| 29| uint16_t digestbits = dst_key_getbits(dctx->key); 215| | 216| 29| REQUIRE(ctx != NULL); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 29| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 217| | 218| 29| isc_buffer_init(&hmac, digest, sizeof(digest)); 219| | 220| 29| if (isc_hmac_final(ctx, &hmac) != ISC_R_SUCCESS) { ------------------ | Branch (220:6): [True: 0, False: 29] ------------------ 221| 0| return DST_R_OPENSSLFAILURE; 222| 0| } 223| | 224| 29| if (digestbits == 0) { ------------------ | Branch (224:6): [True: 29, False: 0] ------------------ 225| | /* 226| | * If digestbits is zero then HMAC truncation is not used, just 227| | * use the key's actual length. 228| | */ 229| 29| isc_result_t result = dst_key_sigsize(dctx->key, 230| 29| &sig_expected_length); 231| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (231:7): [True: 0, False: 29] ------------------ 232| 0| return DST_R_VERIFYFAILURE; 233| 0| } 234| 29| } else { 235| 0| sig_expected_length = (digestbits + 7) / 8; 236| 0| } 237| | 238| 29| if (sig->length != sig_expected_length || ------------------ | Branch (238:6): [True: 0, False: 29] ------------------ 239| 29| sig->length > isc_buffer_usedlength(&hmac)) ------------------ | | 158| 29|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ | Branch (239:6): [True: 0, False: 29] ------------------ 240| 0| { 241| 0| return DST_R_VERIFYFAILURE; 242| 0| } 243| | 244| 29| return isc_safe_memequal(digest, sig->base, sig->length) ------------------ | Branch (244:9): [True: 2, False: 27] ------------------ 245| 29| ? ISC_R_SUCCESS 246| 29| : DST_R_VERIFYFAILURE; 247| 29|} hmac_link.c:hmac_fromdns: 320| 2|hmac_fromdns(isc_md_type_t type, dst_key_t *key, isc_buffer_t *data) { 321| 2| isc_hmac_key_t *hkey = NULL; 322| 2| isc_result_t result; 323| 2| isc_region_t r; 324| | 325| 2| isc_buffer_remainingregion(data, &r); 326| 2| if (r.length == 0) { ------------------ | Branch (326:6): [True: 0, False: 2] ------------------ 327| 0| return ISC_R_SUCCESS; 328| 0| } 329| | 330| 2| result = isc_hmac_key_create(type, r.base, r.length, key->mctx, &hkey); 331| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (331:6): [True: 0, False: 2] ------------------ 332| 0| return DST_R_OPENSSLFAILURE; 333| 0| } 334| | 335| 2| key->key_size = isc_hmac_key_expose(hkey).length * 8; 336| 2| key->keydata.hmac_key = hkey; 337| | 338| 2| isc_buffer_forward(data, r.length); 339| | 340| 2| return ISC_R_SUCCESS; 341| 2|} hmac_link.c:hmac_todns: 305| 2|hmac_todns(const dst_key_t *key, isc_buffer_t *data) { 306| 2| isc_region_t raw_key; 307| | 308| 2| REQUIRE(key != NULL && key->keydata.hmac_key != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 309| | 310| 2| raw_key = isc_hmac_key_expose(key->keydata.hmac_key); 311| | 312| 2| if (isc_buffer_availablelength(data) < raw_key.length) { ------------------ | | 162| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (312:6): [True: 0, False: 2] ------------------ 313| 0| return ISC_R_NOSPACE; 314| 0| } 315| | 316| 2| return isc_buffer_copyregion(data, &raw_key); 317| 2|} hmac_link.c:hmacsha256_createctx: 57| 29| dst_context_t *dctx) { \ 58| 29| return (hmac_createctx(key, dctx)); \ 59| 29| } \ hmac_link.c:hmacsha256_destroyctx: 60| 29| static void hmac##alg##_destroyctx(dst_context_t *dctx) { \ 61| 29| hmac_destroyctx(dctx); \ 62| 29| } \ hmac_link.c:hmacsha256_adddata: 64| 209| const isc_region_t *data) { \ 65| 209| return (hmac_adddata(dctx, data)); \ 66| 209| } \ hmac_link.c:hmacsha256_verify: 72| 29| const isc_region_t *sig) { \ 73| 29| return (hmac_verify(dctx, sig)); \ 74| 29| } \ 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| 775|dns_decompress_getpermitted(const dns_decompress_t dctx) { 252| 775| return dctx == DNS_DECOMPRESS_ALWAYS || ------------------ | Branch (252:9): [True: 0, False: 775] ------------------ 253| 775| dctx == DNS_DECOMPRESS_PERMITTED; ------------------ | Branch (253:9): [True: 766, False: 9] ------------------ 254| 775|} rdata.c:dns_decompress_setpermitted: 237| 1.92k|dns_decompress_setpermitted(const dns_decompress_t dctx, bool permitted) { 238| 1.92k| if (dctx == DNS_DECOMPRESS_NEVER || dctx == DNS_DECOMPRESS_ALWAYS) { ------------------ | Branch (238:6): [True: 0, False: 1.92k] | Branch (238:38): [True: 0, False: 1.92k] ------------------ 239| 0| return dctx; 240| 1.92k| } else if (permitted) { ------------------ | Branch (240:13): [True: 798, False: 1.12k] ------------------ 241| 798| return DNS_DECOMPRESS_PERMITTED; 242| 1.12k| } else { 243| 1.12k| return DNS_DECOMPRESS_DEFAULT; 244| 1.12k| } 245| 1.92k|} dns_lib_initialize: 36| 2|dns_lib_initialize(void) { 37| 2| isc__lib_initialize(); 38| 2| dns__lib_initialize(); 39| 2|} fixedname.c:dns_linkedname_init: 346| 4.24k|dns_linkedname_init(dns_linkedname_t *name) { 347| 4.24k| dns_name_init(&name->name); 348| 4.24k| ISC_LINK_INIT(name, link); ------------------ | | 57| 4.24k|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 4.24k| do { \ | | | | 54| 4.24k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 4.24k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 4.24k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 4.24k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 4.24k| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 4.24k] | | | | ------------------ | | ------------------ ------------------ 349| 4.24k| ISC_LIST_INIT(name->list); ------------------ | | 43| 4.24k| do { \ | | 44| 4.24k| (list).head = NULL; \ | | 45| 4.24k| (list).tail = NULL; \ | | 46| 4.24k| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 4.24k] | | ------------------ ------------------ 350| | name->hashmap = NULL; 351| 4.24k|} fixedname.c:dns_name_init: 264| 4.24k|dns_name_init(dns_name_t *name) { 265| 4.24k| *name = (dns_name_t){ 266| 4.24k| .magic = DNS_NAME_MAGIC, ------------------ | | 153| 4.24k|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 4.24k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 267| 4.24k| }; 268| 4.24k|} fixedname.c:dns_name_setbuffer: 372| 4.24k|dns_name_setbuffer(dns_name_t *name, isc_buffer_t *buffer) { 373| 4.24k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 4.24k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8.48k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4.24k, False: 0] | | | | | Branch (41:11): [True: 4.24k, False: 0] | | | | ------------------ | | | | 42| 4.24k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 374| 4.24k| REQUIRE((buffer != NULL && name->buffer == NULL) || (buffer == NULL)); ------------------ | | 198| 4.24k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4.24k, False: 0] | | | | | Branch (41:11): [True: 4.24k, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 4.24k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 375| | 376| 4.24k| name->buffer = buffer; 377| 4.24k|} fixedname.c:dns_linkedname_name: 128| 5.14k|dns_linkedname_name(dns_linkedname_t *nwl) { 129| 5.14k| return nwl != NULL ? &nwl->name : NULL; ------------------ | Branch (129:9): [True: 5.14k, False: 0] ------------------ 130| 5.14k|} message.c:dns_name_isroot: 1480| 421|dns_name_isroot(const dns_name_t *name) { 1481| 421| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 421|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 842| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 421, False: 0] | | | | | Branch (41:11): [True: 421, False: 0] | | | | ------------------ | | | | 42| 421| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1482| | 1483| 421| return name->length == 1 && name->ndata[0] == 0; ------------------ | Branch (1483:9): [True: 421, False: 0] | Branch (1483:30): [True: 421, False: 0] ------------------ 1484| 421|} message.c:dns_linkedname_attrs: 133| 560|dns_linkedname_attrs(dns_linkedname_t *nwl) { 134| 560| return nwl != NULL ? &nwl->name.attributes : NULL; ------------------ | Branch (134:9): [True: 560, False: 0] ------------------ 135| 560|} message.c:dns_linkedname_name: 128| 7.73k|dns_linkedname_name(dns_linkedname_t *nwl) { 129| 7.73k| return nwl != NULL ? &nwl->name : NULL; ------------------ | Branch (129:9): [True: 7.73k, False: 0] ------------------ 130| 7.73k|} name.c:dns_name__countlabels: 695| 2|dns_name__countlabels(const dns_name_t *name) { 696| 2| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 697| | 698| | return dns_name_offsets(name, NULL); 699| 2|} name.c:dns_name__readonly_arg: 149| 30|dns_name__readonly_arg(const dns_name_t *name) { 150| 30| return name; 151| 30|} name.c:dns_name_invalidate: 317| 82|dns_name_invalidate(dns_name_t *name) { 318| 82| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 82, False: 0] | | | | | Branch (41:11): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 319| | 320| 82| name->magic = 0; 321| 82| name->ndata = NULL; 322| 82| name->length = 0; 323| 82| name->attributes = (struct dns_name_attrs){}; 324| | name->buffer = NULL; 325| 82|} qpzone.c:dns_name__readonly_arg: 149| 250|dns_name__readonly_arg(const dns_name_t *name) { 150| 250| return name; 151| 250|} qpzone.c:dns_name_init: 264| 6|dns_name_init(dns_name_t *name) { 265| 6| *name = (dns_name_t){ 266| 6| .magic = DNS_NAME_MAGIC, ------------------ | | 153| 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)) | | ------------------ ------------------ 267| 6| }; 268| 6|} qpzone.c:dns_name__countlabels: 695| 12|dns_name__countlabels(const dns_name_t *name) { 696| 12| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 697| | 698| | return dns_name_offsets(name, NULL); 699| 12|} rdata.c:dns_name_init: 264| 4.40k|dns_name_init(dns_name_t *name) { 265| 4.40k| *name = (dns_name_t){ 266| 4.40k| .magic = DNS_NAME_MAGIC, ------------------ | | 153| 4.40k|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 4.40k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 267| 4.40k| }; 268| 4.40k|} rdata.c:dns_name__readonly_arg: 149| 1.25k|dns_name__readonly_arg(const dns_name_t *name) { 150| 1.25k| return name; 151| 1.25k|} tsig.c:dns_name__readonly_arg: 149| 10.2k|dns_name__readonly_arg(const dns_name_t *name) { 150| 10.2k| return name; 151| 10.2k|} tsig.c:dns_name__toregion: 805| 58|dns_name__toregion(const dns_name_t *name, isc_region_t *r) { 806| 58| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 58|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 116| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 58, False: 0] | | | | | Branch (41:11): [True: 58, False: 0] | | | | ------------------ | | | | 42| 58| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 807| 58| REQUIRE(r != NULL); ------------------ | | 198| 58|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 58| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 58, False: 0] | | | | ------------------ | | | | 42| 58| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 808| | 809| 58| r->base = name->ndata; 810| 58| r->length = name->length; 811| 58|} tsig.c:dns_linkedname_name: 128| 556|dns_linkedname_name(dns_linkedname_t *nwl) { 129| 556| return nwl != NULL ? &nwl->name : NULL; ------------------ | Branch (129:9): [True: 556, False: 0] ------------------ 130| 556|} view.c:dns_name__readonly_arg: 149| 208|dns_name__readonly_arg(const dns_name_t *name) { 150| 208| return name; 151| 208|} zone.c:dns_name_init: 264| 2|dns_name_init(dns_name_t *name) { 265| 2| *name = (dns_name_t){ 266| 2| .magic = DNS_NAME_MAGIC, ------------------ | | 153| 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)) | | ------------------ ------------------ 267| 2| }; 268| 2|} zone.c:dns_name__readonly_arg: 149| 14|dns_name__readonly_arg(const dns_name_t *name) { 150| 14| return name; 151| 14|} zoneproperties.c:dns_name__readonly_arg: 149| 4|dns_name__readonly_arg(const dns_name_t *name) { 150| 4| return name; 151| 4|} db.c:dns_name__readonly_arg: 149| 2|dns_name__readonly_arg(const dns_name_t *name) { 150| 2| return name; 151| 2|} dnssec.c:dns_name__readonly_arg: 149| 24|dns_name__readonly_arg(const dns_name_t *name) { 150| 24| return name; 151| 24|} dst_api.c:dns_name__readonly_arg: 149| 168|dns_name__readonly_arg(const dns_name_t *name) { 150| 168| return name; 151| 168|} dst_api.c:dns_name_init: 264| 84|dns_name_init(dns_name_t *name) { 265| 84| *name = (dns_name_t){ 266| 84| .magic = DNS_NAME_MAGIC, ------------------ | | 153| 84|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 84|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 267| 84| }; 268| 84|} master.c:dns_name__readonly_arg: 149| 24|dns_name__readonly_arg(const dns_name_t *name) { 150| 24| return name; 151| 24|} master.c:dns_name__toregion: 805| 4|dns_name__toregion(const dns_name_t *name, isc_region_t *r) { 806| 4| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 807| 4| REQUIRE(r != NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 808| | 809| 4| r->base = name->ndata; 810| 4| r->length = name->length; 811| 4|} nametree.c:dns_name__readonly_arg: 149| 2|dns_name__readonly_arg(const dns_name_t *name) { 150| 2| return name; 151| 2|} message.c:dns_rdatatype_questiononly: 611| 87|dns_rdatatype_questiononly(dns_rdatatype_t type) { 612| 87| return (dns_rdatatype_attributes(type) & 613| 87| DNS_RDATATYPEATTR_QUESTIONONLY) != 0; 614| 87|} rdatavec.c:dns_rdatatype_issig: 724| 6|dns_rdatatype_issig(dns_rdatatype_t type) { 725| 6| return type == dns_rdatatype_rrsig; ------------------ | | 161| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ 726| 6|} master.c:dns_rdatatype_ismeta: 570| 6|dns_rdatatype_ismeta(dns_rdatatype_t type) { 571| 6| return (dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_META) != 0; 572| 6|} master.c:dns_rdatatype_atparent: 638| 6|dns_rdatatype_atparent(dns_rdatatype_t type) { 639| 6| return (dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_ATPARENT) != 640| 6| 0; 641| 6|} master.c:dns_rdatatype_issig: 724| 6|dns_rdatatype_issig(dns_rdatatype_t type) { 725| 6| return type == dns_rdatatype_rrsig; ------------------ | | 161| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ 726| 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: 730| 2| dns_journal_t **journalp) { 731| 2| isc_result_t result; 732| 2| size_t namelen; 733| 2| char backup[1024]; 734| 2| bool writable, create; 735| | 736| 2| create = ((mode & DNS_JOURNAL_CREATE) != 0); ------------------ | | 45| 2|#define DNS_JOURNAL_CREATE 0x00000001 /* true */ ------------------ 737| 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 */ ------------------ 738| | 739| 2| result = journal_open(mctx, filename, writable, create, false, 740| 2| journalp); 741| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (741:6): [True: 2, False: 0] ------------------ 742| 2| namelen = strlen(filename); 743| 2| if (namelen > 4U && strcmp(filename + namelen - 4, ".jnl") == 0) ------------------ | Branch (743:7): [True: 2, False: 0] | Branch (743:23): [True: 2, False: 0] ------------------ 744| 2| { 745| 2| namelen -= 4; 746| 2| } 747| | 748| 2| result = snprintf(backup, sizeof(backup), "%.*s.jbk", 749| 2| (int)namelen, filename); 750| 2| if (result >= sizeof(backup)) { ------------------ | Branch (750:7): [True: 0, False: 2] ------------------ 751| 0| return ISC_R_NOSPACE; 752| 0| } 753| 2| result = journal_open(mctx, backup, writable, writable, false, 754| 2| journalp); 755| 2| } 756| 2| return result; 757| 2|} journal.c:journal_open: 584| 4| bool downgrade, dns_journal_t **journalp) { 585| 4| FILE *fp = NULL; 586| 4| isc_result_t result; 587| 4| journal_rawheader_t rawheader; 588| 4| dns_journal_t *j; 589| | 590| 4| REQUIRE(journalp != NULL && *journalp == NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 591| | 592| 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) ------------------ 593| 4| *j = (dns_journal_t){ .state = JOURNAL_STATE_INVALID, 594| 4| .filename = isc_mem_strdup(mctx, filename), ------------------ | | 167| 4|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 595| 4| .xhdr_version = XHDR_VERSION2 }; 596| 4| isc_mem_attach(mctx, &j->mctx); 597| | 598| 4| result = isc_stdio_open(j->filename, writable ? "rb+" : "rb", &fp); ------------------ | Branch (598:39): [True: 0, False: 4] ------------------ 599| 4| if (result == ISC_R_FILENOTFOUND) { ------------------ | Branch (599:6): [True: 4, False: 0] ------------------ 600| 4| if (create) { ------------------ | Branch (600:7): [True: 0, False: 4] ------------------ 601| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, 602| 0| DNS_LOGMODULE_JOURNAL, ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 603| 0| "journal file %s does not exist, " 604| 0| "creating it", 605| 0| j->filename); 606| 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| } ------------------ 607| | /* 608| | * Retry. 609| | */ 610| 0| result = isc_stdio_open(j->filename, "rb+", &fp); 611| 4| } else { 612| 4| CLEANUP(ISC_R_NOTFOUND); ------------------ | | 266| 4| { \ | | 267| 4| result = (r); \ | | 268| 4| goto cleanup; \ | | 269| 4| } ------------------ 613| 0| } 614| 4| } 615| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (615:6): [True: 0, False: 0] ------------------ 616| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL, 617| 0| ISC_LOG_ERROR, "%s: open: %s", j->filename, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 618| 0| isc_result_totext(result)); 619| 0| CLEANUP(ISC_R_UNEXPECTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 620| 0| } 621| | 622| 0| j->fp = fp; 623| | 624| | /* 625| | * Set magic early so that seek/read can succeed. 626| | */ 627| 0| j->magic = DNS_JOURNAL_MAGIC; ------------------ | | 340| 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)) | | ------------------ ------------------ 628| | 629| 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| } ------------------ 630| 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| } ------------------ 631| | 632| 0| if (memcmp(rawheader.h.format, journal_header_ver1.format, ------------------ | Branch (632:6): [True: 0, False: 0] ------------------ 633| 0| sizeof(journal_header_ver1.format)) == 0) 634| 0| { 635| | /* 636| | * The file header says it's the old format, but it 637| | * still might have the new xhdr format because we 638| | * forgot to change the format string when we introduced 639| | * the new xhdr. When we first try to read it, we assume 640| | * it uses the new xhdr format. If that fails, we'll be 641| | * called a second time with compat set to true, in which 642| | * case we can lower xhdr_version to 1 if we find a 643| | * corrupt transaction. 644| | */ 645| 0| j->header_ver1 = true; 646| 0| } else if (memcmp(rawheader.h.format, initial_journal_header.format, ------------------ | Branch (646:13): [True: 0, False: 0] ------------------ 647| 0| sizeof(initial_journal_header.format)) == 0) 648| 0| { 649| | /* 650| | * File header says this is format version 2; all 651| | * transactions have to match. 652| | */ 653| 0| j->header_ver1 = false; 654| 0| } else { 655| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_JOURNAL, 656| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 657| 0| "%s: journal format not recognized", j->filename); 658| 0| CLEANUP(ISC_R_UNEXPECTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 659| 0| } 660| 0| journal_header_decode(&rawheader, &j->header); 661| | 662| | /* 663| | * If there is an index, read the raw index into a dynamically 664| | * allocated buffer and then convert it into a cooked index. 665| | */ 666| 0| if (j->header.index_size != 0) { ------------------ | Branch (666:6): [True: 0, False: 0] ------------------ 667| 0| unsigned int i; 668| 0| unsigned int rawbytes; 669| 0| unsigned char *p; 670| | 671| 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) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 36| 0| _c; \ | | 37| 0| }) ------------------ 672| 0| sizeof(journal_rawpos_t)); 673| 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) ------------------ 674| | 675| 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| } ------------------ 676| | 677| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 147| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 678| 0| sizeof(journal_pos_t)); 679| | 680| 0| p = j->rawindex; 681| 0| for (i = 0; i < j->header.index_size; i++) { ------------------ | Branch (681:15): [True: 0, False: 0] ------------------ 682| 0| j->index[i].serial = decode_uint32(p); 683| 0| p += 4; 684| 0| j->index[i].offset = decode_uint32(p); 685| 0| p += 4; 686| 0| } 687| 0| INSIST(p == j->rawindex + rawbytes); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 688| 0| } 689| 0| j->offset = -1; /* Invalid, must seek explicitly. */ 690| | 691| | /* 692| | * Initialize the iterator. 693| | */ 694| 0| dns_name_init(&j->it.name); 695| 0| dns_rdata_init(&j->it.rdata); 696| | 697| | /* 698| | * Set up empty initial buffers for unchecked and checked 699| | * wire format RR data. They will be reallocated 700| | * later. 701| | */ 702| 0| isc_buffer_initnull(&j->it.source); 703| 0| isc_buffer_initnull(&j->it.target); 704| | 705| 0| j->state = writable ? JOURNAL_STATE_WRITE : JOURNAL_STATE_READ; ------------------ | Branch (705:13): [True: 0, False: 0] ------------------ 706| | 707| 0| *journalp = j; 708| 0| return ISC_R_SUCCESS; 709| | 710| 4|cleanup: 711| 4| j->magic = 0; 712| 4| if (j->rawindex != NULL) { ------------------ | Branch (712:6): [True: 0, False: 4] ------------------ 713| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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] | | ------------------ ------------------ 714| 0| sizeof(journal_rawpos_t)); 715| 0| } 716| 4| if (j->index != NULL) { ------------------ | Branch (716:6): [True: 0, False: 4] ------------------ 717| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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] | | ------------------ ------------------ 718| 0| sizeof(journal_pos_t)); 719| 0| } 720| 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] | | ------------------ ------------------ 721| 4| if (j->fp != NULL) { ------------------ | Branch (721:6): [True: 0, False: 4] ------------------ 722| 0| (void)isc_stdio_close(j->fp); 723| 0| } 724| | 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] | | ------------------ ------------------ 725| 4| return result; 726| 0|} dst_region_computeid: 30| 189|dst_region_computeid(const isc_region_t *source) { 31| 189| uint32_t ac; 32| 189| const unsigned char *p; 33| 189| int size; 34| | 35| 189| REQUIRE(source != NULL); ------------------ | | 198| 189|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 189| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 189, False: 0] | | | | ------------------ | | | | 42| 189| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 36| 189| REQUIRE(source->length >= 4); ------------------ | | 198| 189|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 189| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 189, False: 0] | | | | ------------------ | | | | 42| 189| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 37| | 38| 189| p = source->base; 39| 189| size = source->length; 40| | 41| 24.8k| for (ac = 0; size > 1; size -= 2, p += 2) { ------------------ | Branch (41:15): [True: 24.7k, False: 189] ------------------ 42| 24.7k| ac += ((*p) << 8) + *(p + 1); 43| 24.7k| } 44| | 45| 189| if (size > 0) { ------------------ | Branch (45:6): [True: 0, False: 189] ------------------ 46| 0| ac += ((*p) << 8); 47| 0| } 48| 189| ac += (ac >> 16) & 0xffff; 49| | 50| 189| return (uint16_t)(ac & 0xffff); 51| 189|} dst_region_computerid: 54| 84|dst_region_computerid(const isc_region_t *source) { 55| 84| uint32_t ac; 56| 84| const unsigned char *p; 57| 84| int size; 58| | 59| 84| REQUIRE(source != NULL); ------------------ | | 198| 84|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 84| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 84, False: 0] | | | | ------------------ | | | | 42| 84| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 60| 84| REQUIRE(source->length >= 4); ------------------ | | 198| 84|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 84| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 84, False: 0] | | | | ------------------ | | | | 42| 84| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 61| | 62| 84| p = source->base; 63| 84| size = source->length; 64| | 65| 84| ac = ((*p) << 8) + *(p + 1); 66| 84| ac |= DNS_KEYFLAG_REVOKE; 67| 10.8k| for (size -= 2, p += 2; size > 1; size -= 2, p += 2) { ------------------ | Branch (67:26): [True: 10.7k, False: 84] ------------------ 68| 10.7k| ac += ((*p) << 8) + *(p + 1); 69| 10.7k| } 70| | 71| 84| if (size > 0) { ------------------ | Branch (71:6): [True: 0, False: 84] ------------------ 72| 0| ac += ((*p) << 8); 73| 0| } 74| 84| ac += (ac >> 16) & 0xffff; 75| | 76| 84| return (uint16_t)(ac & 0xffff); 77| 84|} dst_key_name: 80| 12|dst_key_name(const dst_key_t *key) { 81| 12| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 82| 12| return key->key_name; 83| 12|} 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 88| 2| return key->key_size; 89| 2|} dst_key_alg: 92| 218|dst_key_alg(const dst_key_t *key) { 93| 218| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 218|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 436| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 218, False: 0] | | | | | Branch (41:11): [True: 218, False: 0] | | | | ------------------ | | | | 42| 218| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 94| 218| return key->key_alg; 95| 218|} dst_key_getbits: 213| 245|dst_key_getbits(const dst_key_t *key) { 214| 245| REQUIRE(VALID_KEY(key)); ------------------ | | 198| 245|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 490| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 245, False: 0] | | | | | Branch (41:11): [True: 245, False: 0] | | | | ------------------ | | | | 42| 245| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 215| 245| return key->key_bits; 216| 245|} 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) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 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: 2557| 2| dns_ttl_t maxttl) { 2558| 2| dns_loadctx_t *lctx = NULL; 2559| 2| isc_result_t result; 2560| | 2561| 2| loadctx_create(format, mctx, options, resign, top, zclass, origin, 2562| 2| callbacks, NULL, NULL, include_cb, include_arg, NULL, 2563| 2| &lctx); 2564| | 2565| 2| lctx->maxttl = maxttl; 2566| | 2567| 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| } ------------------ 2568| | 2569| 2| result = (lctx->load)(lctx); 2570| 2| INSIST(result != DNS_R_CONTINUE); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2571| | 2572| 2|cleanup: 2573| 2| dns_loadctx_detach(&lctx); 2574| 2| return result; 2575| 2|} dns_master_initrawheader: 2923| 2|dns_master_initrawheader(dns_masterrawheader_t *header) { 2924| 2| memset(header, 0, sizeof(dns_masterrawheader_t)); 2925| 2|} master.c:loadctx_destroy: 417| 2|loadctx_destroy(dns_loadctx_t *lctx) { 418| 2| REQUIRE(DNS_LCTX_VALID(lctx)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 419| | 420| 2| isc_refcount_destroy(&lctx->references); ------------------ | | 60| 2| ISC_REQUIRE(isc_refcount_current(target) == 0) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 421| | 422| 2| lctx->magic = 0; 423| 2| if (lctx->inc != NULL) { ------------------ | Branch (423:6): [True: 2, False: 0] ------------------ 424| 2| incctx_destroy(lctx->mctx, lctx->inc); 425| 2| } 426| | 427| 2| if (lctx->f != NULL) { ------------------ | Branch (427:6): [True: 0, False: 2] ------------------ 428| 0| isc_result_t result = isc_stdio_close(lctx->f); 429| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (429:7): [True: 0, False: 0] ------------------ 430| 0| UNEXPECTED_ERROR("isc_stdio_close() failed: %s", ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 431| 0| isc_result_totext(result)); 432| 0| } 433| 0| } 434| | 435| | /* isc_lex_destroy() will close all open streams */ 436| 2| if (lctx->lex != NULL && !lctx->keep_lex) { ------------------ | Branch (436:6): [True: 2, False: 0] | Branch (436:27): [True: 2, False: 0] ------------------ 437| 2| isc_lex_destroy(&lctx->lex); 438| 2| } 439| | 440| | 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] | | ------------------ ------------------ 441| 2|} master.c:incctx_destroy: 401| 2|incctx_destroy(isc_mem_t *mctx, dns_incctx_t *ictx) { 402| 2| dns_incctx_t *parent; 403| | 404| 2|again: 405| 2| parent = ictx->parent; 406| 2| ictx->parent = NULL; 407| | 408| 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] | | ------------------ ------------------ 409| | 410| 2| if (parent != NULL) { ------------------ | Branch (410:6): [True: 0, False: 2] ------------------ 411| 0| ictx = parent; 412| 0| goto again; 413| 0| } 414| 2|} master.c:loadctx_create: 481| 2| isc_lex_t *lex, dns_loadctx_t **lctxp) { 482| 2| dns_loadctx_t *lctx = NULL; 483| 2| isc_region_t r; 484| | 485| 2| REQUIRE(lctxp != NULL && *lctxp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 486| 2| REQUIRE(callbacks != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 487| 2| REQUIRE(callbacks->update != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 488| 2| REQUIRE(callbacks->error != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 489| 2| REQUIRE(callbacks->warn != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 490| 2| REQUIRE(mctx != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 491| 2| REQUIRE(dns_name_isabsolute(top)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 492| 2| REQUIRE(dns_name_isabsolute(origin)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 493| | 494| 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) ------------------ 495| 2| *lctx = (dns_loadctx_t){ 496| 2| .format = format, 497| 2| .ttl_known = ((options & DNS_MASTER_NOTTL) != 0), ------------------ | | 57| 2|#define DNS_MASTER_NOTTL 0x00008000 /*%< Don't require ttl. */ ------------------ 498| 2| .default_ttl_known = ((options & DNS_MASTER_NOTTL) != 0), ------------------ | | 57| 2|#define DNS_MASTER_NOTTL 0x00008000 /*%< Don't require ttl. */ ------------------ 499| 2| .warn_1035 = true, 500| 2| .warn_sigexpired = true, 501| 2| .options = options, 502| 2| .zclass = zclass, 503| 2| .resign = resign, 504| 2| .include_cb = include_cb, 505| 2| .include_arg = include_arg, 506| 2| .first = true, 507| 2| .done = done, 508| 2| .callbacks = callbacks, 509| 2| .done_arg = done_arg, 510| 2| }; 511| | 512| 2| incctx_create(mctx, origin, &lctx->inc); 513| | 514| 2| switch (format) { 515| 2| case dns_masterformat_text: ------------------ | Branch (515:2): [True: 2, False: 0] ------------------ 516| 2| lctx->openfile = openfile_text; 517| 2| lctx->load = load_text; 518| 2| break; 519| 0| case dns_masterformat_raw: ------------------ | Branch (519:2): [True: 0, False: 2] ------------------ 520| 0| lctx->openfile = openfile_raw; 521| 0| lctx->load = load_raw; 522| 0| break; 523| 0| default: ------------------ | Branch (523:2): [True: 0, False: 2] ------------------ 524| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 525| 2| } 526| | 527| 2| if (lex != NULL) { ------------------ | Branch (527:6): [True: 0, False: 2] ------------------ 528| 0| lctx->lex = lex; 529| 0| lctx->keep_lex = true; 530| 2| } else { 531| 2| isc_lexspecials_t specials; 532| 2| lctx->lex = NULL; 533| 2| isc_lex_create(mctx, TOKENSIZ, &lctx->lex); ------------------ | | 84| 2|#define TOKENSIZ (8 * 1024) ------------------ 534| 2| lctx->keep_lex = false; 535| | /* 536| | * If specials change update dns_test_rdatafromstring() 537| | * in lib/dns/tests/dnstest.c. 538| | */ 539| 2| memset(specials, 0, sizeof(specials)); 540| 2| specials['('] = 1; 541| 2| specials[')'] = 1; 542| 2| specials['"'] = 1; 543| 2| isc_lex_setspecials(lctx->lex, specials); 544| 2| isc_lex_setcomments(lctx->lex, ISC_LEXCOMMENT_DNSMASTERFILE); ------------------ | | 98| 2|#define ISC_LEXCOMMENT_DNSMASTERFILE 0x08 ------------------ 545| 2| } 546| | 547| 2| lctx->now = isc_stdtime_now(); 548| | 549| 2| lctx->top = dns_fixedname_initname(&lctx->fixed_top); 550| 2| dns_name_toregion(top, &r); ------------------ | | 1548| 2|#define dns_name_toregion(name, r) dns_name__toregion(DNS_NAME__RO_ARG(name), r) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 551| 2| dns_name_fromregion(lctx->top, &r); 552| | 553| 2| dns_master_initrawheader(&lctx->header); 554| | 555| 2| isc_refcount_init(&lctx->references, 1); /* Implicit attach. */ ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 556| 2| isc_mem_attach(mctx, &lctx->mctx); 557| | 558| 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)) | | ------------------ ------------------ 559| 2| *lctxp = lctx; 560| 2| return; 561| 2|} master.c:incctx_create: 444| 2|incctx_create(isc_mem_t *mctx, dns_name_t *origin, dns_incctx_t **ictxp) { 445| 2| dns_incctx_t *ictx; 446| 2| isc_region_t r; 447| 2| int i; 448| | 449| 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) ------------------ 450| | 451| 10| for (i = 0; i < NBUFS; i++) { ------------------ | | 63| 10|#define NBUFS 4 ------------------ | Branch (451:14): [True: 8, False: 2] ------------------ 452| 8| dns_fixedname_init(&ictx->fixed[i]); 453| 8| ictx->in_use[i] = false; 454| 8| } 455| | 456| 2| ictx->origin_in_use = 0; 457| 2| ictx->origin = dns_name(&ictx->fixed[ictx->origin_in_use]); ------------------ | | 1515| 2|#define dns_name(source) DNS_NAME__RO_ARG(source) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 458| 2| ictx->in_use[ictx->origin_in_use] = true; 459| 2| dns_name_toregion(origin, &r); ------------------ | | 1548| 2|#define dns_name_toregion(name, r) dns_name__toregion(DNS_NAME__RO_ARG(name), r) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 460| 2| dns_name_fromregion(ictx->origin, &r); 461| | 462| 2| ictx->glue = NULL; 463| 2| ictx->current = NULL; 464| 2| ictx->glue_in_use = -1; 465| 2| ictx->current_in_use = -1; 466| 2| ictx->parent = NULL; 467| 2| ictx->drop = false; 468| 2| ictx->glue_line = 0; 469| 2| ictx->current_line = 0; 470| 2| ictx->origin_changed = true; 471| | 472| 2| *ictxp = ictx; 473| 2|} master.c:openfile_text: 969| 2|openfile_text(dns_loadctx_t *lctx, const char *master_file) { 970| 2| return isc_lex_openfile(lctx->lex, master_file); 971| 2|} master.c:load_text: 987| 2|load_text(dns_loadctx_t *lctx) { 988| 2| dns_rdataclass_t rdclass; 989| 2| dns_rdatatype_t type, covers; 990| 2| uint32_t ttl_offset = 0; 991| 2| dns_name_t *new_name = NULL; 992| 2| bool current_has_delegation = false; 993| 2| bool finish_origin = false; 994| 2| bool finish_include = false; 995| 2| bool read_till_eol = false; 996| 2| bool initialws; 997| 2| char *include_file = NULL; 998| 2| isc_token_t token; 999| 2| isc_result_t result = ISC_R_UNEXPECTED; 1000| 2| rdatalist_head_t glue_list; 1001| 2| rdatalist_head_t current_list; 1002| 2| dns_rdatalist_t *rdatalist = NULL; 1003| 2| dns_rdatalist_t *new_rdatalist = NULL; 1004| 2| int rdlcount = 0; 1005| 2| int rdlcount_save = 0; 1006| 2| int rdatalist_size = 0; 1007| 2| isc_buffer_t buffer; 1008| 2| isc_buffer_t target; 1009| 2| isc_buffer_t target_ft; 1010| 2| isc_buffer_t target_save; 1011| 2| dns_rdata_t *rdata = NULL; 1012| 2| dns_rdata_t *new_rdata = NULL; 1013| 2| int rdcount = 0; 1014| 2| int rdcount_save = 0; 1015| 2| int rdata_size = 0; 1016| 2| unsigned char *target_mem = NULL; 1017| 2| int target_size = TSIZ; ------------------ | | 72| 2|#define TSIZ (128 * 1024) ------------------ 1018| 2| int new_in_use; 1019| 2| isc_mem_t *mctx = NULL; 1020| 2| dns_rdatacallbacks_t *callbacks = NULL; 1021| 2| dns_incctx_t *ictx = NULL; 1022| 2| char *range = NULL; 1023| 2| char *lhs = NULL; 1024| 2| char *gtype = NULL; 1025| 2| char *rhs = NULL; 1026| 2| const char *source = NULL; 1027| 2| unsigned long line = 0; 1028| 2| bool explicit_ttl; 1029| 2| char classname1[DNS_RDATACLASS_FORMATSIZE]; 1030| 2| char classname2[DNS_RDATACLASS_FORMATSIZE]; 1031| 2| unsigned int options = 0; 1032| | 1033| 2| REQUIRE(DNS_LCTX_VALID(lctx)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1034| 2| callbacks = lctx->callbacks; 1035| 2| mctx = lctx->mctx; 1036| 2| ictx = lctx->inc; 1037| | 1038| 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] | | ------------------ ------------------ 1039| 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] | | ------------------ ------------------ 1040| | 1041| | /* 1042| | * Allocate target_size of buffer space. This is greater than twice 1043| | * the maximum individual RR data size. 1044| | */ 1045| 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) ------------------ 1046| 2| isc_buffer_init(&target, target_mem, target_size); 1047| 2| target_save = target; 1048| | 1049| | /* open a database transaction */ 1050| 2| if (callbacks->setup != NULL) { ------------------ | Branch (1050:6): [True: 2, False: 0] ------------------ 1051| 2| callbacks->setup(callbacks->add_private); 1052| 2| } 1053| | 1054| 2| if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) { ------------------ | | 47| 2|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ | Branch (1054:6): [True: 0, False: 2] ------------------ 1055| 0| options |= DNS_RDATA_CHECKNAMES; ------------------ | | 212| 0|#define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES | | ------------------ | | | | 167| 0|#define DNS_NAME_CHECKNAMES 0x0002 /*%< Used by rdata. */ | | ------------------ ------------------ 1056| 0| } 1057| 2| if ((lctx->options & DNS_MASTER_CHECKNAMESFAIL) != 0) { ------------------ | | 48| 2|#define DNS_MASTER_CHECKNAMESFAIL 0x00000200 ------------------ | Branch (1057:6): [True: 0, False: 2] ------------------ 1058| 0| options |= DNS_RDATA_CHECKNAMESFAIL; ------------------ | | 213| 0|#define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL | | ------------------ | | | | 168| 0|#define DNS_NAME_CHECKNAMESFAIL 0x0004 /*%< Used by rdata. */ | | ------------------ ------------------ 1059| 0| } 1060| 2| if ((lctx->options & DNS_MASTER_CHECKMX) != 0) { ------------------ | | 52| 2|#define DNS_MASTER_CHECKMX 0x00000800 ------------------ | Branch (1060:6): [True: 0, False: 2] ------------------ 1061| 0| options |= DNS_RDATA_CHECKMX; ------------------ | | 215| 0|#define DNS_RDATA_CHECKMX DNS_NAME_CHECKMX | | ------------------ | | | | 170| 0|#define DNS_NAME_CHECKMX 0x0010 /*%< Used by rdata. */ | | ------------------ ------------------ 1062| 0| } 1063| 2| if ((lctx->options & DNS_MASTER_CHECKMXFAIL) != 0) { ------------------ | | 53| 2|#define DNS_MASTER_CHECKMXFAIL 0x00001000 ------------------ | Branch (1063:6): [True: 0, False: 2] ------------------ 1064| 0| options |= DNS_RDATA_CHECKMXFAIL; ------------------ | | 216| 0|#define DNS_RDATA_CHECKMXFAIL DNS_NAME_CHECKMXFAIL | | ------------------ | | | | 171| 0|#define DNS_NAME_CHECKMXFAIL 0x0020 /*%< Used by rdata. */ | | ------------------ ------------------ 1065| 0| } 1066| 2| source = isc_lex_getsourcename(lctx->lex); 1067| 8| while (true) { ------------------ | Branch (1067:9): [True: 8, Folded] ------------------ 1068| 8| dns_rdatalist_t *this = NULL; 1069| | 1070| 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] | | ------------------ ------------------ 1071| 0| result = ISC_R_CANCELED; 1072| 0| goto log_and_cleanup; 1073| 0| } 1074| | 1075| 8| initialws = false; 1076| 8| line = isc_lex_getsourceline(lctx->lex); 1077| 8| GETTOKEN(lctx->lex, ISC_LEXOPT_INITIALWS | ISC_LEXOPT_QSTRING, ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| 8| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 8] | | | | ------------------ | | | | 249| 8| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 8] | | | | ------------------ | | | | 250| 8| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 8| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 1078| 8| &token, true); 1079| 8| line = isc_lex_getsourceline(lctx->lex); 1080| | 1081| 8| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1081:7): [True: 2, False: 6] ------------------ 1082| 2| if (read_till_eol) { ------------------ | Branch (1082:8): [True: 0, False: 2] ------------------ 1083| 0| WARNUNEXPECTEDEOF(lctx->lex); ------------------ | | 286| 0| do { \ | | 287| 0| if (isc_lex_isfile(lexer)) \ | | ------------------ | | | Branch (287:7): [True: 0, False: 0] | | ------------------ | | 288| 0| (*callbacks->warn)(callbacks, \ | | 289| 0| "%s: file does not end with " \ | | 290| 0| "newline", \ | | 291| 0| source); \ | | 292| 0| } while (0) | | ------------------ | | | Branch (292:11): [Folded, False: 0] | | ------------------ ------------------ 1084| 0| } 1085| | /* Pop the include stack? */ 1086| 2| if (ictx->parent != NULL) { ------------------ | Branch (1086:8): [True: 0, False: 2] ------------------ 1087| 0| COMMITALL; ------------------ | | 265| 0| do { \ | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | 267| 0| source, ictx->current_line); \ | | 268| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 269| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (270:14): [True: 0, False: 0] | | ------------------ | | 271| 0| goto insist_and_cleanup; \ | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | 273| 0| source, ictx->glue_line); \ | | 274| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 275| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (276:14): [True: 0, False: 0] | | ------------------ | | 277| 0| goto insist_and_cleanup; \ | | 278| 0| rdcount = 0; \ | | 279| 0| rdlcount = 0; \ | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | 281| 0| rdcount_save = rdcount; \ | | 282| 0| rdlcount_save = rdlcount; \ | | 283| 0| } while (0) | | ------------------ | | | Branch (283:11): [Folded, False: 0] | | ------------------ ------------------ 1088| 0| lctx->inc = ictx->parent; 1089| 0| ictx->parent = NULL; 1090| 0| incctx_destroy(lctx->mctx, ictx); 1091| 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] | | ------------------ ------------------ 1092| 0| ISC_R_SUCCESS); 1093| 0| line = isc_lex_getsourceline(lctx->lex); 1094| 0| POST(line); ------------------ | | 74| 0|#define POST(x) (void)(x) ------------------ 1095| 0| source = isc_lex_getsourcename(lctx->lex); 1096| 0| ictx = lctx->inc; 1097| 0| continue; 1098| 0| } 1099| 2| break; 1100| 2| } 1101| | 1102| 6| if (token.type == isc_tokentype_eol) { ------------------ | Branch (1102:7): [True: 0, False: 6] ------------------ 1103| 0| read_till_eol = false; 1104| 0| continue; /* blank line */ 1105| 0| } 1106| | 1107| 6| if (read_till_eol) { ------------------ | Branch (1107:7): [True: 0, False: 6] ------------------ 1108| 0| continue; 1109| 0| } 1110| | 1111| 6| if (token.type == isc_tokentype_initialws) { ------------------ | Branch (1111:7): [True: 0, False: 6] ------------------ 1112| | /* 1113| | * Still working on the same name. 1114| | */ 1115| 0| initialws = true; 1116| 6| } else if (token.type == isc_tokentype_string || ------------------ | Branch (1116:14): [True: 6, False: 0] ------------------ 1117| 0| token.type == isc_tokentype_qstring) ------------------ | Branch (1117:7): [True: 0, False: 0] ------------------ 1118| 6| { 1119| | /* 1120| | * "$" Support. 1121| | * 1122| | * "$ORIGIN" and "$INCLUDE" can both take domain names. 1123| | * The processing of "$ORIGIN" and "$INCLUDE" extends 1124| | * across the normal domain name processing. 1125| | */ 1126| | 1127| 6| if (strcasecmp(DNS_AS_STR(token), "$ORIGIN") == 0) { ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1127:8): [True: 0, False: 6] ------------------ 1128| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1129| 0| finish_origin = true; 1130| 6| } else if (strcasecmp(DNS_AS_STR(token), "$TTL") == 0) { ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1130:15): [True: 0, False: 6] ------------------ 1131| 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); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 223| 0| COMMITALL; \ | | ------------------ | | | | 265| 0| do { \ | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | 267| 0| source, ictx->current_line); \ | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 269| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | ------------------ | | | | | Branch (270:14): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| goto insist_and_cleanup; \ | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | 273| 0| source, ictx->glue_line); \ | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 275| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | ------------------ | | | | | Branch (276:14): [True: 0, False: 0] | | | | ------------------ | | | | 277| 0| goto insist_and_cleanup; \ | | | | 278| 0| rdcount = 0; \ | | | | 279| 0| rdlcount = 0; \ | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | 281| 0| rdcount_save = rdcount; \ | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | 283| 0| } while (0) | | | | ------------------ | | | | | Branch (283: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)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 241| 0| LOGIT(result); \ | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | ------------------ | | | Branch (248:7): [True: 0, False: 0] | | ------------------ | | 249| 0| isc_token_hasnul(token)) \ | | ------------------ | | | Branch (249:7): [True: 0, False: 0] | | ------------------ | | 250| 0| { \ | | 251| 0| result = DNS_R_SYNTAX; \ | | 252| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 253| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 254| 0| LOGIT(result); \ | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ | | 255| 0| read_till_eol = true; \ | | 256| 0| goto next_line; \ | | 257| 0| } else \ | | 258| 0| goto log_and_cleanup; \ | | 259| 0| } \ | | 260| 0| } while (0) | | ------------------ | | | Branch (260:11): [Folded, False: 0] | | ------------------ ------------------ 1132| 0| lctx->ttl = 0; 1133| 0| lctx->default_ttl_known = true;); 1134| 0| result = dns_ttl_fromtext( 1135| 0| &token.value.as_textregion, &lctx->ttl); 1136| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1137| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1138| 0| lctx->ttl = 0; 1139| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1139:16): [True: 0, False: 0] ------------------ 1140| 0| goto insist_and_cleanup; 1141| 0| } 1142| 0| limit_ttl(callbacks, source, line, &lctx->ttl); 1143| 0| lctx->default_ttl = lctx->ttl; 1144| 0| lctx->default_ttl_known = true; 1145| 0| EXPECTEOL; ------------------ | | 295| 0| do { \ | | 296| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 262| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 265| 0| do { \ | | | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | | | 278| 0| rdcount = 0; \ | | | | | | | | 279| 0| rdlcount = 0; \ | | | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | | | 283| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (283: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)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | | | ------------------ | | | | | | | Branch (248:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 249| 0| isc_token_hasnul(token)) \ | | | | | | ------------------ | | | | | | | Branch (249:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 250| 0| { \ | | | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 253| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 254| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 255| 0| read_till_eol = true; \ | | | | | | 256| 0| goto next_line; \ | | | | | | 257| 0| } else \ | | | | | | 258| 0| goto log_and_cleanup; \ | | | | | | 259| 0| } \ | | | | | | 260| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (260:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 297| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (297:7): [True: 0, False: 0] | | ------------------ | | 298| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 299| 0| result = DNS_R_EXTRATOKEN; \ | | 300| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 301| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 302| 0| LOGIT(result); \ | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ | | 303| 0| read_till_eol = true; \ | | 304| 0| break; \ | | 305| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (305:15): [True: 0, False: 0] | | ------------------ | | 306| 0| goto log_and_cleanup; \ | | 307| 0| } \ | | 308| 0| } while (0) | | ------------------ | | | Branch (308:11): [Folded, False: 0] | | ------------------ ------------------ 1146| 0| continue; 1147| 6| } else if (strcasecmp(DNS_AS_STR(token), "$INCLUDE") == ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1147:15): [True: 0, False: 6] ------------------ 1148| 6| 0) 1149| 0| { 1150| 0| COMMITALL; ------------------ | | 265| 0| do { \ | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | 267| 0| source, ictx->current_line); \ | | 268| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 269| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (270:14): [True: 0, False: 0] | | ------------------ | | 271| 0| goto insist_and_cleanup; \ | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | 273| 0| source, ictx->glue_line); \ | | 274| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 275| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (276:14): [True: 0, False: 0] | | ------------------ | | 277| 0| goto insist_and_cleanup; \ | | 278| 0| rdcount = 0; \ | | 279| 0| rdlcount = 0; \ | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | 281| 0| rdcount_save = rdcount; \ | | 282| 0| rdlcount_save = rdlcount; \ | | 283| 0| } while (0) | | ------------------ | | | Branch (283:11): [Folded, False: 0] | | ------------------ ------------------ 1151| 0| if (ttl_offset != 0) { ------------------ | Branch (1151:9): [True: 0, False: 0] ------------------ 1152| 0| (callbacks->error)(callbacks, 1153| 0| "%s: %s:%lu: " 1154| 0| "$INCLUDE " 1155| 0| "may not be used " 1156| 0| "with $DATE", 1157| 0| "dns_master_load", 1158| 0| source, line); 1159| 0| result = DNS_R_SYNTAX; 1160| 0| goto insist_and_cleanup; 1161| 0| } 1162| 0| GETTOKEN(lctx->lex, ISC_LEXOPT_QSTRING, &token, ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1163| 0| false); 1164| 0| if (include_file != NULL) { ------------------ | Branch (1164:9): [True: 0, False: 0] ------------------ 1165| 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] | | ------------------ ------------------ 1166| 0| } 1167| 0| include_file = 1168| 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) ------------------ 1169| 0| GETTOKEN(lctx->lex, 0, &token, true); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1170| | 1171| 0| if (token.type == isc_tokentype_eol || ------------------ | Branch (1171:9): [True: 0, False: 0] ------------------ 1172| 0| token.type == isc_tokentype_eof) ------------------ | Branch (1172:9): [True: 0, False: 0] ------------------ 1173| 0| { 1174| 0| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1174:10): [True: 0, False: 0] ------------------ 1175| 0| WARNUNEXPECTEDEOF(lctx->lex); ------------------ | | 286| 0| do { \ | | 287| 0| if (isc_lex_isfile(lexer)) \ | | ------------------ | | | Branch (287:7): [True: 0, False: 0] | | ------------------ | | 288| 0| (*callbacks->warn)(callbacks, \ | | 289| 0| "%s: file does not end with " \ | | 290| 0| "newline", \ | | 291| 0| source); \ | | 292| 0| } while (0) | | ------------------ | | | Branch (292:11): [Folded, False: 0] | | ------------------ ------------------ 1176| 0| } 1177| | /* 1178| | * No origin field. 1179| | */ 1180| 0| result = pushfile(include_file, 1181| 0| ictx->origin, lctx); 1182| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1183| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1184| 0| LOGITFILE(result, include_file); ------------------ | | 320| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (320:6): [True: 0, False: 0] | | | Branch (320:37): [True: 0, False: 0] | | ------------------ | | 321| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (321:6): [True: 0, False: 0] | | | Branch (321:33): [True: 0, False: 0] | | ------------------ | | 322| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (322:6): [True: 0, False: 0] | | ------------------ | | 323| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 324| 0| "dns_master_load", source, line, filename, \ | | 325| 0| isc_result_totext(result)); \ | | 326| 0| else \ | | 327| 0| LOGIT(result) | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1185| 0| continue; 1186| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1186:17): [True: 0, False: 0] ------------------ 1187| 0| LOGITFILE(result, include_file); ------------------ | | 320| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (320:6): [True: 0, False: 0] | | | Branch (320:37): [True: 0, False: 0] | | ------------------ | | 321| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (321:6): [True: 0, False: 0] | | | Branch (321:33): [True: 0, False: 0] | | ------------------ | | 322| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (322:6): [True: 0, False: 0] | | ------------------ | | 323| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 324| 0| "dns_master_load", source, line, filename, \ | | 325| 0| isc_result_totext(result)); \ | | 326| 0| else \ | | 327| 0| LOGIT(result) | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1188| 0| goto insist_and_cleanup; 1189| 0| } 1190| 0| ictx = lctx->inc; 1191| 0| source = isc_lex_getsourcename( 1192| 0| lctx->lex); 1193| 0| line = isc_lex_getsourceline(lctx->lex); 1194| 0| POST(line); ------------------ | | 74| 0|#define POST(x) (void)(x) ------------------ 1195| 0| continue; 1196| 0| } 1197| | /* 1198| | * There is an origin field. Fall through 1199| | * to domain name processing code and do 1200| | * the actual inclusion later. 1201| | */ 1202| 0| finish_include = true; 1203| 6| } else if (strcasecmp(DNS_AS_STR(token), "$DATE") == 0) ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1203:15): [True: 0, False: 6] ------------------ 1204| 0| { 1205| 0| int64_t dump_time64; 1206| 0| isc_stdtime_t dump_time; 1207| 0| isc_stdtime_t current_time = isc_stdtime_now(); 1208| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1209| 0| result = dns_time64_fromregion( 1210| 0| token.value.as_textregion, 1211| 0| &dump_time64); 1212| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1213| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1214| 0| LOGIT(result); ------------------ | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 331| 0| source, line, isc_result_totext(result)) ------------------ 1215| 0| dump_time64 = 0; 1216| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1216:16): [True: 0, False: 0] ------------------ 1217| 0| goto log_and_cleanup; 1218| 0| } 1219| 0| dump_time = (isc_stdtime_t)dump_time64; 1220| 0| if (dump_time != dump_time64) { ------------------ | Branch (1220:9): [True: 0, False: 0] ------------------ 1221| 0| UNEXPECTED_ERROR("%s: %s:%lu: $DATE " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1222| 0| "outside epoch", 1223| 0| "dns_master_load", 1224| 0| source, line); 1225| 0| result = ISC_R_UNEXPECTED; 1226| 0| goto insist_and_cleanup; 1227| 0| } 1228| 0| if (dump_time > current_time) { ------------------ | Branch (1228:9): [True: 0, False: 0] ------------------ 1229| 0| UNEXPECTED_ERROR("%s: %s:%lu: " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1230| 0| "$DATE in future, " 1231| 0| "using current date", 1232| 0| "dns_master_load", 1233| 0| source, line); 1234| 0| dump_time = current_time; 1235| 0| } 1236| 0| ttl_offset = current_time - dump_time; 1237| 0| EXPECTEOL; ------------------ | | 295| 0| do { \ | | 296| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 262| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 265| 0| do { \ | | | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | | | 278| 0| rdcount = 0; \ | | | | | | | | 279| 0| rdlcount = 0; \ | | | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | | | 283| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (283: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)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | | | ------------------ | | | | | | | Branch (248:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 249| 0| isc_token_hasnul(token)) \ | | | | | | ------------------ | | | | | | | Branch (249:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 250| 0| { \ | | | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 253| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 254| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 255| 0| read_till_eol = true; \ | | | | | | 256| 0| goto next_line; \ | | | | | | 257| 0| } else \ | | | | | | 258| 0| goto log_and_cleanup; \ | | | | | | 259| 0| } \ | | | | | | 260| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (260:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 297| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (297:7): [True: 0, False: 0] | | ------------------ | | 298| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 299| 0| result = DNS_R_EXTRATOKEN; \ | | 300| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 301| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 302| 0| LOGIT(result); \ | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ | | 303| 0| read_till_eol = true; \ | | 304| 0| break; \ | | 305| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (305:15): [True: 0, False: 0] | | ------------------ | | 306| 0| goto log_and_cleanup; \ | | 307| 0| } \ | | 308| 0| } while (0) | | ------------------ | | | Branch (308:11): [Folded, False: 0] | | ------------------ ------------------ 1238| 0| continue; 1239| 6| } else if (strcasecmp(DNS_AS_STR(token), "$GENERATE") == ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1239:15): [True: 0, False: 6] ------------------ 1240| 6| 0) 1241| 0| { 1242| | /* 1243| | * Lazy cleanup. 1244| | */ 1245| 0| if (range != NULL) { ------------------ | Branch (1245:9): [True: 0, False: 0] ------------------ 1246| 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] | | ------------------ ------------------ 1247| 0| } 1248| 0| if (lhs != NULL) { ------------------ | Branch (1248:9): [True: 0, False: 0] ------------------ 1249| 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] | | ------------------ ------------------ 1250| 0| } 1251| 0| if (gtype != NULL) { ------------------ | Branch (1251:9): [True: 0, False: 0] ------------------ 1252| 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] | | ------------------ ------------------ 1253| 0| } 1254| 0| if (rhs != NULL) { ------------------ | Branch (1254:9): [True: 0, False: 0] ------------------ 1255| 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] | | ------------------ ------------------ 1256| 0| } 1257| 0| range = lhs = gtype = rhs = NULL; 1258| | /* RANGE */ 1259| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1260| 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) ------------------ 1261| | /* LHS */ 1262| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1263| 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) ------------------ 1264| 0| rdclass = 0; 1265| 0| explicit_ttl = false; 1266| | /* CLASS? */ 1267| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1268| 0| if (dns_rdataclass_fromtext( ------------------ | Branch (1268:9): [True: 0, False: 0] ------------------ 1269| 0| &rdclass, 1270| 0| &token.value.as_textregion) == 1271| 0| ISC_R_SUCCESS) 1272| 0| { 1273| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1274| 0| } 1275| | /* TTL? */ 1276| 0| if (dns_ttl_fromtext(&token.value.as_textregion, ------------------ | Branch (1276:9): [True: 0, False: 0] ------------------ 1277| 0| &lctx->ttl) == 1278| 0| ISC_R_SUCCESS) 1279| 0| { 1280| 0| limit_ttl(callbacks, source, line, 1281| 0| &lctx->ttl); 1282| 0| lctx->ttl_known = true; 1283| 0| explicit_ttl = true; 1284| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1285| 0| } 1286| | /* CLASS? */ 1287| 0| if (rdclass == 0 && ------------------ | Branch (1287:9): [True: 0, False: 0] ------------------ 1288| 0| dns_rdataclass_fromtext( ------------------ | Branch (1288:9): [True: 0, False: 0] ------------------ 1289| 0| &rdclass, 1290| 0| &token.value.as_textregion) == 1291| 0| ISC_R_SUCCESS) 1292| 0| { 1293| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1294| 0| } 1295| | /* TYPE */ 1296| 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) ------------------ 1297| | /* RHS */ 1298| 0| GETTOKEN(lctx->lex, ISC_LEXOPT_QSTRING, &token, ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1299| 0| false); 1300| 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) ------------------ 1301| 0| if (!lctx->ttl_known && ------------------ | Branch (1301:9): [True: 0, False: 0] ------------------ 1302| 0| !lctx->default_ttl_known) ------------------ | Branch (1302:9): [True: 0, False: 0] ------------------ 1303| 0| { 1304| 0| (*callbacks->error)(callbacks, 1305| 0| "%s: %s:%lu: no " 1306| 0| "TTL specified", 1307| 0| "dns_master_load", 1308| 0| source, line); 1309| 0| result = DNS_R_NOTTL; 1310| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1311| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1312| 0| lctx->ttl = 0; 1313| 0| } else { 1314| 0| goto insist_and_cleanup; 1315| 0| } 1316| 0| } else if (!explicit_ttl && ------------------ | Branch (1316:16): [True: 0, False: 0] ------------------ 1317| 0| lctx->default_ttl_known) ------------------ | Branch (1317:9): [True: 0, False: 0] ------------------ 1318| 0| { 1319| 0| lctx->ttl = lctx->default_ttl; 1320| 0| } 1321| | /* 1322| | * If the class specified does not match the 1323| | * zone's class print out a error message and 1324| | * exit. 1325| | */ 1326| 0| if (rdclass != 0 && rdclass != lctx->zclass) { ------------------ | Branch (1326:9): [True: 0, False: 0] | Branch (1326:25): [True: 0, False: 0] ------------------ 1327| 0| goto bad_class; 1328| 0| } 1329| 0| result = generate(lctx, range, lhs, gtype, rhs, 1330| 0| source, line); 1331| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1332| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1333| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1333:16): [True: 0, False: 0] ------------------ 1334| 0| goto insist_and_cleanup; 1335| 0| } 1336| 0| EXPECTEOL; ------------------ | | 295| 0| do { \ | | 296| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 262| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 265| 0| do { \ | | | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | | | 278| 0| rdcount = 0; \ | | | | | | | | 279| 0| rdlcount = 0; \ | | | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | | | 283| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (283: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)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | | | ------------------ | | | | | | | Branch (248:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 249| 0| isc_token_hasnul(token)) \ | | | | | | ------------------ | | | | | | | Branch (249:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 250| 0| { \ | | | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 253| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 254| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 255| 0| read_till_eol = true; \ | | | | | | 256| 0| goto next_line; \ | | | | | | 257| 0| } else \ | | | | | | 258| 0| goto log_and_cleanup; \ | | | | | | 259| 0| } \ | | | | | | 260| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (260:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 297| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (297:7): [True: 0, False: 0] | | ------------------ | | 298| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 299| 0| result = DNS_R_EXTRATOKEN; \ | | 300| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 301| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 302| 0| LOGIT(result); \ | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ | | 303| 0| read_till_eol = true; \ | | 304| 0| break; \ | | 305| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (305:15): [True: 0, False: 0] | | ------------------ | | 306| 0| goto log_and_cleanup; \ | | 307| 0| } \ | | 308| 0| } while (0) | | ------------------ | | | Branch (308:11): [Folded, False: 0] | | ------------------ ------------------ 1337| 0| continue; 1338| 6| } else if (isc_string_casehasprefix(DNS_AS_STR(token), ------------------ | | 176| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1338:15): [True: 0, False: 6] ------------------ 1339| 6| "$")) 1340| 0| { 1341| 0| (callbacks->error)(callbacks, 1342| 0| "%s: %s:%lu: " 1343| 0| "unknown $ directive '%s'", 1344| 0| "dns_master_load", source, 1345| 0| line, DNS_AS_STR(token)); ------------------ | | 176| 0|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ 1346| 0| result = DNS_R_SYNTAX; 1347| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1348| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1349| 0| } else { 1350| 0| goto insist_and_cleanup; 1351| 0| } 1352| 0| } 1353| | 1354| | /* 1355| | * Normal processing resumes. 1356| | */ 1357| 6| new_in_use = find_free_name(ictx); 1358| 6| new_name = dns_fixedname_initname( 1359| 6| &ictx->fixed[new_in_use]); 1360| 6| isc_buffer_init(&buffer, token.value.as_region.base, 1361| 6| token.value.as_region.length); 1362| 6| isc_buffer_add(&buffer, token.value.as_region.length); 1363| 6| isc_buffer_setactive(&buffer, 1364| 6| token.value.as_region.length); 1365| 6| result = dns_name_fromtext(new_name, &buffer, 1366| 6| ictx->origin, 0); 1367| 6| if (MANYERRS(lctx, result)) { ------------------ | | 311| 6| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 6] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1368| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1369| 0| LOGIT(result); ------------------ | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 331| 0| source, line, isc_result_totext(result)) ------------------ 1370| 0| read_till_eol = true; 1371| 0| continue; 1372| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1372:15): [True: 0, False: 6] ------------------ 1373| 0| goto log_and_cleanup; 1374| 0| } 1375| | 1376| | /* 1377| | * Finish $ORIGIN / $INCLUDE processing if required. 1378| | */ 1379| 6| if (finish_origin) { ------------------ | Branch (1379:8): [True: 0, False: 6] ------------------ 1380| 0| if (ictx->origin_in_use != -1) { ------------------ | Branch (1380:9): [True: 0, False: 0] ------------------ 1381| 0| ictx->in_use[ictx->origin_in_use] = 1382| 0| false; 1383| 0| } 1384| 0| ictx->origin_in_use = new_in_use; 1385| 0| ictx->in_use[ictx->origin_in_use] = true; 1386| 0| ictx->origin = new_name; 1387| 0| ictx->origin_changed = true; 1388| 0| finish_origin = false; 1389| 0| EXPECTEOL; ------------------ | | 295| 0| do { \ | | 296| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 262| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 265| 0| do { \ | | | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | | | 278| 0| rdcount = 0; \ | | | | | | | | 279| 0| rdlcount = 0; \ | | | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | | | 283| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (283: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)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | | | ------------------ | | | | | | | Branch (248:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 249| 0| isc_token_hasnul(token)) \ | | | | | | ------------------ | | | | | | | Branch (249:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 250| 0| { \ | | | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 253| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 254| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 255| 0| read_till_eol = true; \ | | | | | | 256| 0| goto next_line; \ | | | | | | 257| 0| } else \ | | | | | | 258| 0| goto log_and_cleanup; \ | | | | | | 259| 0| } \ | | | | | | 260| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (260:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 297| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (297:7): [True: 0, False: 0] | | ------------------ | | 298| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 299| 0| result = DNS_R_EXTRATOKEN; \ | | 300| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 301| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 302| 0| LOGIT(result); \ | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ | | 303| 0| read_till_eol = true; \ | | 304| 0| break; \ | | 305| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (305:15): [True: 0, False: 0] | | ------------------ | | 306| 0| goto log_and_cleanup; \ | | 307| 0| } \ | | 308| 0| } while (0) | | ------------------ | | | Branch (308:11): [Folded, False: 0] | | ------------------ ------------------ 1390| 0| continue; 1391| 0| } 1392| 6| if (finish_include) { ------------------ | Branch (1392:8): [True: 0, False: 6] ------------------ 1393| 0| finish_include = false; 1394| 0| EXPECTEOL; ------------------ | | 295| 0| do { \ | | 296| 0| GETTOKEN(lctx->lex, 0, &token, true); \ | | ------------------ | | | | 262| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 223| 0| COMMITALL; \ | | | | | | ------------------ | | | | | | | | 265| 0| do { \ | | | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | | | ------------------ | | | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 312| 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] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | | | ------------------ | | | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | | | 317| 0| } | | | | | | | | ------------------ | | | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | | | ------------------ | | | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | | | 278| 0| rdcount = 0; \ | | | | | | | | 279| 0| rdlcount = 0; \ | | | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | | | 283| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (283: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)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 241| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | | | ------------------ | | | | | | | Branch (248:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 249| 0| isc_token_hasnul(token)) \ | | | | | | ------------------ | | | | | | | Branch (249:7): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 250| 0| { \ | | | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 253| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 254| 0| LOGIT(result); \ | | | | | | ------------------ | | | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | | | ------------------ | | | | | | 255| 0| read_till_eol = true; \ | | | | | | 256| 0| goto next_line; \ | | | | | | 257| 0| } else \ | | | | | | 258| 0| goto log_and_cleanup; \ | | | | | | 259| 0| } \ | | | | | | 260| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (260:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 297| 0| if (token.type != isc_tokentype_eol) { \ | | ------------------ | | | Branch (297:7): [True: 0, False: 0] | | ------------------ | | 298| 0| isc_lex_ungettoken(lctx->lex, &token); \ | | 299| 0| result = DNS_R_EXTRATOKEN; \ | | 300| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 301| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 302| 0| LOGIT(result); \ | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ | | 303| 0| read_till_eol = true; \ | | 304| 0| break; \ | | 305| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (305:15): [True: 0, False: 0] | | ------------------ | | 306| 0| goto log_and_cleanup; \ | | 307| 0| } \ | | 308| 0| } while (0) | | ------------------ | | | Branch (308:11): [Folded, False: 0] | | ------------------ ------------------ 1395| 0| result = pushfile(include_file, new_name, lctx); 1396| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1397| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1398| 0| LOGITFILE(result, include_file); ------------------ | | 320| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (320:6): [True: 0, False: 0] | | | Branch (320:37): [True: 0, False: 0] | | ------------------ | | 321| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (321:6): [True: 0, False: 0] | | | Branch (321:33): [True: 0, False: 0] | | ------------------ | | 322| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (322:6): [True: 0, False: 0] | | ------------------ | | 323| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 324| 0| "dns_master_load", source, line, filename, \ | | 325| 0| isc_result_totext(result)); \ | | 326| 0| else \ | | 327| 0| LOGIT(result) | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1399| 0| continue; 1400| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1400:16): [True: 0, False: 0] ------------------ 1401| 0| LOGITFILE(result, include_file); ------------------ | | 320| 0| if (result == ISC_R_INVALIDFILE || result == ISC_R_FILENOTFOUND || \ | | ------------------ | | | Branch (320:6): [True: 0, False: 0] | | | Branch (320:37): [True: 0, False: 0] | | ------------------ | | 321| 0| result == ISC_R_IOERROR || result == ISC_R_TOOMANYOPENFILES || \ | | ------------------ | | | Branch (321:6): [True: 0, False: 0] | | | Branch (321:33): [True: 0, False: 0] | | ------------------ | | 322| 0| result == ISC_R_NOPERM) \ | | ------------------ | | | Branch (322:6): [True: 0, False: 0] | | ------------------ | | 323| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s: %s", \ | | 324| 0| "dns_master_load", source, line, filename, \ | | 325| 0| isc_result_totext(result)); \ | | 326| 0| else \ | | 327| 0| LOGIT(result) | | ------------------ | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | 331| 0| source, line, isc_result_totext(result)) | | ------------------ ------------------ 1402| 0| goto insist_and_cleanup; 1403| 0| } 1404| 0| ictx = lctx->inc; 1405| 0| ictx->origin_changed = true; 1406| 0| source = isc_lex_getsourcename(lctx->lex); 1407| 0| line = isc_lex_getsourceline(lctx->lex); 1408| 0| POST(line); ------------------ | | 74| 0|#define POST(x) (void)(x) ------------------ 1409| 0| continue; 1410| 0| } 1411| | 1412| | /* 1413| | * "$" Processing Finished 1414| | */ 1415| | 1416| | /* 1417| | * If we are processing glue and the new name does 1418| | * not match the current glue name, commit the glue 1419| | * and pop stacks leaving us in 'normal' processing 1420| | * state. Linked lists are undone by commit(). 1421| | */ 1422| 6| if (ictx->glue != NULL && ------------------ | Branch (1422:8): [True: 0, False: 6] ------------------ 1423| 0| !dns_name_caseequal(ictx->glue, new_name)) ------------------ | Branch (1423:8): [True: 0, False: 0] ------------------ 1424| 0| { 1425| 0| result = commit(callbacks, lctx, &glue_list, 1426| 0| ictx->glue, source, 1427| 0| ictx->glue_line); 1428| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1429| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1430| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1430:16): [True: 0, False: 0] ------------------ 1431| 0| goto insist_and_cleanup; 1432| 0| } 1433| 0| if (ictx->glue_in_use != -1) { ------------------ | Branch (1433:9): [True: 0, False: 0] ------------------ 1434| 0| ictx->in_use[ictx->glue_in_use] = false; 1435| 0| } 1436| 0| ictx->glue_in_use = -1; 1437| 0| ictx->glue = NULL; 1438| 0| rdcount = rdcount_save; 1439| 0| rdlcount = rdlcount_save; 1440| 0| target = target_save; 1441| 0| } 1442| | 1443| | /* 1444| | * If we are in 'normal' processing state and the new 1445| | * name does not match the current name, see if the 1446| | * new name is for glue and treat it as such, 1447| | * otherwise we have a new name so commit what we 1448| | * have. 1449| | */ 1450| 6| if ((ictx->glue == NULL) && ------------------ | Branch (1450:8): [True: 6, False: 0] ------------------ 1451| 6| (ictx->current == NULL || ------------------ | Branch (1451:9): [True: 2, False: 4] ------------------ 1452| 4| !dns_name_caseequal(ictx->current, new_name))) ------------------ | Branch (1452:9): [True: 0, False: 4] ------------------ 1453| 2| { 1454| 2| if (current_has_delegation && ------------------ | Branch (1454:9): [True: 0, False: 2] ------------------ 1455| 0| is_glue(¤t_list, new_name)) ------------------ | Branch (1455:9): [True: 0, False: 0] ------------------ 1456| 0| { 1457| 0| rdcount_save = rdcount; 1458| 0| rdlcount_save = rdlcount; 1459| 0| target_save = target; 1460| 0| ictx->glue = new_name; 1461| 0| ictx->glue_in_use = new_in_use; 1462| 0| ictx->in_use[ictx->glue_in_use] = true; 1463| 2| } else { 1464| 2| result = commit(callbacks, lctx, 1465| 2| ¤t_list, 1466| 2| ictx->current, source, 1467| 2| ictx->current_line); 1468| 2| if (MANYERRS(lctx, result)) { ------------------ | | 311| 2| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 2] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1469| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1470| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1470:17): [True: 0, False: 2] ------------------ 1471| 0| goto insist_and_cleanup; 1472| 0| } 1473| 2| rdcount = 0; 1474| 2| rdlcount = 0; 1475| 2| if (ictx->current_in_use != -1) { ------------------ | Branch (1475:10): [True: 0, False: 2] ------------------ 1476| 0| ictx->in_use 1477| 0| [ictx->current_in_use] = 1478| 0| false; 1479| 0| } 1480| 2| ictx->current_in_use = new_in_use; 1481| 2| ictx->in_use[ictx->current_in_use] = 1482| 2| true; 1483| 2| ictx->current = new_name; 1484| 2| current_has_delegation = false; 1485| 2| isc_buffer_init(&target, target_mem, 1486| 2| target_size); 1487| 2| } 1488| | /* 1489| | * Check for internal wildcards. 1490| | */ 1491| 2| if ((lctx->options & ------------------ | Branch (1491:9): [True: 0, False: 2] ------------------ 1492| 2| DNS_MASTER_CHECKWILDCARD) != 0) ------------------ | | 50| 2| 0x00000400 /* Check for internal wildcards. \ ------------------ 1493| 0| { 1494| 0| check_wildcard(ictx, source, line, 1495| 0| callbacks); 1496| 0| } 1497| 2| } 1498| 6| if (dns_master_isprimary(lctx) && ------------------ | Branch (1498:8): [True: 6, False: 0] ------------------ 1499| 6| !dns_name_issubdomain(new_name, lctx->top)) ------------------ | | 1544| 6| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (1499:8): [True: 0, False: 6] ------------------ 1500| 0| { 1501| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1502| 0| dns_name_format(new_name, namebuf, ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1503| 0| sizeof(namebuf)); 1504| | /* 1505| | * Ignore out-of-zone data. 1506| | */ 1507| 0| (*callbacks->warn)(callbacks, 1508| 0| "%s:%lu: " 1509| 0| "ignoring out-of-zone data " 1510| 0| "(%s)", 1511| 0| source, line, namebuf); 1512| 0| ictx->drop = true; 1513| 6| } else { 1514| 6| ictx->drop = false; 1515| 6| } 1516| 6| } else { 1517| 0| UNEXPECTED_ERROR("%s:%lu: isc_lex_gettoken() returned " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1518| 0| "unexpected token type (%d)", 1519| 0| source, line, token.type); 1520| 0| result = ISC_R_UNEXPECTED; 1521| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1522| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1523| 0| LOGIT(result); ------------------ | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 331| 0| source, line, isc_result_totext(result)) ------------------ 1524| 0| continue; 1525| 0| } else { 1526| 0| goto insist_and_cleanup; 1527| 0| } 1528| 0| } 1529| | 1530| | /* 1531| | * Find TTL, class and type. Both TTL and class are optional 1532| | * and may occur in any order if they exist. TTL and class 1533| | * come before type which must exist. 1534| | * 1535| | * [] [] 1536| | * [] [] 1537| | */ 1538| | 1539| 6| type = dns_rdatatype_none; ------------------ | | 115| 6|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1540| 6| rdclass = 0; 1541| | 1542| 6| GETTOKEN(lctx->lex, 0, &token, initialws); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| 6| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 6] | | | | ------------------ | | | | 249| 6| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 6] | | | | ------------------ | | | | 250| 6| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 6| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 1543| | 1544| 6| if (initialws) { ------------------ | Branch (1544:7): [True: 0, False: 6] ------------------ 1545| 0| if (token.type == isc_tokentype_eol) { ------------------ | Branch (1545:8): [True: 0, False: 0] ------------------ 1546| 0| read_till_eol = false; 1547| 0| continue; /* blank line */ 1548| 0| } 1549| | 1550| 0| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1550:8): [True: 0, False: 0] ------------------ 1551| 0| WARNUNEXPECTEDEOF(lctx->lex); ------------------ | | 286| 0| do { \ | | 287| 0| if (isc_lex_isfile(lexer)) \ | | ------------------ | | | Branch (287:7): [True: 0, False: 0] | | ------------------ | | 288| 0| (*callbacks->warn)(callbacks, \ | | 289| 0| "%s: file does not end with " \ | | 290| 0| "newline", \ | | 291| 0| source); \ | | 292| 0| } while (0) | | ------------------ | | | Branch (292:11): [Folded, False: 0] | | ------------------ ------------------ 1552| 0| read_till_eol = false; 1553| 0| isc_lex_ungettoken(lctx->lex, &token); 1554| 0| continue; 1555| 0| } 1556| | 1557| 0| if (ictx->current == NULL) { ------------------ | Branch (1557:8): [True: 0, False: 0] ------------------ 1558| 0| (*callbacks->error)(callbacks, 1559| 0| "%s:%lu: no current owner " 1560| 0| "name", 1561| 0| source, line); 1562| 0| result = DNS_R_NOOWNER; 1563| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1564| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1565| 0| read_till_eol = true; 1566| 0| continue; 1567| 0| } else { 1568| 0| goto insist_and_cleanup; 1569| 0| } 1570| 0| } 1571| | 1572| 0| if (ictx->origin_changed) { ------------------ | Branch (1572:8): [True: 0, False: 0] ------------------ 1573| 0| char cbuf[DNS_NAME_FORMATSIZE]; 1574| 0| char obuf[DNS_NAME_FORMATSIZE]; 1575| 0| dns_name_format(ictx->current, cbuf, ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1576| 0| sizeof(cbuf)); 1577| 0| dns_name_format(ictx->origin, obuf, ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1578| 0| sizeof(obuf)); 1579| 0| (*callbacks->warn)(callbacks, 1580| 0| "%s:%lu: record with " 1581| 0| "inherited " 1582| 0| "owner (%s) immediately " 1583| 0| "after " 1584| 0| "$ORIGIN (%s)", 1585| 0| source, line, cbuf, obuf); 1586| 0| } 1587| 0| } 1588| | 1589| 6| ictx->origin_changed = false; 1590| | 1591| 6| if (dns_rdataclass_fromtext(&rdclass, ------------------ | Branch (1591:7): [True: 0, False: 6] ------------------ 1592| 6| &token.value.as_textregion) == 1593| 6| ISC_R_SUCCESS) 1594| 0| { 1595| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1596| 0| } 1597| | 1598| 6| explicit_ttl = false; 1599| 6| result = dns_ttl_fromtext(&token.value.as_textregion, 1600| 6| &lctx->ttl); 1601| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1601:7): [True: 6, False: 0] ------------------ 1602| 6| limit_ttl(callbacks, source, line, &lctx->ttl); 1603| 6| explicit_ttl = true; 1604| 6| lctx->ttl_known = true; 1605| 6| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| 6| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 6] | | | | ------------------ | | | | 249| 6| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 6] | | | | ------------------ | | | | 250| 6| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 6| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 1606| 6| } 1607| | 1608| 6| if (token.type != isc_tokentype_string) { ------------------ | Branch (1608:7): [True: 0, False: 6] ------------------ 1609| 0| UNEXPECTED_ERROR("isc_lex_gettoken() returned " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1610| 0| "unexpected token type"); 1611| 0| result = ISC_R_UNEXPECTED; 1612| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1613| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1614| 0| read_till_eol = true; 1615| 0| continue; 1616| 0| } else { 1617| 0| goto insist_and_cleanup; 1618| 0| } 1619| 0| } 1620| | 1621| 6| if (rdclass == 0 && ------------------ | Branch (1621:7): [True: 6, False: 0] ------------------ 1622| 6| dns_rdataclass_fromtext(&rdclass, ------------------ | Branch (1622:7): [True: 6, False: 0] ------------------ 1623| 6| &token.value.as_textregion) == 1624| 6| ISC_R_SUCCESS) 1625| 6| { 1626| 6| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| 6| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 6] | | | | ------------------ | | | | 249| 6| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 6] | | | | ------------------ | | | | 250| 6| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 6| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 1627| 6| } 1628| | 1629| 6| if (token.type != isc_tokentype_string) { ------------------ | Branch (1629:7): [True: 0, False: 6] ------------------ 1630| 0| UNEXPECTED_ERROR("isc_lex_gettoken() returned " ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1631| 0| "unexpected token type"); 1632| 0| result = ISC_R_UNEXPECTED; 1633| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1634| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1635| 0| read_till_eol = true; 1636| 0| continue; 1637| 0| } else { 1638| 0| goto insist_and_cleanup; 1639| 0| } 1640| 0| } 1641| | 1642| 6| result = dns_rdatatype_fromtext(&type, 1643| 6| &token.value.as_textregion); 1644| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1644:7): [True: 0, False: 6] ------------------ 1645| 0| (*callbacks->warn)( 1646| 0| callbacks, "%s:%lu: unknown RR type '%.*s'", 1647| 0| source, line, token.value.as_textregion.length, 1648| 0| token.value.as_textregion.base); 1649| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1650| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1651| 0| read_till_eol = true; 1652| 0| continue; 1653| 0| } else { 1654| 0| goto insist_and_cleanup; 1655| 0| } 1656| 0| } 1657| | 1658| | /* 1659| | * If the class specified does not match the zone's class 1660| | * print out a error message and exit. 1661| | */ 1662| 6| if (rdclass != 0 && rdclass != lctx->zclass) { ------------------ | Branch (1662:7): [True: 6, False: 0] | Branch (1662:23): [True: 0, False: 6] ------------------ 1663| 0| bad_class: 1664| | 1665| 0| dns_rdataclass_format(rdclass, classname1, 1666| 0| sizeof(classname1)); 1667| 0| dns_rdataclass_format(lctx->zclass, classname2, 1668| 0| sizeof(classname2)); 1669| 0| (*callbacks->error)(callbacks, 1670| 0| "%s:%lu: class '%s' != " 1671| 0| "zone class '%s'", 1672| 0| source, line, classname1, 1673| 0| classname2); 1674| 0| result = DNS_R_BADCLASS; 1675| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1676| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1677| 0| read_till_eol = true; 1678| 0| continue; 1679| 0| } else { 1680| 0| goto insist_and_cleanup; 1681| 0| } 1682| 0| } 1683| | 1684| 6| if (type == dns_rdatatype_ns && ictx->glue == NULL) { ------------------ | | 117| 12|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (1684:7): [True: 2, False: 4] | Branch (1684:35): [True: 2, False: 0] ------------------ 1685| 2| current_has_delegation = true; 1686| 2| } 1687| | 1688| | /* 1689| | * RFC1123: MD and MF are not allowed to be loaded from 1690| | * master files. 1691| | */ 1692| 6| if (dns_master_isprimary(lctx) && ------------------ | Branch (1692:7): [True: 6, False: 0] ------------------ 1693| 6| (type == dns_rdatatype_md || type == dns_rdatatype_mf)) ------------------ | | 118| 12|#define dns_rdatatype_md ((dns_rdatatype_t)dns_rdatatype_md) ------------------ (type == dns_rdatatype_md || type == dns_rdatatype_mf)) ------------------ | | 119| 6|#define dns_rdatatype_mf ((dns_rdatatype_t)dns_rdatatype_mf) ------------------ | Branch (1693:8): [True: 0, False: 6] | Branch (1693:36): [True: 0, False: 6] ------------------ 1694| 0| { 1695| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1696| | 1697| 0| result = DNS_R_OBSOLETE; 1698| | 1699| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1700| 0| (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s", 1701| 0| source, line, "type", typebuf, 1702| 0| isc_result_totext(result)); 1703| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1704| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1705| 0| } else { 1706| 0| goto insist_and_cleanup; 1707| 0| } 1708| 0| } 1709| | 1710| | /* 1711| | * RFC2930: TKEY and TSIG are not allowed to be loaded 1712| | * from master files. 1713| | */ 1714| 6| if (dns_master_isprimary(lctx) && dns_rdatatype_ismeta(type)) { ------------------ | Branch (1714:7): [True: 6, False: 0] | Branch (1714:37): [True: 0, False: 6] ------------------ 1715| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1716| | 1717| 0| result = DNS_R_METATYPE; 1718| | 1719| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1720| 0| (*callbacks->error)(callbacks, "%s:%lu: %s '%s': %s", 1721| 0| source, line, "type", typebuf, 1722| 0| isc_result_totext(result)); 1723| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1724| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1725| 0| } else { 1726| 0| goto insist_and_cleanup; 1727| 0| } 1728| 0| } 1729| | 1730| | /* 1731| | * Find a rdata structure. 1732| | */ 1733| 6| if (rdcount == rdata_size) { ------------------ | Branch (1733:7): [True: 2, False: 4] ------------------ 1734| 2| new_rdata = grow_rdata(rdata_size + RDSZ, rdata, ------------------ | | 61| 2|#define RDSZ 512 ------------------ 1735| 2| rdata_size, ¤t_list, 1736| 2| &glue_list, mctx); 1737| 2| rdata_size += RDSZ; ------------------ | | 61| 2|#define RDSZ 512 ------------------ 1738| 2| rdata = new_rdata; 1739| 2| } 1740| | 1741| | /* 1742| | * Peek at the NS record. 1743| | */ 1744| 6| if (type == dns_rdatatype_ns && ------------------ | | 117| 12|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (1744:7): [True: 2, False: 4] ------------------ 1745| 2| lctx->zclass == dns_rdataclass_in && ------------------ | | 24| 8|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (1745:7): [True: 2, False: 0] ------------------ 1746| 2| (lctx->options & DNS_MASTER_CHECKNS) != 0) ------------------ | | 38| 2| 0x00000040 /*%< \ ------------------ | Branch (1746:7): [True: 0, False: 2] ------------------ 1747| 0| { 1748| 0| GETTOKEN(lctx->lex, 0, &token, false); ------------------ | | 262| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 223| 0| COMMITALL; \ | | | | ------------------ | | | | | | 265| 0| do { \ | | | | | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | | | | | 267| 0| source, ictx->current_line); \ | | | | | | 268| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 269| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (270:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 271| 0| goto insist_and_cleanup; \ | | | | | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | | | | | 273| 0| source, ictx->glue_line); \ | | | | | | 274| 0| if (MANYERRS(lctx, result)) { \ | | | | | | ------------------ | | | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | | | ------------------ | | | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 312| 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] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 275| 0| SETRESULT(lctx, result); \ | | | | | | ------------------ | | | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | | | 317| 0| } | | | | | | ------------------ | | | | | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | | | | | ------------------ | | | | | | | Branch (276:14): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 277| 0| goto insist_and_cleanup; \ | | | | | | 278| 0| rdcount = 0; \ | | | | | | 279| 0| rdlcount = 0; \ | | | | | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | | | | | 281| 0| rdcount_save = rdcount; \ | | | | | | 282| 0| rdlcount_save = rdlcount; \ | | | | | | 283| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (283: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)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 241| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 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| (token)->type == isc_tokentype_unknown || \ | | | | ------------------ | | | | | Branch (248:7): [True: 0, False: 0] | | | | ------------------ | | | | 249| 0| isc_token_hasnul(token)) \ | | | | ------------------ | | | | | Branch (249:7): [True: 0, False: 0] | | | | ------------------ | | | | 250| 0| { \ | | | | 251| 0| result = DNS_R_SYNTAX; \ | | | | 252| 0| if (MANYERRS(lctx, result)) { \ | | | | ------------------ | | | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | | | ------------------ | | | | | | | Branch (311:3): [True: 0, False: 0] | | | | | | | Branch (311:32): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 312| 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] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 253| 0| SETRESULT(lctx, result); \ | | | | ------------------ | | | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | | | ------------------ | | | | | | | Branch (315:6): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 316| 0| (lctx)->result = r; \ | | | | | | 317| 0| } | | | | ------------------ | | | | 254| 0| LOGIT(result); \ | | | | ------------------ | | | | | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | | | | | 331| 0| source, line, isc_result_totext(result)) | | | | ------------------ | | | | 255| 0| read_till_eol = true; \ | | | | 256| 0| goto next_line; \ | | | | 257| 0| } else \ | | | | 258| 0| goto log_and_cleanup; \ | | | | 259| 0| } \ | | | | 260| 0| } while (0) | | | | ------------------ | | | | | Branch (260:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1749| 0| result = check_ns(lctx, &token, source, line); 1750| 0| isc_lex_ungettoken(lctx->lex, &token); 1751| 0| if ((lctx->options & DNS_MASTER_FATALNS) != 0) { ------------------ | | 43| 0| 0x00000080 /*%< \ ------------------ | Branch (1751:8): [True: 0, False: 0] ------------------ 1752| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1753| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1754| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1754:16): [True: 0, False: 0] ------------------ 1755| 0| goto insist_and_cleanup; 1756| 0| } 1757| 0| } 1758| 0| } 1759| | 1760| | /* 1761| | * Check owner name. 1762| | */ 1763| 6| options &= ~DNS_RDATA_CHECKREVERSE; ------------------ | | 214| 6|#define DNS_RDATA_CHECKREVERSE DNS_NAME_CHECKREVERSE | | ------------------ | | | | 169| 6|#define DNS_NAME_CHECKREVERSE 0x0008 /*%< Used by rdata. */ | | ------------------ ------------------ 1764| 6| if ((lctx->options & DNS_MASTER_CHECKNAMES) != 0) { ------------------ | | 47| 6|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ | Branch (1764:7): [True: 0, False: 6] ------------------ 1765| 0| bool ok; 1766| 0| dns_name_t *name; 1767| | 1768| 0| name = (ictx->glue != NULL) ? ictx->glue ------------------ | Branch (1768:11): [True: 0, False: 0] ------------------ 1769| 0| : ictx->current; 1770| 0| ok = dns_rdata_checkowner(name, lctx->zclass, type, ------------------ | | 836| 0| dns__rdata_checkowner(DNS_NAME__RO_ARG(name), rdclass, type, wildcard) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1771| 0| true); 1772| 0| if (!ok) { ------------------ | Branch (1772:8): [True: 0, False: 0] ------------------ 1773| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1774| 0| const char *desc; 1775| 0| dns_name_format(name, namebuf, sizeof(namebuf)); ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1776| 0| result = DNS_R_BADOWNERNAME; 1777| 0| desc = isc_result_totext(result); 1778| 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] | | ------------------ ------------------ 1779| 0| type == dns_rdatatype_nsec3) ------------------ | | 165| 0|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1779:9): [True: 0, False: 0] ------------------ 1780| 0| { 1781| 0| (*callbacks->error)( 1782| 0| callbacks, "%s:%lu: %s: %s", 1783| 0| source, line, namebuf, desc); 1784| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1785| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1786| 0| } else { 1787| 0| goto cleanup; 1788| 0| } 1789| 0| } else { 1790| 0| (*callbacks->warn)( 1791| 0| callbacks, "%s:%lu: %s: %s", 1792| 0| source, line, namebuf, desc); 1793| 0| } 1794| 0| } 1795| 0| if (type == dns_rdatatype_ptr && ------------------ | | 127| 0|#define dns_rdatatype_ptr ((dns_rdatatype_t)dns_rdatatype_ptr) ------------------ | Branch (1795:8): [True: 0, False: 0] ------------------ 1796| 0| !dns_name_isdnssd(name) && ------------------ | Branch (1796:8): [True: 0, False: 0] ------------------ 1797| 0| (dns_name_issubdomain(name, &in_addr_arpa) || ------------------ | | 1544| 0| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1544:2): [True: 0, False: 0] | | ------------------ ------------------ 1798| 0| dns_name_issubdomain(name, &ip6_arpa) || ------------------ | | 1544| 0| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1544:2): [True: 0, False: 0] | | ------------------ ------------------ 1799| 0| dns_name_issubdomain(name, &ip6_int))) ------------------ | | 1544| 0| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1544:2): [True: 0, False: 0] | | ------------------ ------------------ 1800| 0| { 1801| 0| options |= DNS_RDATA_CHECKREVERSE; ------------------ | | 214| 0|#define DNS_RDATA_CHECKREVERSE DNS_NAME_CHECKREVERSE | | ------------------ | | | | 169| 0|#define DNS_NAME_CHECKREVERSE 0x0008 /*%< Used by rdata. */ | | ------------------ ------------------ 1802| 0| } 1803| 0| } 1804| | 1805| | /* 1806| | * Read rdata contents. 1807| | */ 1808| 6| dns_rdata_init(&rdata[rdcount]); 1809| 6| target_ft = target; 1810| 6| result = dns_rdata_fromtext(&rdata[rdcount], lctx->zclass, type, 1811| 6| lctx->lex, ictx->origin, options, 1812| 6| lctx->mctx, &target, callbacks); 1813| 6| if (MANYERRS(lctx, result)) { ------------------ | | 311| 6| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 6] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1814| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1815| 0| continue; 1816| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1816:14): [True: 0, False: 6] ------------------ 1817| 0| goto insist_and_cleanup; 1818| 0| } 1819| | 1820| 6| if (ictx->drop) { ------------------ | Branch (1820:7): [True: 0, False: 6] ------------------ 1821| 0| target = target_ft; 1822| 0| continue; 1823| 0| } 1824| | 1825| 6| if (type == dns_rdatatype_soa && ------------------ | | 121| 12|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (1825:7): [True: 2, False: 4] ------------------ 1826| 2| (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 2|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (1826:7): [True: 2, False: 0] ------------------ 1827| 2| !dns_name_equal(ictx->current, lctx->top)) ------------------ | | 1541| 2| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (1827:7): [True: 0, False: 2] ------------------ 1828| 0| { 1829| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1830| 0| dns_name_format(ictx->current, namebuf, ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1831| 0| sizeof(namebuf)); 1832| 0| (*callbacks->error)(callbacks, 1833| 0| "%s:%lu: SOA " 1834| 0| "record not at top of zone (%s)", 1835| 0| source, line, namebuf); 1836| 0| result = DNS_R_NOTZONETOP; 1837| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1838| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1839| 0| read_till_eol = true; 1840| 0| target = target_ft; 1841| 0| continue; 1842| 0| } else { 1843| 0| goto insist_and_cleanup; 1844| 0| } 1845| 0| } 1846| | 1847| 6| if (type == dns_rdatatype_svcb && ------------------ | | 178| 12|#define dns_rdatatype_svcb ((dns_rdatatype_t)dns_rdatatype_svcb) ------------------ | Branch (1847:7): [True: 0, False: 6] ------------------ 1848| 0| (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 0|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (1848:7): [True: 0, False: 0] ------------------ 1849| 0| (lctx->options & DNS_MASTER_CHECKSVCB) != 0) ------------------ | | 59| 0|#define DNS_MASTER_CHECKSVCB 0x00020000 /*%< Check SVBC records */ ------------------ | Branch (1849:7): [True: 0, False: 0] ------------------ 1850| 0| { 1851| 0| result = dns_rdata_checksvcb(ictx->current, 1852| 0| &rdata[rdcount]); 1853| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1853:8): [True: 0, False: 0] ------------------ 1854| 0| (*callbacks->error)(callbacks, 1855| 0| "%s:%lu: SVCB " 1856| 0| "record not valid: %s", 1857| 0| source, line, 1858| 0| isc_result_totext(result)); 1859| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1860| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1861| 0| target = target_ft; 1862| 0| continue; 1863| 0| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1863:16): [True: 0, False: 0] ------------------ 1864| 0| goto insist_and_cleanup; 1865| 0| } 1866| 0| } 1867| 0| } 1868| | 1869| 6| if (dns_rdatatype_atparent(type) && ------------------ | Branch (1869:7): [True: 0, False: 6] ------------------ 1870| 0| dns_master_isprimary(lctx) && ------------------ | Branch (1870:7): [True: 0, False: 0] ------------------ 1871| 0| dns_name_equal(ictx->current, lctx->top)) ------------------ | | 1541| 0| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1541:2): [True: 0, False: 0] | | ------------------ ------------------ 1872| 0| { 1873| 0| char namebuf[DNS_NAME_FORMATSIZE]; 1874| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 1875| | 1876| 0| dns_name_format(ictx->current, namebuf, ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1877| 0| sizeof(namebuf)); 1878| 0| dns_rdatatype_format(type, typebuf, sizeof(typebuf)); 1879| 0| (*callbacks->error)( 1880| 0| callbacks, 1881| 0| "%s:%lu: %s record at top of zone (%s)", source, 1882| 0| line, typebuf, namebuf); 1883| 0| result = DNS_R_ATZONETOP; 1884| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1885| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1886| 0| target = target_ft; 1887| 0| continue; 1888| 0| } else { 1889| 0| goto insist_and_cleanup; 1890| 0| } 1891| 0| } 1892| | 1893| 6| if (dns_rdatatype_issig(type)) { ------------------ | Branch (1893:7): [True: 0, False: 6] ------------------ 1894| 0| covers = dns_rdata_covers(&rdata[rdcount]); 1895| 6| } else { 1896| 6| covers = dns_rdatatype_none; ------------------ | | 115| 6|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1897| 6| } 1898| | 1899| 6| if (!lctx->ttl_known && !lctx->default_ttl_known) { ------------------ | Branch (1899:7): [True: 0, False: 6] | Branch (1899:27): [True: 0, False: 0] ------------------ 1900| 0| if (type == dns_rdatatype_soa) { ------------------ | | 121| 0|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (1900:8): [True: 0, False: 0] ------------------ 1901| 0| (*callbacks->warn)(callbacks, 1902| 0| "%s:%lu: no TTL specified; " 1903| 0| "using SOA MINTTL instead", 1904| 0| source, line); 1905| 0| lctx->ttl = dns_soa_getminimum(&rdata[rdcount]); 1906| 0| limit_ttl(callbacks, source, line, &lctx->ttl); 1907| 0| lctx->default_ttl = lctx->ttl; 1908| 0| lctx->default_ttl_known = true; 1909| 0| } else if ((lctx->options & DNS_MASTER_HINT) != 0) { ------------------ | | 35| 0|#define DNS_MASTER_HINT 0x00000010 /*%< Loading a hint master file. */ ------------------ | Branch (1909:15): [True: 0, False: 0] ------------------ 1910| | /* 1911| | * Zero TTL's are fine for hints. 1912| | */ 1913| 0| lctx->ttl = 0; 1914| 0| lctx->default_ttl = lctx->ttl; 1915| 0| lctx->default_ttl_known = true; 1916| 0| } else { 1917| 0| (*callbacks->warn)(callbacks, 1918| 0| "%s:%lu: no TTL specified; " 1919| 0| "zone rejected", 1920| 0| source, line); 1921| 0| result = DNS_R_NOTTL; 1922| 0| if (MANYERRS(lctx, result)) { ------------------ | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 0] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 1923| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 1924| 0| lctx->ttl = 0; 1925| 0| } else { 1926| 0| goto insist_and_cleanup; 1927| 0| } 1928| 0| } 1929| 6| } else if (!explicit_ttl && lctx->default_ttl_known) { ------------------ | Branch (1929:14): [True: 0, False: 6] | Branch (1929:31): [True: 0, False: 0] ------------------ 1930| 0| lctx->ttl = lctx->default_ttl; 1931| 6| } else if (!explicit_ttl && lctx->warn_1035) { ------------------ | Branch (1931:14): [True: 0, False: 6] | Branch (1931:31): [True: 0, False: 0] ------------------ 1932| 0| (*callbacks->warn)(callbacks, 1933| 0| "%s:%lu: " 1934| 0| "using RFC1035 TTL semantics", 1935| 0| source, line); 1936| 0| lctx->warn_1035 = false; 1937| 0| } 1938| | 1939| 6| if (type == dns_rdatatype_rrsig && lctx->warn_sigexpired) { ------------------ | | 161| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1939:7): [True: 0, False: 6] | Branch (1939:38): [True: 0, False: 0] ------------------ 1940| 0| dns_rdata_rrsig_t sig; 1941| 0| result = dns_rdata_tostruct(&rdata[rdcount], &sig); 1942| 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] | | ------------------ ------------------ 1943| 0| if (isc_serial_lt(sig.timeexpire, lctx->now)) { ------------------ | Branch (1943:8): [True: 0, False: 0] ------------------ 1944| 0| (*callbacks->warn)(callbacks, 1945| 0| "%s:%lu: " 1946| 0| "signature has expired", 1947| 0| source, line); 1948| 0| lctx->warn_sigexpired = false; 1949| 0| } 1950| 0| } 1951| | 1952| 6| if ((lctx->options & DNS_MASTER_AGETTL) != 0) { ------------------ | | 30| 6|#define DNS_MASTER_AGETTL 0x00000001 /*%< Age the ttl based on $DATE. */ ------------------ | Branch (1952:7): [True: 0, False: 6] ------------------ 1953| | /* 1954| | * Adjust the TTL for $DATE. If the RR has 1955| | * already expired, set its TTL to 0. This 1956| | * should be okay even if the TTL stretching 1957| | * feature is not in effect, because it will 1958| | * just be quickly expired by the cache, and the 1959| | * way this was written before the patch it 1960| | * could potentially add 0 TTLs anyway. 1961| | */ 1962| 0| if (lctx->ttl < ttl_offset) { ------------------ | Branch (1962:8): [True: 0, False: 0] ------------------ 1963| 0| lctx->ttl = 0; 1964| 0| } else { 1965| 0| lctx->ttl -= ttl_offset; 1966| 0| } 1967| 0| } 1968| | 1969| | /* 1970| | * Find type in rdatalist. 1971| | * If it does not exist create new one and prepend to list 1972| | * as this will minimise list traversal. 1973| | */ 1974| 6| if (ictx->glue != NULL) { ------------------ | Branch (1974:7): [True: 0, False: 6] ------------------ 1975| 0| this = ISC_LIST_HEAD(glue_list); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1976| 6| } else { 1977| 6| this = ISC_LIST_HEAD(current_list); ------------------ | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1978| 6| } 1979| | 1980| 12| while (this != NULL) { ------------------ | Branch (1980:10): [True: 6, False: 6] ------------------ 1981| 6| if (this->type == type && this->covers == covers) { ------------------ | Branch (1981:8): [True: 0, False: 6] | Branch (1981:30): [True: 0, False: 0] ------------------ 1982| 0| break; 1983| 0| } 1984| 6| this = ISC_LIST_NEXT(this, link); ------------------ | | 140| 6|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 1985| 6| } 1986| | 1987| 6| if (this == NULL) { ------------------ | Branch (1987:7): [True: 6, False: 0] ------------------ 1988| 6| if (rdlcount == rdatalist_size) { ------------------ | Branch (1988:8): [True: 2, False: 4] ------------------ 1989| 2| new_rdatalist = grow_rdatalist( 1990| 2| rdatalist_size + RDLSZ, rdatalist, ------------------ | | 56| 2|#define RDLSZ 32 ------------------ 1991| 2| rdatalist_size, ¤t_list, 1992| 2| &glue_list, mctx); 1993| 2| rdatalist = new_rdatalist; 1994| 2| rdatalist_size += RDLSZ; ------------------ | | 56| 2|#define RDLSZ 32 ------------------ 1995| 2| } 1996| 6| this = &rdatalist[rdlcount++]; 1997| 6| dns_rdatalist_init(this); 1998| 6| this->type = type; 1999| 6| this->covers = covers; 2000| 6| this->rdclass = lctx->zclass; 2001| 6| this->ttl = lctx->ttl; 2002| 6| if (ictx->glue != NULL) { ------------------ | Branch (2002:8): [True: 0, False: 6] ------------------ 2003| 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] | | | | ------------------ | | ------------------ ------------------ 2004| 6| } else { 2005| 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] | | | | ------------------ | | ------------------ ------------------ 2006| 6| link); 2007| 6| } 2008| 6| } else if (this->ttl != lctx->ttl) { ------------------ | Branch (2008:14): [True: 0, False: 0] ------------------ 2009| 0| (*callbacks->warn)(callbacks, 2010| 0| "%s:%lu: " 2011| 0| "TTL set to prior TTL (%lu)", 2012| 0| source, line, this->ttl); 2013| 0| lctx->ttl = this->ttl; 2014| 0| } 2015| | 2016| 6| if ((lctx->options & DNS_MASTER_CHECKTTL) != 0 && ------------------ | | 58| 6|#define DNS_MASTER_CHECKTTL 0x00010000 /*%< Check max-zone-ttl */ ------------------ | Branch (2016:7): [True: 0, False: 6] ------------------ 2017| 0| lctx->ttl > lctx->maxttl) ------------------ | Branch (2017:7): [True: 0, False: 0] ------------------ 2018| 0| { 2019| 0| (callbacks->error)(callbacks, 2020| 0| "dns_master_load: %s:%lu: " 2021| 0| "TTL %d exceeds configured " 2022| 0| "max-zone-ttl %d", 2023| 0| source, line, lctx->ttl, 2024| 0| lctx->maxttl); 2025| 0| result = ISC_R_RANGE; 2026| 0| goto log_and_cleanup; 2027| 0| } 2028| | 2029| 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] | | ------------------ ------------------ 2030| 6| if (ictx->glue != NULL) { ------------------ | Branch (2030:7): [True: 0, False: 6] ------------------ 2031| 0| ictx->glue_line = line; 2032| 6| } else { 2033| 6| ictx->current_line = line; 2034| 6| } 2035| 6| rdcount++; 2036| | 2037| | /* 2038| | * We must have at least 64k as rdlen is 16 bits. 2039| | * If we don't commit everything we have so far. 2040| | */ 2041| 6| if ((target.length - target.used) < MINTSIZ) { ------------------ | | 76| 6|#define MINTSIZ DNS_RDATA_MAXLENGTH | | ------------------ | | | | 183| 6|#define DNS_RDATA_MAXLENGTH 65512U | | ------------------ ------------------ | Branch (2041:7): [True: 0, False: 6] ------------------ 2042| 0| COMMITALL; ------------------ | | 265| 0| do { \ | | 266| 0| result = commit(callbacks, lctx, ¤t_list, ictx->current, \ | | 267| 0| source, ictx->current_line); \ | | 268| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 269| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 270| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (270:14): [True: 0, False: 0] | | ------------------ | | 271| 0| goto insist_and_cleanup; \ | | 272| 0| result = commit(callbacks, lctx, &glue_list, ictx->glue, \ | | 273| 0| source, ictx->glue_line); \ | | 274| 0| if (MANYERRS(lctx, result)) { \ | | ------------------ | | | | 311| 0| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | | | ------------------ | | | | | Branch (311:3): [True: 0, False: 0] | | | | | Branch (311:32): [True: 0, False: 0] | | | | ------------------ | | | | 312| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 275| 0| SETRESULT(lctx, result); \ | | ------------------ | | | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | | | ------------------ | | | | | Branch (315:6): [True: 0, False: 0] | | | | ------------------ | | | | 316| 0| (lctx)->result = r; \ | | | | 317| 0| } | | ------------------ | | 276| 0| } else if (result != ISC_R_SUCCESS) \ | | ------------------ | | | Branch (276:14): [True: 0, False: 0] | | ------------------ | | 277| 0| goto insist_and_cleanup; \ | | 278| 0| rdcount = 0; \ | | 279| 0| rdlcount = 0; \ | | 280| 0| isc_buffer_init(&target, target_mem, target_size); \ | | 281| 0| rdcount_save = rdcount; \ | | 282| 0| rdlcount_save = rdlcount; \ | | 283| 0| } while (0) | | ------------------ | | | Branch (283:11): [Folded, False: 0] | | ------------------ ------------------ 2043| 0| } 2044| 6| next_line:; 2045| 6| } 2046| | 2047| | /* 2048| | * Commit what has not yet been committed. 2049| | */ 2050| 2| result = commit(callbacks, lctx, ¤t_list, ictx->current, source, 2051| 2| ictx->current_line); 2052| 2| if (MANYERRS(lctx, result)) { ------------------ | | 311| 2| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 2] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 2053| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 2054| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2054:13): [True: 0, False: 2] ------------------ 2055| 0| goto insist_and_cleanup; 2056| 0| } 2057| 2| result = commit(callbacks, lctx, &glue_list, ictx->glue, source, 2058| 2| ictx->glue_line); 2059| 2| if (MANYERRS(lctx, result)) { ------------------ | | 311| 2| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 2] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 2060| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 2061| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2061:13): [True: 0, False: 2] ------------------ 2062| 0| goto insist_and_cleanup; 2063| 2| } else if (lctx->result != ISC_R_SUCCESS) { ------------------ | Branch (2063:13): [True: 0, False: 2] ------------------ 2064| 0| result = lctx->result; 2065| 2| } else if (lctx->seen_include) { ------------------ | Branch (2065:13): [True: 0, False: 2] ------------------ 2066| 0| result = DNS_R_SEENINCLUDE; 2067| 0| } 2068| | 2069| 2| goto cleanup; 2070| | 2071| 2|log_and_cleanup: 2072| 0| LOGIT(result); ------------------ | | 330| 0| (*callbacks->error)(callbacks, "%s: %s:%lu: %s", "dns_master_load", \ | | 331| 0| source, line, isc_result_totext(result)) ------------------ 2073| | 2074| 0|insist_and_cleanup: 2075| 0| INSIST(result != ISC_R_SUCCESS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2076| | 2077| 2|cleanup: 2078| | /* commit the database transaction */ 2079| 2| if (callbacks->commit != NULL) { ------------------ | Branch (2079:6): [True: 2, False: 0] ------------------ 2080| 2| callbacks->commit(callbacks->add_private); 2081| 2| } 2082| | 2083| 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] | | ------------------ ------------------ 2084| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2085| 0| } 2086| 2| 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] | | ------------------ ------------------ 2087| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2088| 0| } 2089| 2| if (rdatalist != NULL) { ------------------ | Branch (2089:6): [True: 2, False: 0] ------------------ 2090| 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) | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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| sizeof(*rdatalist)); 2092| 2| } 2093| 2| if (rdata != NULL) { ------------------ | Branch (2093:6): [True: 2, False: 0] ------------------ 2094| 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) | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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] | | ------------------ ------------------ 2095| 2| } 2096| 2| if (target_mem != NULL) { ------------------ | Branch (2096:6): [True: 2, False: 0] ------------------ 2097| 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] | | ------------------ ------------------ 2098| 2| } 2099| 2| if (include_file != NULL) { ------------------ | Branch (2099:6): [True: 0, False: 2] ------------------ 2100| 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] | | ------------------ ------------------ 2101| 0| } 2102| 2| if (range != NULL) { ------------------ | Branch (2102:6): [True: 0, False: 2] ------------------ 2103| 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] | | ------------------ ------------------ 2104| 0| } 2105| 2| if (lhs != NULL) { ------------------ | Branch (2105:6): [True: 0, False: 2] ------------------ 2106| 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] | | ------------------ ------------------ 2107| 0| } 2108| 2| if (gtype != NULL) { ------------------ | Branch (2108:6): [True: 0, False: 2] ------------------ 2109| 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] | | ------------------ ------------------ 2110| 0| } 2111| 2| if (rhs != NULL) { ------------------ | Branch (2111:6): [True: 0, False: 2] ------------------ 2112| 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] | | ------------------ ------------------ 2113| 0| } 2114| | 2115| 2| return result; 2116| 0|} master.c:gettoken: 351| 26| dns_rdatacallbacks_t *callbacks) { 352| 26| isc_result_t result; 353| | 354| 26| options |= ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ISC_LEXOPT_DNSMULTILINE | ------------------ | | 63| 26|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ options |= ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ISC_LEXOPT_DNSMULTILINE | ------------------ | | 64| 26|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ options |= ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ISC_LEXOPT_DNSMULTILINE | ------------------ | | 78| 26|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ 355| 26| ISC_LEXOPT_ESCAPE; ------------------ | | 82| 26|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 356| 26| result = isc_lex_gettoken(lex, options, token); 357| 26| if (result != ISC_R_SUCCESS) { ------------------ | Branch (357:6): [True: 0, False: 26] ------------------ 358| 0| switch (result) { 359| 0| default: ------------------ | Branch (359:3): [True: 0, False: 0] ------------------ 360| 0| (*callbacks->error)(callbacks, 361| 0| "dns_master_load: %s:%lu:" 362| 0| " isc_lex_gettoken() failed: %s", 363| 0| isc_lex_getsourcename(lex), 364| 0| isc_lex_getsourceline(lex), 365| 0| isc_result_totext(result)); 366| 0| return result; 367| 0| } 368| | /*NOTREACHED*/ 369| 0| } 370| 26| if (eol != true) { ------------------ | Branch (370:6): [True: 18, False: 8] ------------------ 371| 18| if (token->type == isc_tokentype_eol || ------------------ | Branch (371:7): [True: 0, False: 18] ------------------ 372| 18| token->type == isc_tokentype_eof) ------------------ | Branch (372:7): [True: 0, False: 18] ------------------ 373| 0| { 374| 0| { 375| 0| unsigned long int line; 376| 0| const char *what; 377| 0| const char *file; 378| 0| file = isc_lex_getsourcename(lex); 379| 0| line = isc_lex_getsourceline(lex); 380| 0| if (token->type == isc_tokentype_eol) { ------------------ | Branch (380:9): [True: 0, False: 0] ------------------ 381| 0| line--; 382| 0| what = "line"; 383| 0| } else { 384| 0| what = "file"; 385| 0| } 386| 0| (*callbacks->error)(callbacks, 387| 0| "dns_master_load: %s:%lu: " 388| 0| "unexpected end of %s", 389| 0| file, line, what); 390| 0| return ISC_R_UNEXPECTEDEND; 391| 0| } 392| 0| } 393| 18| } 394| 26| return ISC_R_SUCCESS; 395| 26|} master.c:commit: 2834| 6| unsigned int line) { 2835| 6| dns_rdataset_t dataset; 2836| 6| isc_result_t result = ISC_R_SUCCESS; 2837| 6| char namebuf[DNS_NAME_FORMATSIZE]; 2838| 6| void (*error)(struct dns_rdatacallbacks *, const char *, ...); 2839| | 2840| 6| error = callbacks->error; 2841| | 2842| 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] | | ------------------ ------------------ 2843| 6| dns_rdataset_init(&dataset); 2844| 6| dns_rdatalist_tordataset(this, &dataset); 2845| 6| dataset.trust = dns_trust_ultimate; ------------------ | | 381| 6|#define dns_trust_ultimate ((dns_trust_t)dns_trust_ultimate) ------------------ 2846| | /* 2847| | * If this is a secure dynamic zone set the re-signing time. 2848| | */ 2849| 6| if (dataset.type == dns_rdatatype_rrsig && ------------------ | | 161| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (2849:7): [True: 0, False: 6] ------------------ 2850| 0| (lctx->options & DNS_MASTER_RESIGN) != 0) ------------------ | | 55| 0|#define DNS_MASTER_RESIGN 0x00002000 ------------------ | Branch (2850:7): [True: 0, False: 0] ------------------ 2851| 0| { 2852| 0| dataset.attributes.resign = true; 2853| 0| dataset.resign = resign_fromlist(this, lctx); 2854| 0| } 2855| 6| result = callbacks->update(callbacks->add_private, owner, 2856| 6| &dataset, 2857| 6| DNS_DIFFOP_ADD DNS__DB_FILELINE); 2858| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2858:7): [True: 0, False: 6] ------------------ 2859| 0| dns_name_format(owner, namebuf, sizeof(namebuf)); ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 2860| 0| if (source != NULL) { ------------------ | Branch (2860:8): [True: 0, False: 0] ------------------ 2861| 0| (*error)(callbacks, "%s: %s:%lu: %s: %s", 2862| 0| "dns_master_load", source, line, 2863| 0| namebuf, isc_result_totext(result)); 2864| 0| } else { 2865| 0| (*error)(callbacks, "%s: %s: %s", 2866| 0| "dns_master_load", namebuf, 2867| 0| isc_result_totext(result)); 2868| 0| } 2869| 0| } 2870| 6| if (MANYERRS(lctx, result)) { ------------------ | | 311| 6| ((result != ISC_R_SUCCESS) && (result != ISC_R_IOERROR) && \ | | ------------------ | | | Branch (311:3): [True: 0, False: 6] | | | Branch (311:32): [True: 0, False: 0] | | ------------------ | | 312| 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] | | | | ------------------ | | ------------------ ------------------ 2871| 0| SETRESULT(lctx, result); ------------------ | | 315| 0| if ((lctx)->result == ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (315:6): [True: 0, False: 0] | | ------------------ | | 316| 0| (lctx)->result = r; \ | | 317| 0| } ------------------ 2872| 6| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (2872:14): [True: 0, False: 6] ------------------ 2873| 0| break; 2874| 0| } 2875| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 6| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 6| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 6| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 6| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 6| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 6] | | | | | | ------------------ | | | | ------------------ | | | | 135| 6| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 6] | | | | ------------------ | | ------------------ ------------------ 2876| 6| } 2877| | 2878| 6| return result; 2879| 6|} master.c:limit_ttl: 898| 6| unsigned int line, uint32_t *ttlp) { 899| 6| if (*ttlp > 0x7fffffffUL) { ------------------ | Branch (899:6): [True: 0, False: 6] ------------------ 900| 0| (callbacks->warn)(callbacks, 901| 0| "%s: %s:%lu: " 902| 0| "$TTL %lu > MAXTTL, " 903| 0| "setting $TTL to 0", 904| 0| "dns_master_load", source, line, *ttlp); 905| 0| *ttlp = 0; 906| 0| } 907| 6|} master.c:find_free_name: 974| 6|find_free_name(dns_incctx_t *incctx) { 975| 6| int i; 976| | 977| 16| for (i = 0; i < (NBUFS - 1); i++) { ------------------ | | 63| 16|#define NBUFS 4 ------------------ | Branch (977:14): [True: 16, False: 0] ------------------ 978| 16| if (!incctx->in_use[i]) { ------------------ | Branch (978:7): [True: 6, False: 10] ------------------ 979| 6| break; 980| 6| } 981| 16| } 982| 6| INSIST(!incctx->in_use[i]); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 983| 6| return i; 984| 6|} master.c:dns_master_isprimary: 343| 18|dns_master_isprimary(dns_loadctx_t *lctx) { 344| 18| return (lctx->options & DNS_MASTER_ZONE) != 0 && ------------------ | | 34| 18|#define DNS_MASTER_ZONE 0x00000008 /*%< Loading a zone master file. */ ------------------ | Branch (344:9): [True: 18, False: 0] ------------------ 345| 18| (lctx->options & DNS_MASTER_SECONDARY) == 0 && ------------------ | | 36| 18|#define DNS_MASTER_SECONDARY 0x00000020 /*%< Secondary master file. */ ------------------ | Branch (345:9): [True: 18, False: 0] ------------------ 346| 18| (lctx->options & DNS_MASTER_KEY) == 0; ------------------ | | 56| 18|#define DNS_MASTER_KEY 0x00004000 /*%< Loading a key zone master file. */ ------------------ | Branch (346:9): [True: 18, False: 0] ------------------ 347| 18|} master.c:grow_rdata: 2749| 2| rdatalist_head_t *current, rdatalist_head_t *glue, isc_mem_t *mctx) { 2750| 2| dns_rdata_t *newlist; 2751| 2| int rdcount = 0; 2752| 2| ISC_LIST(dns_rdata_t) save; ------------------ | | 39| 2| struct { \ | | 40| 2| type *head, *tail; \ | | 41| 2| } ------------------ 2753| | 2754| 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) | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 147| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 2755| | 2756| | /* 2757| | * Copy current relinking. 2758| | */ 2759| 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] | | ------------------ ------------------ 2760| 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] | | ------------------ ------------------ 2761| 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] | | ------------------ ------------------ 2762| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2763| 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] | | ------------------ ------------------ 2764| 0| } 2765| 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] | | ------------------ ------------------ 2766| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2767| 0| INSIST(rdcount < new_len); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2768| 0| newlist[rdcount] = *rdata; 2769| 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] | | ------------------ ------------------ 2770| 0| rdcount++; 2771| 0| } 2772| 0| } 2773| | 2774| | /* 2775| | * Copy glue relinking. 2776| | */ 2777| 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] | | ------------------ ------------------ 2778| 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] | | ------------------ ------------------ 2779| 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] | | ------------------ ------------------ 2780| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2781| 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] | | ------------------ ------------------ 2782| 0| } 2783| 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] | | ------------------ ------------------ 2784| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2785| 0| INSIST(rdcount < new_len); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2786| 0| newlist[rdcount] = *rdata; 2787| 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] | | ------------------ ------------------ 2788| 0| rdcount++; 2789| 0| } 2790| 0| } 2791| 2| INSIST(rdcount == old_len || rdcount == 0); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 2, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2792| 2| if (oldlist != NULL) { ------------------ | Branch (2792:6): [True: 0, False: 2] ------------------ 2793| | 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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] | | ------------------ ------------------ 2794| 0| } 2795| 2| return newlist; 2796| 2|} master.c:grow_rdatalist: 2703| 2| isc_mem_t *mctx) { 2704| 2| dns_rdatalist_t *newlist; 2705| 2| int rdlcount = 0; 2706| 2| ISC_LIST(dns_rdatalist_t) save; ------------------ | | 39| 2| struct { \ | | 40| 2| type *head, *tail; \ | | 41| 2| } ------------------ 2707| | 2708| 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) | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 147| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 2709| | 2710| 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] | | ------------------ ------------------ 2711| 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] | | ------------------ ------------------ 2712| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2713| 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] | | ------------------ ------------------ 2714| 0| } 2715| 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] | | ------------------ ------------------ 2716| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2717| 0| INSIST(rdlcount < new_len); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2718| 0| newlist[rdlcount] = *this; 2719| 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] | | ------------------ ------------------ 2720| 0| rdlcount++; 2721| 0| } 2722| | 2723| 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] | | ------------------ ------------------ 2724| 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] | | ------------------ ------------------ 2725| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2726| 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] | | ------------------ ------------------ 2727| 0| } 2728| 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] | | ------------------ ------------------ 2729| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 2730| 0| INSIST(rdlcount < new_len); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2731| 0| newlist[rdlcount] = *this; 2732| 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] | | ------------------ ------------------ 2733| 0| rdlcount++; 2734| 0| } 2735| | 2736| 2| INSIST(rdlcount == old_len); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2737| 2| if (oldlist != NULL) { ------------------ | Branch (2737:6): [True: 0, False: 2] ------------------ 2738| | 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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] | | ------------------ ------------------ 2739| 0| } 2740| 2| return newlist; 2741| 2|} dns_message_create: 709| 1.57k| dns_message_t **msgp) { 710| 1.57k| REQUIRE(mctx != NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 711| 1.57k| REQUIRE(msgp != NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 712| 1.57k| REQUIRE(*msgp == NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 713| 1.57k| REQUIRE(intent == DNS_MESSAGE_INTENTPARSE || ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 714| 1.57k| intent == DNS_MESSAGE_INTENTRENDER); 715| 1.57k| REQUIRE((namepool != NULL && rdspool != NULL) || ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 7.88k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 1.57k] | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 716| 1.57k| (namepool == NULL && rdspool == NULL)); 717| | 718| 1.57k| dns_message_t *msg = isc_mem_get(mctx, sizeof(dns_message_t)); ------------------ | | 144| 1.57k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 719| 1.57k| *msg = (dns_message_t){ 720| 1.57k| .from_to_wire = intent, 721| 1.57k| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 1.57k|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 722| 1.57k| .scratchpad = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.57k| { \ | | 22| 1.57k| .head = NULL, \ | | 23| 1.57k| .tail = NULL, \ | | 24| 1.57k| } ------------------ 723| 1.57k| .cleanup = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.57k| { \ | | 22| 1.57k| .head = NULL, \ | | 23| 1.57k| .tail = NULL, \ | | 24| 1.57k| } ------------------ 724| 1.57k| .rdatas = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.57k| { \ | | 22| 1.57k| .head = NULL, \ | | 23| 1.57k| .tail = NULL, \ | | 24| 1.57k| } ------------------ 725| 1.57k| .rdatalists = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.57k| { \ | | 22| 1.57k| .head = NULL, \ | | 23| 1.57k| .tail = NULL, \ | | 24| 1.57k| } ------------------ 726| 1.57k| .freerdata = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.57k| { \ | | 22| 1.57k| .head = NULL, \ | | 23| 1.57k| .tail = NULL, \ | | 24| 1.57k| } ------------------ 727| 1.57k| .freerdatalist = ISC_LIST_INITIALIZER, ------------------ | | 21| 1.57k| { \ | | 22| 1.57k| .head = NULL, \ | | 23| 1.57k| .tail = NULL, \ | | 24| 1.57k| } ------------------ 728| 1.57k| .magic = DNS_MESSAGE_MAGIC, ------------------ | | 147| 1.57k|#define DNS_MESSAGE_MAGIC ISC_MAGIC('M', 'S', 'G', '@') | | ------------------ | | | | 31| 1.57k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 729| 1.57k| .namepool = namepool, 730| 1.57k| .rdspool = rdspool, 731| 1.57k| .free_pools = (namepool == NULL && rdspool == NULL), ------------------ | Branch (731:18): [True: 1.57k, False: 0] | Branch (731:38): [True: 1.57k, False: 0] ------------------ 732| 1.57k| }; 733| | 734| 1.57k| isc_mem_attach(mctx, &msg->mctx); 735| | 736| 1.57k| if (msg->free_pools) { ------------------ | Branch (736:6): [True: 1.57k, False: 0] ------------------ 737| 1.57k| dns_message_createpools(mctx, &msg->namepool, &msg->rdspool); 738| 1.57k| } 739| | 740| 1.57k| msginit(msg); 741| | 742| 7.88k| for (size_t i = 0; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (742:21): [True: 6.30k, False: 1.57k] ------------------ 743| 6.30k| ISC_LIST_INIT(msg->sections[i]); ------------------ | | 43| 6.30k| do { \ | | 44| 6.30k| (list).head = NULL; \ | | 45| 6.30k| (list).tail = NULL; \ | | 46| 6.30k| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 6.30k] | | ------------------ ------------------ 744| 6.30k| } 745| | 746| 1.57k| isc_buffer_t *dynbuf = NULL; 747| 1.57k| isc_buffer_allocate(mctx, &dynbuf, SCRATCHPAD_SIZE); ------------------ | | 125| 1.57k|#define SCRATCHPAD_SIZE 1232 ------------------ 748| 1.57k| ISC_LIST_APPEND(msg->scratchpad, dynbuf, link); ------------------ | | 100| 1.57k| do { \ | | 101| 1.57k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.57k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.57k| do { \ | | | | 89| 1.57k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.57k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.57k| } else { \ | | | | 92| 1.57k| (list).head = (elt); \ | | | | 93| 1.57k| } \ | | | | 94| 1.57k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.57k| (elt)->link.next = NULL; \ | | | | 96| 1.57k| (list).tail = (elt); \ | | | | 97| 1.57k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.57k] | | | | ------------------ | | ------------------ | | 103| 1.57k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.57k] | | ------------------ ------------------ 749| | 750| 1.57k| *msgp = msg; 751| 1.57k|} dns_message_parse: 1566| 1.57k| unsigned int options) { 1567| 1.57k| isc_region_t r; 1568| 1.57k| isc_result_t result; 1569| 1.57k| uint16_t tmpflags; 1570| 1.57k| isc_buffer_t origsource; 1571| 1.57k| bool seen_problem; 1572| 1.57k| bool ignore_tc; 1573| | 1574| 1.57k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1575| 1.57k| REQUIRE(source != NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1576| 1.57k| REQUIRE(msg->from_to_wire == DNS_MESSAGE_INTENTPARSE); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1577| | 1578| 1.57k| seen_problem = false; 1579| 1.57k| ignore_tc = ((options & DNS_MESSAGEPARSE_IGNORETRUNCATION) != 0); ------------------ | | 209| 1.57k| 0x0008 /*%< truncation errors are \ ------------------ 1580| | 1581| 1.57k| origsource = *source; 1582| | 1583| 1.57k| msg->header_ok = 0; 1584| 1.57k| msg->question_ok = 0; 1585| | 1586| 1.57k| if ((options & DNS_MESSAGEPARSE_CLONEBUFFER) == 0) { ------------------ | | 206| 1.57k| 0x0004 /*%< save a copy of the \ ------------------ | Branch (1586:6): [True: 1.57k, False: 0] ------------------ 1587| 1.57k| isc_buffer_usedregion(&origsource, &msg->saved); 1588| 1.57k| } else { 1589| 0| msg->saved.length = isc_buffer_usedlength(&origsource); ------------------ | | 158| 0|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1590| 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) ------------------ 1591| 0| memmove(msg->saved.base, isc_buffer_base(&origsource), ------------------ | | 144| 0|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 1592| 0| msg->saved.length); 1593| 0| msg->free_saved = 1; 1594| 0| } 1595| | 1596| 1.57k| isc_buffer_remainingregion(source, &r); 1597| 1.57k| if (r.length < DNS_MESSAGE_HEADERLEN) { ------------------ | | 145| 1.57k|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ | Branch (1597:6): [True: 0, False: 1.57k] ------------------ 1598| 0| return ISC_R_UNEXPECTEDEND; 1599| 0| } 1600| | 1601| 1.57k| msg->id = isc_buffer_getuint16(source); 1602| 1.57k| tmpflags = isc_buffer_getuint16(source); 1603| 1.57k| msg->opcode = ((tmpflags & DNS_MESSAGE_OPCODE_MASK) >> ------------------ | | 86| 1.57k|#define DNS_MESSAGE_OPCODE_MASK 0x7800U ------------------ 1604| 1.57k| DNS_MESSAGE_OPCODE_SHIFT); ------------------ | | 87| 1.57k|#define DNS_MESSAGE_OPCODE_SHIFT 11 ------------------ 1605| 1.57k| msg->rcode = (dns_rcode_t)(tmpflags & DNS_MESSAGE_RCODE_MASK); ------------------ | | 88| 1.57k|#define DNS_MESSAGE_RCODE_MASK 0x000fU ------------------ 1606| 1.57k| msg->flags = (tmpflags & DNS_MESSAGE_FLAG_MASK); ------------------ | | 89| 1.57k|#define DNS_MESSAGE_FLAG_MASK 0x8ff0U ------------------ 1607| 1.57k| msg->counts[DNS_SECTION_QUESTION] = isc_buffer_getuint16(source); 1608| 1.57k| msg->counts[DNS_SECTION_ANSWER] = isc_buffer_getuint16(source); 1609| 1.57k| msg->counts[DNS_SECTION_AUTHORITY] = isc_buffer_getuint16(source); 1610| 1.57k| msg->counts[DNS_SECTION_ADDITIONAL] = isc_buffer_getuint16(source); 1611| | 1612| 1.57k| msg->header_ok = 1; 1613| 1.57k| msg->state = DNS_SECTION_QUESTION; 1614| | 1615| 1.57k| bool strict_parse = ((options & DNS_MESSAGEPARSE_BESTEFFORT) == 0); ------------------ | | 202| 1.57k| 0x0002 /*%< return a message if a \ ------------------ 1616| 1.57k| isc_result_t early_check_ret = early_sanity_check(msg); 1617| 1.57k| if (strict_parse && (early_check_ret != ISC_R_SUCCESS)) { ------------------ | Branch (1617:6): [True: 1.57k, False: 0] | Branch (1617:22): [True: 6, False: 1.57k] ------------------ 1618| 6| return early_check_ret; 1619| 6| } 1620| | 1621| 1.57k| result = getquestions(source, msg, options); 1622| | 1623| 1.57k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1623:6): [True: 0, False: 1.57k] | Branch (1623:39): [True: 0, False: 0] ------------------ 1624| 0| goto truncated; 1625| 0| } 1626| 1.57k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1626:6): [True: 0, False: 1.57k] ------------------ 1627| 0| seen_problem = true; 1628| 0| result = ISC_R_SUCCESS; 1629| 0| } 1630| 1.57k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1630:6): [True: 0, False: 1.57k] ------------------ 1631| 0| return result; 1632| 0| } 1633| 1.57k| msg->question_ok = 1; 1634| | 1635| 1.57k| result = getsection(source, msg, DNS_SECTION_ANSWER, options); 1636| 1.57k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1636:6): [True: 0, False: 1.57k] | Branch (1636:39): [True: 0, False: 0] ------------------ 1637| 0| goto truncated; 1638| 0| } 1639| 1.57k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1639:6): [True: 0, False: 1.57k] ------------------ 1640| 0| seen_problem = true; 1641| 0| result = ISC_R_SUCCESS; 1642| 0| } 1643| 1.57k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1643:6): [True: 0, False: 1.57k] ------------------ 1644| 0| return result; 1645| 0| } 1646| | 1647| 1.57k| result = getsection(source, msg, DNS_SECTION_AUTHORITY, options); 1648| 1.57k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1648:6): [True: 0, False: 1.57k] | Branch (1648:39): [True: 0, False: 0] ------------------ 1649| 0| goto truncated; 1650| 0| } 1651| 1.57k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1651:6): [True: 0, False: 1.57k] ------------------ 1652| 0| seen_problem = true; 1653| 0| result = ISC_R_SUCCESS; 1654| 0| } 1655| 1.57k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1655:6): [True: 0, False: 1.57k] ------------------ 1656| 0| return result; 1657| 0| } 1658| | 1659| 1.57k| result = getsection(source, msg, DNS_SECTION_ADDITIONAL, options); 1660| 1.57k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1660:6): [True: 268, False: 1.30k] | Branch (1660:39): [True: 0, False: 268] ------------------ 1661| 0| goto truncated; 1662| 0| } 1663| 1.57k| if (result == DNS_R_RECOVERABLE) { ------------------ | Branch (1663:6): [True: 0, False: 1.57k] ------------------ 1664| 0| seen_problem = true; 1665| 0| result = ISC_R_SUCCESS; 1666| 0| } 1667| 1.57k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1667:6): [True: 480, False: 1.09k] ------------------ 1668| 480| return result; 1669| 480| } 1670| | 1671| 1.09k| isc_buffer_remainingregion(source, &r); 1672| 1.09k| if (r.length != 0) { ------------------ | Branch (1672:6): [True: 0, False: 1.09k] ------------------ 1673| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MESSAGE, 1674| 0| ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1675| 0| "message has %u byte(s) of trailing garbage", 1676| 0| r.length); 1677| 0| } 1678| | 1679| 1.09k|truncated: 1680| | 1681| 1.09k| if (result == ISC_R_UNEXPECTEDEND && ignore_tc) { ------------------ | Branch (1681:6): [True: 0, False: 1.09k] | Branch (1681:39): [True: 0, False: 0] ------------------ 1682| 0| return DNS_R_RECOVERABLE; 1683| 0| } 1684| 1.09k| if (seen_problem) { ------------------ | Branch (1684:6): [True: 0, False: 1.09k] ------------------ 1685| 0| return DNS_R_RECOVERABLE; 1686| 0| } 1687| 1.09k| return ISC_R_SUCCESS; 1688| 1.09k|} dns_message_gettempname: 2392| 3.12k|dns_message_gettempname(dns_message_t *msg, dns_linkedname_t **item) { 2393| 3.12k| dns_fixedname_t *fn = NULL; 2394| | 2395| 3.12k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 3.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | ------------------ | | | | 42| 3.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2396| 3.12k| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 3.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | ------------------ | | | | 42| 3.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2397| | 2398| 3.12k| fn = isc_mempool_get(msg->namepool); ------------------ | | 168| 3.12k|#define isc_mempool_get(c) isc__mempool_get((c)_ISC_MEM_FILELINE) ------------------ 2399| 3.12k| dns_fixedname_init(fn); 2400| | 2401| 3.12k| *item = &fn->name_wl; 2402| 3.12k|} dns_message_gettemprdata: 2405| 249|dns_message_gettemprdata(dns_message_t *msg, dns_rdata_t **item) { 2406| 249| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2407| 249| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2408| | 2409| 249| *item = newrdata(msg); 2410| 249|} dns_message_gettemprdataset: 2413| 2.89k|dns_message_gettemprdataset(dns_message_t *msg, dns_rdataset_t **item) { 2414| 2.89k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.78k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2415| 2.89k| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.78k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2416| | 2417| 2.89k| *item = isc_mempool_get(msg->rdspool); ------------------ | | 168| 2.89k|#define isc_mempool_get(c) isc__mempool_get((c)_ISC_MEM_FILELINE) ------------------ 2418| 2.89k| dns_rdataset_init(*item); 2419| 2.89k|} dns_message_gettemprdatalist: 2422| 249|dns_message_gettemprdatalist(dns_message_t *msg, dns_rdatalist_t **item) { 2423| 249| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2424| 249| REQUIRE(item != NULL && *item == NULL); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2425| | 2426| 249| *item = newrdatalist(msg); 2427| 249|} dns_message_puttempname: 2430| 3.12k|dns_message_puttempname(dns_message_t *msg, dns_linkedname_t **itemp) { 2431| 3.12k| dns_linkedname_t *item = NULL; 2432| | 2433| 3.12k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 3.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | ------------------ | | | | 42| 3.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2434| 3.12k| REQUIRE(itemp != NULL && *itemp != NULL); ------------------ | | 198| 3.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | ------------------ | | | | 42| 3.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2435| | 2436| 3.12k| item = *itemp; 2437| 3.12k| *itemp = NULL; 2438| | 2439| 3.12k| REQUIRE(!ISC_LINK_LINKED(item, link)); ------------------ | | 198| 3.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.12k, False: 0] | | | | ------------------ | | | | 42| 3.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2440| 3.12k| REQUIRE(ISC_LIST_HEAD(item->list) == NULL); ------------------ | | 198| 3.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.12k, False: 0] | | | | ------------------ | | | | 42| 3.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2441| | 2442| 3.12k| if (item->hashmap != NULL) { ------------------ | Branch (2442:6): [True: 0, False: 3.12k] ------------------ 2443| 0| isc_hashmap_destroy(&item->hashmap); 2444| 0| } 2445| | 2446| | /* 2447| | * we need to check this in case dns_name_dup() was used. 2448| | */ 2449| 3.12k| if (dns_name_dynamic(item)) { ------------------ | | 1553| 3.12k|#define dns_name_dynamic(name) dns_name__dynamic(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 3.12k| _Generic((arg), \ | | | | 1508| 3.12k| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 3.12k| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 3.12k| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 3.12k| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 3.12k| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 3.12k| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1553:32): [True: 0, False: 3.12k] | | ------------------ ------------------ 2450| 0| dns_name_free(dns_name(item), msg->mctx); ------------------ | | 1515| 0|#define dns_name(source) DNS_NAME__RO_ARG(source) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 2451| 0| } 2452| | 2453| | /* 2454| | * Since name_wl is the first field in dns_fixedname_t, 2455| | * we can cast directly. 2456| | */ 2457| 3.12k| dns_fixedname_t *fn = (dns_fixedname_t *)item; 2458| | isc_mempool_put(msg->namepool, fn); ------------------ | | 207| 3.12k| do { \ | | 208| 3.12k| isc__mempool_put((c), (p)_ISC_MEM_FILELINE); \ | | 209| 3.12k| (p) = NULL; \ | | 210| 3.12k| } while (0) | | ------------------ | | | Branch (210:11): [Folded, False: 3.12k] | | ------------------ ------------------ 2459| 3.12k|} dns_message_puttemprdataset: 2477| 2.89k|dns_message_puttemprdataset(dns_message_t *msg, dns_rdataset_t **item) { 2478| 2.89k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.78k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2479| 2.89k| REQUIRE(item != NULL && *item != NULL); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.78k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2480| | 2481| 2.89k| REQUIRE(!dns_rdataset_isassociated(*item)); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2482| | isc_mempool_put(msg->rdspool, *item); ------------------ | | 207| 2.89k| do { \ | | 208| 2.89k| isc__mempool_put((c), (p)_ISC_MEM_FILELINE); \ | | 209| 2.89k| (p) = NULL; \ | | 210| 2.89k| } while (0) | | ------------------ | | | Branch (210:11): [Folded, False: 2.89k] | | ------------------ ------------------ 2483| 2.89k|} dns_message_settsigkey: 2667| 294|dns_message_settsigkey(dns_message_t *msg, dns_tsigkey_t *key) { 2668| 294| isc_result_t result; 2669| | 2670| | /* 2671| | * Set the TSIG key for 'msg' 2672| | */ 2673| | 2674| 294| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 294|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 588| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 294, False: 0] | | | | | Branch (41:11): [True: 294, False: 0] | | | | ------------------ | | | | 42| 294| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2675| | 2676| 294| if (key == NULL && msg->tsigkey != NULL) { ------------------ | Branch (2676:6): [True: 0, False: 294] | Branch (2676:21): [True: 0, False: 0] ------------------ 2677| 0| if (msg->sig_reserved != 0) { ------------------ | Branch (2677:7): [True: 0, False: 0] ------------------ 2678| 0| dns_message_renderrelease(msg, msg->sig_reserved); 2679| 0| msg->sig_reserved = 0; 2680| 0| } 2681| 0| dns_tsigkey_detach(&msg->tsigkey); 2682| 0| } 2683| 294| if (key != NULL) { ------------------ | Branch (2683:6): [True: 294, False: 0] ------------------ 2684| 294| REQUIRE(msg->tsigkey == NULL && msg->sig0key == NULL); ------------------ | | 198| 294|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 588| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 294, False: 0] | | | | | Branch (41:11): [True: 294, False: 0] | | | | ------------------ | | | | 42| 294| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2685| 294| dns_tsigkey_attach(key, &msg->tsigkey); 2686| 294| if (msg->from_to_wire == DNS_MESSAGE_INTENTRENDER) { ------------------ | Branch (2686:7): [True: 0, False: 294] ------------------ 2687| 0| msg->sig_reserved = spacefortsig(msg->tsigkey, 0); 2688| 0| result = dns_message_renderreserve(msg, 2689| 0| msg->sig_reserved); 2690| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2690:8): [True: 0, False: 0] ------------------ 2691| 0| dns_tsigkey_detach(&msg->tsigkey); 2692| 0| msg->sig_reserved = 0; 2693| 0| return result; 2694| 0| } 2695| 0| } 2696| 294| } 2697| 294| return ISC_R_SUCCESS; 2698| 294|} dns_message_gettsigkey: 2701| 600|dns_message_gettsigkey(dns_message_t *msg) { 2702| | /* 2703| | * Get the TSIG key for 'msg' 2704| | */ 2705| | 2706| 600| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 600|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 600, False: 0] | | | | | Branch (41:11): [True: 600, False: 0] | | | | ------------------ | | | | 42| 600| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2707| | 2708| 600| return msg->tsigkey; 2709| 600|} dns_message_setquerytsig: 2712| 249|dns_message_setquerytsig(dns_message_t *msg, isc_buffer_t *querytsig) { 2713| 249| dns_rdata_t *rdata = NULL; 2714| 249| dns_rdatalist_t *list = NULL; 2715| 249| dns_rdataset_t *set = NULL; 2716| 249| isc_buffer_t *buf = NULL; 2717| 249| isc_region_t r; 2718| | 2719| 249| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2720| 249| REQUIRE(msg->querytsig == NULL); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 249| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2721| | 2722| 249| if (querytsig == NULL) { ------------------ | Branch (2722:6): [True: 0, False: 249] ------------------ 2723| 0| return; 2724| 0| } 2725| | 2726| 249| dns_message_gettemprdata(msg, &rdata); 2727| | 2728| 249| dns_message_gettemprdatalist(msg, &list); 2729| 249| dns_message_gettemprdataset(msg, &set); 2730| | 2731| 249| isc_buffer_usedregion(querytsig, &r); 2732| 249| isc_buffer_allocate(msg->mctx, &buf, r.length); 2733| 249| isc_buffer_putmem(buf, r.base, r.length); 2734| 249| isc_buffer_usedregion(buf, &r); 2735| 249| dns_rdata_fromregion(rdata, dns_rdataclass_any, dns_rdatatype_tsig, &r); ------------------ | | 34| 249|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ dns_rdata_fromregion(rdata, dns_rdataclass_any, dns_rdatatype_tsig, &r); ------------------ | | 191| 249|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ 2736| 249| dns_message_takebuffer(msg, &buf); 2737| 249| ISC_LIST_APPEND(list->rdata, rdata, link); ------------------ | | 100| 249| do { \ | | 101| 249| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 249| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 249| do { \ | | | | 89| 249| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 249] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 249| } else { \ | | | | 92| 249| (list).head = (elt); \ | | | | 93| 249| } \ | | | | 94| 249| (elt)->link.prev = (list).tail; \ | | | | 95| 249| (elt)->link.next = NULL; \ | | | | 96| 249| (list).tail = (elt); \ | | | | 97| 249| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 249] | | | | ------------------ | | ------------------ | | 103| 249| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 249] | | ------------------ ------------------ 2738| 249| dns_rdatalist_tordataset(list, set); 2739| | 2740| 249| msg->querytsig = set; 2741| 249|} dns_message_takebuffer: 2853| 249|dns_message_takebuffer(dns_message_t *msg, isc_buffer_t **buffer) { 2854| 249| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2855| 249| REQUIRE(buffer != NULL); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 249| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2856| 249| REQUIRE(ISC_BUFFER_VALID(*buffer)); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2857| | 2858| 249| ISC_LIST_APPEND(msg->cleanup, *buffer, link); ------------------ | | 100| 249| do { \ | | 101| 249| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 249| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 249| do { \ | | | | 89| 249| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 249] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 249| } else { \ | | | | 92| 249| (list).head = (elt); \ | | | | 93| 249| } \ | | | | 94| 249| (elt)->link.prev = (list).tail; \ | | | | 95| 249| (elt)->link.next = NULL; \ | | | | 96| 249| (list).tail = (elt); \ | | | | 97| 249| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 249] | | | | ------------------ | | ------------------ | | 103| 249| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 249] | | ------------------ ------------------ 2859| | *buffer = NULL; 2860| 249|} dns_message_checksig: 3037| 1.09k|dns_message_checksig(dns_message_t *msg, dns_view_t *view) { 3038| 1.09k| isc_buffer_t msgb; 3039| | 3040| 1.09k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 1.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.09k, False: 0] | | | | | Branch (41:11): [True: 1.09k, False: 0] | | | | ------------------ | | | | 42| 1.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 3041| | 3042| 1.09k| if (msg->tsigkey == NULL && msg->tsig == NULL && msg->sig0 == NULL) { ------------------ | Branch (3042:6): [True: 797, False: 294] | Branch (3042:30): [True: 491, False: 306] | Branch (3042:51): [True: 73, False: 418] ------------------ 3043| 73| return ISC_R_SUCCESS; 3044| 73| } 3045| | 3046| 1.01k| INSIST(msg->saved.base != NULL); ------------------ | | 202| 1.01k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 1.01k, False: 0] | | | | ------------------ | | | | 54| 1.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 3047| 1.01k| isc_buffer_init(&msgb, msg->saved.base, msg->saved.length); 3048| 1.01k| isc_buffer_add(&msgb, msg->saved.length); 3049| 1.01k| if (msg->tsigkey != NULL || msg->tsig != NULL) { ------------------ | Branch (3049:6): [True: 294, False: 724] | Branch (3049:30): [True: 306, False: 418] ------------------ 3050| |#ifdef SKAN_MSG_DEBUG 3051| | dns_message_dumpsig(msg, "dns_message_checksig#1"); 3052| |#endif /* ifdef SKAN_MSG_DEBUG */ 3053| 600| if (view != NULL) { ------------------ | Branch (3053:7): [True: 460, False: 140] ------------------ 3054| 460| return dns_view_checksig(view, &msgb, msg); 3055| 460| } else { 3056| 140| return dns_tsig_verify(&msgb, msg, NULL, NULL); 3057| 140| } 3058| 600| } else { 3059| 418| dns_rdata_t sigrdata = DNS_RDATA_INIT; ------------------ | | 149| 418| { \ | | 150| 418| .data = NULL, \ | | 151| 418| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 418|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 418| { \ | | | | | | 27| 418| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 418|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 418| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 418|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 418| } | | | | ------------------ | | ------------------ | | 152| 418| } ------------------ 3060| 418| dns_rdata_sig_t sig; 3061| 418| dns_rdataset_t keyset; 3062| 418| isc_result_t result; 3063| 418| uint32_t key_checks, message_checks; 3064| | 3065| 418| result = dns_rdataset_first(msg->sig0); 3066| 418| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 418|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 418| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 418, False: 0] | | | | ------------------ | | | | 54| 418| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 3067| 418| dns_rdataset_current(msg->sig0, &sigrdata); 3068| | 3069| | /* 3070| | * This can occur when the message is a dynamic update, since 3071| | * the rdata length checking is relaxed. This should not 3072| | * happen in a well-formed message, since the SIG(0) is only 3073| | * looked for in the additional section, and the dynamic update 3074| | * meta-records are in the prerequisite and update sections. 3075| | */ 3076| 418| if (sigrdata.length == 0) { ------------------ | Branch (3076:7): [True: 0, False: 418] ------------------ 3077| 0| return ISC_R_UNEXPECTEDEND; 3078| 0| } 3079| | 3080| 418| RETERR(dns_rdata_tostruct(&sigrdata, &sig)); ------------------ | | 276| 418| { \ | | 277| 418| isc_result_t _r = (x); \ | | 278| 418| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 418] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 418| } ------------------ 3081| | 3082| 418| dns_rdataset_init(&keyset); 3083| 418| if (view == NULL) { ------------------ | Branch (3083:7): [True: 29, False: 389] ------------------ 3084| 29| result = DNS_R_KEYUNAUTHORIZED; 3085| 29| goto freesig; 3086| 29| } 3087| 389| result = dns_view_simplefind(view, &sig.signer, 3088| 389| dns_rdatatype_key /* SIG(0) */, 0, ------------------ | | 140| 389|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ 3089| 389| 0, &keyset, NULL); 3090| | 3091| 389| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3091:7): [True: 272, False: 117] ------------------ 3092| 272| result = DNS_R_KEYUNAUTHORIZED; 3093| 272| goto freesig; 3094| 272| } else if (keyset.trust < dns_trust_ultimate) { ------------------ | | 381| 117|#define dns_trust_ultimate ((dns_trust_t)dns_trust_ultimate) ------------------ | Branch (3094:14): [True: 0, False: 117] ------------------ 3095| 0| result = DNS_R_KEYUNAUTHORIZED; 3096| 0| goto freesig; 3097| 0| } 3098| 117| result = dns_rdataset_first(&keyset); 3099| 117| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 117|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 117, False: 0] | | | | ------------------ | | | | 54| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 3100| | 3101| | /* 3102| | * In order to protect from a possible DoS attack, this function 3103| | * supports limitations on how many keyid checks and how many 3104| | * key checks (message verifications using a matched key) are 3105| | * going to be allowed. 3106| | */ 3107| 117| const uint32_t max_key_checks = 3108| 117| view->sig0key_checks_limit > 0 ------------------ | Branch (3108:4): [True: 0, False: 117] ------------------ 3109| 117| ? view->sig0key_checks_limit 3110| 117| : UINT32_MAX; 3111| 117| const uint32_t max_message_checks = 3112| 117| view->sig0message_checks_limit > 0 ------------------ | Branch (3112:4): [True: 0, False: 117] ------------------ 3113| 117| ? view->sig0message_checks_limit 3114| 117| : UINT32_MAX; 3115| | 3116| 117| for (key_checks = 0, message_checks = 0; 3117| 233| result == ISC_R_SUCCESS && key_checks < max_key_checks && ------------------ | Branch (3117:8): [True: 117, False: 116] | Branch (3117:35): [True: 117, False: 0] ------------------ 3118| 117| message_checks < max_message_checks; ------------------ | Branch (3118:8): [True: 117, False: 0] ------------------ 3119| 117| key_checks++, result = dns_rdataset_next(&keyset)) 3120| 117| { 3121| 117| dns_rdata_t keyrdata = DNS_RDATA_INIT; ------------------ | | 149| 117| { \ | | 150| 117| .data = NULL, \ | | 151| 117| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 117|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 117| { \ | | | | | | 27| 117| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 117|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 117| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 117|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 117| } | | | | ------------------ | | ------------------ | | 152| 117| } ------------------ 3122| 117| dns_rdata_key_t ks; 3123| 117| dst_key_t *key = NULL; 3124| 117| isc_region_t r; 3125| | 3126| 117| dns_rdataset_current(&keyset, &keyrdata); 3127| 117| dns_rdata_tostruct(&keyrdata, &ks); 3128| | 3129| 117| if (sig.algorithm != ks.algorithm || ------------------ | Branch (3129:8): [True: 12, False: 105] ------------------ 3130| 105| (ks.protocol != DNS_KEYPROTO_DNSSEC && ------------------ | Branch (3130:9): [True: 0, False: 105] ------------------ 3131| 0| ks.protocol != DNS_KEYPROTO_ANY)) ------------------ | Branch (3131:9): [True: 0, False: 0] ------------------ 3132| 12| { 3133| 12| continue; 3134| 12| } 3135| | 3136| 105| dns_rdata_toregion(&keyrdata, &r); 3137| 105| if (dst_region_computeid(&r) != sig.keyid) { ------------------ | Branch (3137:8): [True: 23, False: 82] ------------------ 3138| 23| continue; 3139| 23| } 3140| | 3141| 82| result = dns_dnssec_keyfromrdata(&sig.signer, &keyrdata, 3142| 82| view->mctx, &key); 3143| 82| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3143:8): [True: 0, False: 82] ------------------ 3144| 0| continue; 3145| 0| } 3146| | 3147| 82| result = dns_dnssec_verifymessage(&msgb, msg, key); 3148| 82| dst_key_free(&key); 3149| 82| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3149:8): [True: 1, False: 81] ------------------ 3150| 1| break; 3151| 1| } 3152| 81| message_checks++; 3153| 81| } 3154| 117| if (result == ISC_R_NOMORE) { ------------------ | Branch (3154:7): [True: 116, False: 1] ------------------ 3155| 116| result = DNS_R_KEYUNAUTHORIZED; 3156| 116| } else if (key_checks == max_key_checks) { ------------------ | Branch (3156:14): [True: 0, False: 1] ------------------ 3157| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, 3158| 0| DNS_LOGMODULE_MESSAGE, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 3159| 0| "sig0key-checks-limit reached when " 3160| 0| "trying to check a message signature"); 3161| 0| result = DNS_R_KEYUNAUTHORIZED; 3162| 1| } else if (message_checks == max_message_checks) { ------------------ | Branch (3162:14): [True: 0, False: 1] ------------------ 3163| 0| isc_log_write(ISC_LOGCATEGORY_GENERAL, 3164| 0| DNS_LOGMODULE_MESSAGE, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 3165| 0| "sig0message-checks-limit reached when " 3166| 0| "trying to check a message signature"); 3167| 0| result = DNS_R_KEYUNAUTHORIZED; 3168| 0| } 3169| | 3170| 418| freesig: 3171| | dns_rdataset_cleanup(&keyset); ------------------ | | 302| 418| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 418, Folded] | | | Branch (302:26): [True: 117, False: 301] | | ------------------ | | 303| 117| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 117| } ------------------ 3172| 418| return result; 3173| 117| } 3174| 1.01k|} dns_message_createpools: 5021| 1.57k| isc_mempool_t **rdspoolp) { 5022| 1.57k| REQUIRE(mctx != NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 5023| 1.57k| REQUIRE(namepoolp != NULL && *namepoolp == NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 5024| 1.57k| REQUIRE(rdspoolp != NULL && *rdspoolp == NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 5025| | 5026| 1.57k| isc_mempool_create(mctx, sizeof(dns_fixedname_t), "dns_fixedname_pool", ------------------ | | 382| 1.57k| isc__mempool_create((c), (s), (n), (mp)_ISC_MEM_FILELINE) ------------------ 5027| 1.57k| namepoolp); 5028| 1.57k| isc_mempool_setfillcount(*namepoolp, NAME_FILLCOUNT); ------------------ | | 126| 1.57k|#define NAME_FILLCOUNT 1024 ------------------ 5029| 1.57k| isc_mempool_setfreemax(*namepoolp, NAME_FREEMAX); ------------------ | | 127| 1.57k|#define NAME_FREEMAX 8 * NAME_FILLCOUNT | | ------------------ | | | | 126| 1.57k|#define NAME_FILLCOUNT 1024 | | ------------------ ------------------ 5030| | 5031| 1.57k| isc_mempool_create(mctx, sizeof(dns_rdataset_t), "dns_rdataset_pool", ------------------ | | 382| 1.57k| isc__mempool_create((c), (s), (n), (mp)_ISC_MEM_FILELINE) ------------------ 5032| 1.57k| rdspoolp); 5033| 1.57k| isc_mempool_setfillcount(*rdspoolp, RDATASET_FILLCOUNT); ------------------ | | 131| 1.57k|#define RDATASET_FILLCOUNT 1024 ------------------ 5034| 1.57k| isc_mempool_setfreemax(*rdspoolp, RDATASET_FREEMAX); ------------------ | | 132| 1.57k|#define RDATASET_FREEMAX 8 * RDATASET_FILLCOUNT | | ------------------ | | | | 131| 1.57k|#define RDATASET_FILLCOUNT 1024 | | ------------------ ------------------ 5035| 1.57k|} dns_message_destroypools: 5038| 1.57k|dns_message_destroypools(isc_mempool_t **namepoolp, isc_mempool_t **rdspoolp) { 5039| 1.57k| REQUIRE(namepoolp != NULL && *namepoolp != NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 5040| 1.57k| REQUIRE(rdspoolp != NULL && *rdspoolp != NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 5041| | 5042| 1.57k| ENSURE(isc_mempool_getallocated(*namepoolp) == 0); ------------------ | | 200| 1.57k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 48| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 5043| 1.57k| ENSURE(isc_mempool_getallocated(*rdspoolp) == 0); ------------------ | | 200| 1.57k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 48| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 5044| | 5045| 1.57k| isc_mempool_destroy(rdspoolp); ------------------ | | 399| 1.57k|#define isc_mempool_destroy(mp) isc__mempool_destroy((mp)_ISC_MEM_FILELINE) ------------------ 5046| 1.57k| isc_mempool_destroy(namepoolp); ------------------ | | 399| 1.57k|#define isc_mempool_destroy(mp) isc__mempool_destroy((mp)_ISC_MEM_FILELINE) ------------------ 5047| 1.57k|} message.c:msginit: 440| 1.57k|msginit(dns_message_t *m) { 441| 1.57k| msginitheader(m); 442| 1.57k| msginitprivate(m); 443| 1.57k| msginittsig(m); 444| 1.57k| m->header_ok = 0; 445| 1.57k| m->question_ok = 0; 446| 1.57k| m->tcp_continuation = 0; 447| 1.57k| m->verified_sig = 0; 448| 1.57k| m->verify_attempted = 0; 449| 1.57k| m->query.base = NULL; 450| 1.57k| m->query.length = 0; 451| 1.57k| m->free_query = 0; 452| 1.57k| m->saved.base = NULL; 453| 1.57k| m->saved.length = 0; 454| 1.57k| m->free_saved = 0; 455| 1.57k| m->cc_ok = 0; 456| 1.57k| m->cc_bad = 0; 457| 1.57k| m->tkey = 0; 458| 1.57k| m->rdclass_set = 0; 459| 1.57k| m->has_dname = 0; 460| | m->querytsig = NULL; 461| 1.57k| m->indent.string = "\t"; 462| 1.57k| m->indent.count = 0; 463| 1.57k|} message.c:msginitheader: 393| 1.57k|msginitheader(dns_message_t *m) { 394| 1.57k| m->id = 0; 395| 1.57k| m->flags = 0; 396| 1.57k| m->rcode = 0; 397| 1.57k| m->opcode = 0; 398| 1.57k| m->rdclass = 0; 399| 1.57k|} message.c:msginittsig: 424| 1.57k|msginittsig(dns_message_t *m) { 425| 1.57k| m->tsigstatus = dns_rcode_noerror; ------------------ | | 270| 1.57k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 426| 1.57k| m->querytsigstatus = dns_rcode_noerror; ------------------ | | 270| 1.57k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 427| 1.57k| m->tsigkey = NULL; 428| 1.57k| m->tsigctx = NULL; 429| 1.57k| m->sigstart = -1; 430| 1.57k| m->sig0key = NULL; 431| 1.57k| m->sig0status = dns_rcode_noerror; ------------------ | | 270| 1.57k|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 432| 1.57k| m->timeadjust = 0; 433| 1.57k|} message.c:msgreset: 555| 1.57k|msgreset(dns_message_t *msg, bool everything) { 556| 1.57k| dns_msgblock_t *msgblock = NULL, *next_msgblock = NULL; 557| 1.57k| isc_buffer_t *dynbuf = NULL, *next_dynbuf = NULL; 558| | 559| 1.57k| msgresetnames(msg, 0); 560| 1.57k| msgresetopt(msg); 561| 1.57k| msgresetsigs(msg, false); 562| 1.57k| msgresetedns(msg); 563| | 564| | /* 565| | * Clean up linked lists. 566| | */ 567| | 568| | /* 569| | * Run through the free lists, and just unlink anything found there. 570| | * The memory isn't lost since these are part of message blocks we 571| | * have allocated. 572| | */ 573| 1.57k| ISC_LIST_FOREACH(msg->freerdata, rdata, link) { ------------------ | | 234| 1.57k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 1.57k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 1.57k| 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.57k] | | ------------------ | | 236| 1.57k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 1.57k] | | ------------------ | | 237| 1.57k| 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] | | ------------------ ------------------ 574| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 575| 0| } 576| 1.57k| ISC_LIST_FOREACH(msg->freerdatalist, rdatalist, link) { ------------------ | | 234| 1.57k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 1.57k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 1.57k| 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.57k] | | ------------------ | | 236| 1.57k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 0, False: 1.57k] | | ------------------ | | 237| 1.57k| 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] | | ------------------ ------------------ 577| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 578| 0| } 579| | 580| 1.57k| dynbuf = ISC_LIST_HEAD(msg->scratchpad); ------------------ | | 62| 1.57k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 581| 1.57k| INSIST(dynbuf != NULL); ------------------ | | 202| 1.57k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 54| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 582| 1.57k| if (!everything) { ------------------ | Branch (582:6): [True: 0, False: 1.57k] ------------------ 583| 0| isc_buffer_clear(dynbuf); 584| 0| dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 585| 0| } 586| 3.52k| while (dynbuf != NULL) { ------------------ | Branch (586:9): [True: 1.94k, False: 1.57k] ------------------ 587| 1.94k| next_dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 1.94k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 588| 1.94k| ISC_LIST_UNLINK(msg->scratchpad, dynbuf, link); ------------------ | | 137| 1.94k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.94k| do { \ | | | | 133| 1.94k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.94k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.94k| do { \ | | | | | | 110| 1.94k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 368, False: 1.57k] | | | | | | ------------------ | | | | | | 111| 368| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.57k| } else { \ | | | | | | 113| 1.57k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.57k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.57k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.57k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.57k| } \ | | | | | | 116| 1.94k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.94k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.94k| } else { \ | | | | | | 119| 1.94k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.94k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.94k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.94k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.94k| } \ | | | | | | 122| 1.94k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.94k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.94k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.94k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.94k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.94k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.94k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.94k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.94k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.94k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.94k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.94k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.94k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.94k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.94k] | | | | ------------------ | | ------------------ ------------------ 589| 1.94k| isc_buffer_free(&dynbuf); 590| 1.94k| dynbuf = next_dynbuf; 591| 1.94k| } 592| | 593| 1.57k| msgblock = ISC_LIST_HEAD(msg->rdatas); ------------------ | | 62| 1.57k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 594| 1.57k| if (!everything && msgblock != NULL) { ------------------ | Branch (594:6): [True: 0, False: 1.57k] | Branch (594:21): [True: 0, False: 0] ------------------ 595| 0| msgblock_reset(msgblock); 596| 0| msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 597| 0| } 598| 3.13k| while (msgblock != NULL) { ------------------ | Branch (598:9): [True: 1.55k, False: 1.57k] ------------------ 599| 1.55k| next_msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 1.55k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 600| 1.55k| ISC_LIST_UNLINK(msg->rdatas, msgblock, link); ------------------ | | 137| 1.55k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.55k| do { \ | | | | 133| 1.55k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.55k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.55k| do { \ | | | | | | 110| 1.55k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.55k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.55k| } else { \ | | | | | | 113| 1.55k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.55k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.55k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.55k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.55k| } \ | | | | | | 116| 1.55k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.55k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.55k| } else { \ | | | | | | 119| 1.55k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.55k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.55k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.55k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.55k| } \ | | | | | | 122| 1.55k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.55k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.55k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.55k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.55k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.55k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.55k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.55k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.55k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.55k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.55k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.55k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.55k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.55k] | | | | ------------------ | | ------------------ ------------------ 601| 1.55k| msgblock_free(msg->mctx, msgblock, sizeof(dns_rdata_t)); 602| 1.55k| msgblock = next_msgblock; 603| 1.55k| } 604| | 605| | /* 606| | * rdatalists could be empty. 607| | */ 608| | 609| 1.57k| msgblock = ISC_LIST_HEAD(msg->rdatalists); ------------------ | | 62| 1.57k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 610| 1.57k| if (!everything && msgblock != NULL) { ------------------ | Branch (610:6): [True: 0, False: 1.57k] | Branch (610:21): [True: 0, False: 0] ------------------ 611| 0| msgblock_reset(msgblock); 612| 0| msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 0|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 613| 0| } 614| 3.14k| while (msgblock != NULL) { ------------------ | Branch (614:9): [True: 1.57k, False: 1.57k] ------------------ 615| 1.57k| next_msgblock = ISC_LIST_NEXT(msgblock, link); ------------------ | | 140| 1.57k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 616| 1.57k| ISC_LIST_UNLINK(msg->rdatalists, msgblock, link); ------------------ | | 137| 1.57k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.57k| do { \ | | | | 133| 1.57k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.57k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.57k| do { \ | | | | | | 110| 1.57k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.57k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.57k| } else { \ | | | | | | 113| 1.57k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.57k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.57k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.57k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.57k| } \ | | | | | | 116| 1.57k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.57k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.57k| } else { \ | | | | | | 119| 1.57k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.57k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.57k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.57k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.57k| } \ | | | | | | 122| 1.57k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.57k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.57k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.57k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.57k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.57k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.57k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.57k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.57k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.57k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.57k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.57k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.57k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.57k] | | | | ------------------ | | ------------------ ------------------ 617| 1.57k| msgblock_free(msg->mctx, msgblock, sizeof(dns_rdatalist_t)); 618| 1.57k| msgblock = next_msgblock; 619| 1.57k| } 620| | 621| 1.57k| if (msg->tsigkey != NULL) { ------------------ | Branch (621:6): [True: 598, False: 979] ------------------ 622| 598| dns_tsigkey_detach(&msg->tsigkey); 623| 598| msg->tsigkey = NULL; 624| 598| } 625| | 626| 1.57k| if (msg->tsigctx != NULL) { ------------------ | Branch (626:6): [True: 0, False: 1.57k] ------------------ 627| 0| dst_context_destroy(&msg->tsigctx); 628| 0| } 629| | 630| 1.57k| if (msg->query.base != NULL) { ------------------ | Branch (630:6): [True: 0, False: 1.57k] ------------------ 631| 0| if (msg->free_query != 0) { ------------------ | Branch (631:7): [True: 0, False: 0] ------------------ 632| 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] | | ------------------ ------------------ 633| 0| msg->query.length); 634| 0| } 635| 0| msg->query.base = NULL; 636| 0| msg->query.length = 0; 637| 0| } 638| | 639| 1.57k| if (msg->saved.base != NULL) { ------------------ | Branch (639:6): [True: 1.57k, False: 0] ------------------ 640| 1.57k| if (msg->free_saved != 0) { ------------------ | Branch (640:7): [True: 0, False: 1.57k] ------------------ 641| 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] | | ------------------ ------------------ 642| 0| msg->saved.length); 643| 0| } 644| 1.57k| msg->saved.base = NULL; 645| 1.57k| msg->saved.length = 0; 646| 1.57k| } 647| | 648| | /* 649| | * cleanup the buffer cleanup list 650| | */ 651| 1.57k| dynbuf = ISC_LIST_HEAD(msg->cleanup); ------------------ | | 62| 1.57k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 652| 1.82k| while (dynbuf != NULL) { ------------------ | Branch (652:9): [True: 249, False: 1.57k] ------------------ 653| 249| next_dynbuf = ISC_LIST_NEXT(dynbuf, link); ------------------ | | 140| 249|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 654| 249| ISC_LIST_UNLINK(msg->cleanup, dynbuf, link); ------------------ | | 137| 249| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 249| do { \ | | | | 133| 249| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 249| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 249| do { \ | | | | | | 110| 249| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 249] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 249| } else { \ | | | | | | 113| 249| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 249| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 249, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 114| 249| (list).tail = (elt)->link.prev; \ | | | | | | 115| 249| } \ | | | | | | 116| 249| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 249] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 249| } else { \ | | | | | | 119| 249| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 249| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 249, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 120| 249| (list).head = (elt)->link.next; \ | | | | | | 121| 249| } \ | | | | | | 122| 249| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 249|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 249| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 249|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 249| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 249| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 249, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 249| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 249| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 249, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | | | 135| 249| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 249] | | | | ------------------ | | ------------------ ------------------ 655| 249| isc_buffer_free(&dynbuf); 656| 249| dynbuf = next_dynbuf; 657| 249| } 658| | 659| | /* 660| | * Set other bits to normal default values. 661| | */ 662| 1.57k| if (!everything) { ------------------ | Branch (662:6): [True: 0, False: 1.57k] ------------------ 663| 0| msginit(msg); 664| 0| } 665| 1.57k|} message.c:msgblock_free: 298| 3.12k| unsigned int sizeof_type) { 299| 3.12k| unsigned int length; 300| | 301| 3.12k| length = sizeof(dns_msgblock_t) + (sizeof_type * block->count); 302| | 303| | isc_mem_put(mctx, block, length); ------------------ | | 171| 3.12k| do { \ | | 172| 3.12k| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 3.12k| (p) = NULL; \ | | 174| 3.12k| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 3.12k] | | ------------------ ------------------ 304| 3.12k|} message.c:dns__message_destroy: 764| 1.57k|dns__message_destroy(dns_message_t *msg) { 765| 1.57k| REQUIRE(msg != NULL); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 766| 1.57k| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 767| | 768| 1.57k| msgreset(msg, true); 769| | 770| 1.57k| msg->magic = 0; 771| | 772| 1.57k| if (msg->free_pools) { ------------------ | Branch (772:6): [True: 1.57k, False: 0] ------------------ 773| 1.57k| dns_message_destroypools(&msg->namepool, &msg->rdspool); 774| 1.57k| } 775| | 776| | isc_mem_putanddetach(&msg->mctx, msg, sizeof(dns_message_t)); ------------------ | | 187| 1.57k| do { \ | | 188| 1.57k| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 1.57k| (p) = NULL; \ | | 190| 1.57k| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 1.57k] | | ------------------ ------------------ 777| 1.57k|} message.c:early_sanity_check: 1533| 1.57k|early_sanity_check(dns_message_t *msg) { 1534| 1.57k| bool is_unknown_opcode = msg->opcode >= dns_opcode_max; 1535| 1.57k| bool is_query_response = (msg->flags & DNS_MESSAGEFLAG_QR) != 0; 1536| 1.57k| bool no_questions = msg->counts[DNS_SECTION_QUESTION] == 0; 1537| 1.57k| bool many_questions = msg->counts[DNS_SECTION_QUESTION] > 1; 1538| 1.57k| bool has_answer = msg->counts[DNS_SECTION_ANSWER] > 0; 1539| 1.57k| bool has_auth = msg->counts[DNS_SECTION_AUTHORITY] > 0; 1540| | 1541| 1.57k| if (is_unknown_opcode) { ------------------ | Branch (1541:6): [True: 6, False: 1.57k] ------------------ 1542| 6| return DNS_R_NOTIMP; 1543| 1.57k| } else if (many_questions) { ------------------ | Branch (1543:13): [True: 0, False: 1.57k] ------------------ 1544| 0| return DNS_R_FORMERR; 1545| 1.57k| } else if (no_questions && (msg->opcode != dns_opcode_query) && ------------------ | Branch (1545:13): [True: 0, False: 1.57k] | Branch (1545:29): [True: 0, False: 0] ------------------ 1546| 0| (msg->opcode != dns_opcode_status)) ------------------ | Branch (1546:6): [True: 0, False: 0] ------------------ 1547| 0| { 1548| | /* 1549| | * Per RFC9619, the two cases where qdcount == 0 is acceptable 1550| | * are AXFR transfers and cookies, and both have opcode 0. 1551| | * 1552| | * RFC9619 also specifies that msg->opcode == dns_opcode_status 1553| | * is unspecified, so we ignore it. 1554| | */ 1555| 0| return DNS_R_FORMERR; 1556| 1.57k| } else if (msg->opcode == dns_opcode_notify && ------------------ | Branch (1556:13): [True: 310, False: 1.26k] ------------------ 1557| 310| ((is_query_response && has_answer) || has_auth)) ------------------ | Branch (1557:8): [True: 43, False: 267] | Branch (1557:29): [True: 0, False: 43] | Branch (1557:44): [True: 0, False: 310] ------------------ 1558| 0| { 1559| 0| return DNS_R_FORMERR; 1560| 0| } 1561| 1.57k| return ISC_R_SUCCESS; 1562| 1.57k|} message.c:getquestions: 920| 1.57k|getquestions(isc_buffer_t *source, dns_message_t *msg, unsigned int options) { 921| 1.57k| isc_region_t r; 922| 1.57k| unsigned int count; 923| 1.57k| dns_linkedname_t *name = NULL; 924| 1.57k| dns_rdataset_t *rdataset = NULL; 925| 1.57k| dns_rdatalist_t *rdatalist = NULL; 926| 1.57k| isc_result_t result = ISC_R_SUCCESS; 927| 1.57k| dns_rdatatype_t rdtype; 928| 1.57k| dns_rdataclass_t rdclass; 929| 1.57k| dns_namelist_t *section = &msg->sections[DNS_SECTION_QUESTION]; 930| 1.57k| bool best_effort = ((options & DNS_MESSAGEPARSE_BESTEFFORT) != 0); ------------------ | | 202| 1.57k| 0x0002 /*%< return a message if a \ ------------------ 931| 1.57k| bool seen_problem = false; 932| 1.57k| bool free_name = false; 933| | 934| 1.57k| REQUIRE(msg->counts[DNS_SECTION_QUESTION] <= 1 || best_effort); ------------------ | | 198| 1.57k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.57k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.57k, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 935| | 936| 3.14k| for (count = 0; count < msg->counts[DNS_SECTION_QUESTION]; count++) { ------------------ | Branch (936:18): [True: 1.57k, False: 1.57k] ------------------ 937| 1.57k| name = NULL; 938| 1.57k| dns_message_gettempname(msg, &name); 939| 1.57k| free_name = true; 940| | 941| | /* 942| | * Parse the name out of this packet. 943| | */ 944| 1.57k| isc_buffer_remainingregion(source, &r); 945| 1.57k| isc_buffer_setactive(source, r.length); 946| 1.57k| CHECK(dns_name_fromwire(dns_name(name), source, ------------------ | | 255| 1.57k| { \ | | 256| 1.57k| result = (r); \ | | 257| 1.57k| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 1.57k] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 1.57k| } ------------------ 947| 1.57k| DNS_DECOMPRESS_ALWAYS, NULL)); 948| | 949| 1.57k| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 1.57k| do { \ | | 101| 1.57k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.57k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.57k| do { \ | | | | 89| 1.57k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.57k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.57k| } else { \ | | | | 92| 1.57k| (list).head = (elt); \ | | | | 93| 1.57k| } \ | | | | 94| 1.57k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.57k| (elt)->link.next = NULL; \ | | | | 96| 1.57k| (list).tail = (elt); \ | | | | 97| 1.57k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.57k] | | | | ------------------ | | ------------------ | | 103| 1.57k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.57k] | | ------------------ ------------------ 950| | 951| 1.57k| free_name = false; 952| | 953| | /* 954| | * Get type and class. 955| | */ 956| 1.57k| isc_buffer_remainingregion(source, &r); 957| 1.57k| if (r.length < 4) { ------------------ | Branch (957:7): [True: 0, False: 1.57k] ------------------ 958| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 959| 0| } 960| 1.57k| rdtype = isc_buffer_getuint16(source); 961| 1.57k| rdclass = isc_buffer_getuint16(source); 962| | 963| | /* 964| | * Notify and update messages need to specify the data class. 965| | */ 966| 1.57k| if ((msg->opcode == dns_opcode_update || ------------------ | Branch (966:8): [True: 222, False: 1.34k] ------------------ 967| 1.34k| msg->opcode == dns_opcode_notify) && ------------------ | Branch (967:8): [True: 310, False: 1.03k] ------------------ 968| 532| (rdclass == dns_rdataclass_none || ------------------ | | 32| 1.06k|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (968:8): [True: 0, False: 532] ------------------ 969| 532| rdclass == dns_rdataclass_any)) ------------------ | | 34| 532|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (969:8): [True: 0, False: 532] ------------------ 970| 0| { 971| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 972| 0| } 973| | 974| | /* 975| | * If this class is different than the one we already read, 976| | * this is an error. 977| | */ 978| 1.57k| if (msg->rdclass_set == 0) { ------------------ | Branch (978:7): [True: 1.57k, False: 0] ------------------ 979| 1.57k| msg->rdclass = rdclass; 980| 1.57k| msg->rdclass_set = 1; 981| 1.57k| } else if (msg->rdclass != rdclass) { ------------------ | Branch (981:14): [True: 0, False: 0] ------------------ 982| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 983| 0| } 984| | 985| | /* 986| | * Is this a TKEY query? 987| | */ 988| 1.57k| if (rdtype == dns_rdatatype_tkey) { ------------------ | | 190| 1.57k|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (988:7): [True: 0, False: 1.57k] ------------------ 989| 0| msg->tkey = 1; 990| 0| } 991| | 992| | /* 993| | * Allocate a new rdatalist. 994| | */ 995| 1.57k| rdatalist = newrdatalist(msg); 996| 1.57k| rdatalist->type = rdtype; 997| 1.57k| rdatalist->rdclass = rdclass; 998| 1.57k| rdatalist->covers = dns_rdatatype_none; ------------------ | | 115| 1.57k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 999| | 1000| | /* 1001| | * Convert rdatalist to rdataset, and attach the latter to 1002| | * the name. 1003| | */ 1004| 1.57k| dns_message_gettemprdataset(msg, &rdataset); 1005| 1.57k| dns_rdatalist_tordataset(rdatalist, rdataset); 1006| | 1007| 1.57k| rdataset->attributes.question = true; 1008| | 1009| 1.57k| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 1.57k| do { \ | | 101| 1.57k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.57k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.57k| do { \ | | | | 89| 1.57k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.57k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.57k| } else { \ | | | | 92| 1.57k| (list).head = (elt); \ | | | | 93| 1.57k| } \ | | | | 94| 1.57k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.57k| (elt)->link.next = NULL; \ | | | | 96| 1.57k| (list).tail = (elt); \ | | | | 97| 1.57k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.57k] | | | | ------------------ | | ------------------ | | 103| 1.57k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.57k] | | ------------------ ------------------ 1010| | 1011| 1.57k| rdataset = NULL; 1012| 1.57k| } 1013| | 1014| 1.57k| if (seen_problem) { ------------------ | Branch (1014:6): [True: 0, False: 1.57k] ------------------ 1015| | /* XXX test coverage */ 1016| 0| result = DNS_R_RECOVERABLE; 1017| 0| } 1018| | 1019| 1.57k|cleanup: 1020| 1.57k| if (rdataset != NULL) { ------------------ | Branch (1020:6): [True: 0, False: 1.57k] ------------------ 1021| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 302| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 0, False: 0] | | | Branch (302:26): [True: 0, False: 0] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 1022| 0| dns_message_puttemprdataset(msg, &rdataset); 1023| 0| } 1024| | 1025| 1.57k| if (free_name) { ------------------ | Branch (1025:6): [True: 0, False: 1.57k] ------------------ 1026| 0| dns_message_puttempname(msg, &name); 1027| 0| } 1028| | 1029| 1.57k| return result; 1030| 1.57k|} message.c:getsection: 1046| 4.71k| unsigned int options) { 1047| 4.71k| isc_region_t r; 1048| 4.71k| unsigned int count, rdatalen; 1049| 4.71k| dns_linkedname_t *name = NULL; 1050| 4.71k| dns_linkedname_t *found_name = NULL; 1051| 4.71k| dns_rdataset_t *rdataset = NULL; 1052| 4.71k| dns_rdataset_t *found_rdataset = NULL; 1053| 4.71k| dns_rdatalist_t *rdatalist = NULL; 1054| 4.71k| isc_result_t result = ISC_R_SUCCESS; 1055| 4.71k| dns_rdatatype_t rdtype, covers; 1056| 4.71k| dns_rdataclass_t rdclass; 1057| 4.71k| dns_rdata_t *rdata = NULL; 1058| 4.71k| dns_ttl_t ttl; 1059| 4.71k| dns_namelist_t *section = &msg->sections[sectionid]; 1060| 4.71k| bool free_name = false, seen_problem = false; 1061| 4.71k| bool free_hashmaps = false; 1062| 4.71k| bool preserve_order = ((options & DNS_MESSAGEPARSE_PRESERVEORDER) != 0); ------------------ | | 200| 4.71k|#define DNS_MESSAGEPARSE_PRESERVEORDER 0x0001 /*%< preserve rdata order */ ------------------ 1063| 4.71k| bool best_effort = ((options & DNS_MESSAGEPARSE_BESTEFFORT) != 0); ------------------ | | 202| 4.71k| 0x0002 /*%< return a message if a \ ------------------ 1064| 4.71k| bool isedns, issigzero, istsig; 1065| 4.71k| isc_hashmap_t *name_map = NULL; 1066| | 1067| 4.71k| if (msg->counts[sectionid] > 1) { ------------------ | Branch (1067:6): [True: 0, False: 4.71k] ------------------ 1068| 0| isc_hashmap_create(msg->mctx, 1, &name_map); 1069| 0| } 1070| | 1071| 5.78k| for (count = 0; count < msg->counts[sectionid]; count++) { ------------------ | Branch (1071:18): [True: 1.55k, False: 4.23k] ------------------ 1072| 1.55k| int recstart = source->current; 1073| 1.55k| bool skip_name_search, skip_type_search; 1074| | 1075| 1.55k| skip_name_search = false; 1076| 1.55k| skip_type_search = false; 1077| 1.55k| isedns = false; 1078| 1.55k| issigzero = false; 1079| 1.55k| istsig = false; 1080| 1.55k| found_rdataset = NULL; 1081| | 1082| 1.55k| name = NULL; 1083| 1.55k| dns_message_gettempname(msg, &name); 1084| 1.55k| free_name = true; 1085| | 1086| | /* 1087| | * Parse the name out of this packet. 1088| | */ 1089| 1.55k| isc_buffer_remainingregion(source, &r); 1090| 1.55k| isc_buffer_setactive(source, r.length); 1091| 1.55k| CHECK(dns_name_fromwire(dns_name(name), source, ------------------ | | 255| 1.55k| { \ | | 256| 1.55k| result = (r); \ | | 257| 1.55k| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 1.55k] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 1.55k| } ------------------ 1092| 1.55k| DNS_DECOMPRESS_ALWAYS, NULL)); 1093| | 1094| | /* 1095| | * Get type, class, ttl, and rdatalen. Verify that at least 1096| | * rdatalen bytes remain. (Some of this is deferred to 1097| | * later.) 1098| | */ 1099| 1.55k| isc_buffer_remainingregion(source, &r); 1100| 1.55k| if (r.length < 2 + 2 + 4 + 2) { ------------------ | Branch (1100:7): [True: 0, False: 1.55k] ------------------ 1101| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1102| 0| } 1103| 1.55k| rdtype = isc_buffer_getuint16(source); 1104| 1.55k| rdclass = isc_buffer_getuint16(source); 1105| | 1106| | /* 1107| | * If there was no question section, we may not yet have 1108| | * established a class. Do so now. 1109| | */ 1110| 1.55k| if (msg->rdclass_set == 0 && ------------------ | Branch (1110:7): [True: 0, False: 1.55k] ------------------ 1111| 0| rdtype != dns_rdatatype_opt && /* class is UDP SIZE */ ------------------ | | 156| 1.55k|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1111:7): [True: 0, False: 0] ------------------ 1112| 0| rdtype != dns_rdatatype_tsig && /* class is ANY */ ------------------ | | 191| 1.55k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1112:7): [True: 0, False: 0] ------------------ 1113| 0| rdtype != dns_rdatatype_tkey) /* class is undefined */ ------------------ | | 190| 0|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1113:7): [True: 0, False: 0] ------------------ 1114| 0| { 1115| 0| msg->rdclass = rdclass; 1116| 0| msg->rdclass_set = 1; 1117| 0| } 1118| | 1119| | /* 1120| | * If this class is different than the one in the question 1121| | * section, bail. 1122| | */ 1123| 1.55k| if (msg->opcode != dns_opcode_update && ------------------ | Branch (1123:7): [True: 1.33k, False: 220] ------------------ 1124| 1.33k| rdtype != dns_rdatatype_tsig && ------------------ | | 191| 2.88k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1124:7): [True: 592, False: 740] ------------------ 1125| 592| rdtype != dns_rdatatype_opt && ------------------ | | 156| 2.14k|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1125:7): [True: 592, False: 0] ------------------ 1126| 592| rdtype != dns_rdatatype_key && /* in a TKEY query */ ------------------ | | 140| 2.14k|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ | Branch (1126:7): [True: 592, False: 0] ------------------ 1127| 592| rdtype != dns_rdatatype_sig && /* SIG(0) */ ------------------ | | 139| 2.14k|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ | Branch (1127:7): [True: 0, False: 592] ------------------ 1128| 0| rdtype != dns_rdatatype_tkey && /* Win2000 TKEY */ ------------------ | | 190| 1.55k|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1128:7): [True: 0, False: 0] ------------------ 1129| 0| msg->rdclass != dns_rdataclass_any && ------------------ | | 34| 1.55k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1129:7): [True: 0, False: 0] ------------------ 1130| 0| msg->rdclass != rdclass) ------------------ | Branch (1130:7): [True: 0, False: 0] ------------------ 1131| 0| { 1132| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1133| 0| } 1134| | 1135| | /* 1136| | * If this is not a TKEY query/response then the KEY 1137| | * record's class needs to match. 1138| | */ 1139| 1.55k| if (msg->opcode != dns_opcode_update && !msg->tkey && ------------------ | Branch (1139:7): [True: 1.33k, False: 220] | Branch (1139:43): [True: 1.33k, False: 0] ------------------ 1140| 1.33k| rdtype == dns_rdatatype_key && ------------------ | | 140| 2.88k|#define dns_rdatatype_key ((dns_rdatatype_t)dns_rdatatype_key) ------------------ | Branch (1140:7): [True: 0, False: 1.33k] ------------------ 1141| 0| msg->rdclass != dns_rdataclass_any && ------------------ | | 34| 1.55k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1141:7): [True: 0, False: 0] ------------------ 1142| 0| msg->rdclass != rdclass) ------------------ | Branch (1142:7): [True: 0, False: 0] ------------------ 1143| 0| { 1144| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1145| 0| } 1146| | 1147| | /* 1148| | * Special type handling for TSIG, OPT, and TKEY. 1149| | */ 1150| 1.55k| if (rdtype == dns_rdatatype_tsig) { ------------------ | | 191| 1.55k|#define dns_rdatatype_tsig ((dns_rdatatype_t)dns_rdatatype_tsig) ------------------ | Branch (1150:7): [True: 921, False: 631] ------------------ 1151| | /* 1152| | * If it is a tsig, verify that it is in the 1153| | * additional data section. 1154| | */ 1155| 921| if (sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1155:8): [True: 0, False: 921] ------------------ 1156| 921| rdclass != dns_rdataclass_any || ------------------ | | 34| 1.84k|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1156:8): [True: 0, False: 921] ------------------ 1157| 921| count != msg->counts[sectionid] - 1) ------------------ | Branch (1157:8): [True: 0, False: 921] ------------------ 1158| 0| { 1159| 0| DO_ERROR(DNS_R_BADTSIG); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1160| 921| } else { 1161| 921| skip_name_search = true; 1162| 921| skip_type_search = true; 1163| 921| istsig = true; 1164| 921| } 1165| 921| } else if (rdtype == dns_rdatatype_opt) { ------------------ | | 156| 631|#define dns_rdatatype_opt ((dns_rdatatype_t)dns_rdatatype_opt) ------------------ | Branch (1165:14): [True: 0, False: 631] ------------------ 1166| | /* 1167| | * The name of an OPT record must be ".", it 1168| | * must be in the additional data section, and 1169| | * it must be the first OPT we've seen. 1170| | */ 1171| 0| if (!dns_name_isroot(dns_linkedname_name(name)) || ------------------ | Branch (1171:8): [True: 0, False: 0] ------------------ 1172| 0| sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1172:8): [True: 0, False: 0] ------------------ 1173| 0| msg->opt != NULL) ------------------ | Branch (1173:8): [True: 0, False: 0] ------------------ 1174| 0| { 1175| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1176| 0| } else { 1177| 0| skip_name_search = true; 1178| 0| skip_type_search = true; 1179| 0| isedns = true; 1180| 0| } 1181| 631| } else if (rdtype == dns_rdatatype_tkey) { ------------------ | | 190| 631|#define dns_rdatatype_tkey ((dns_rdatatype_t)dns_rdatatype_tkey) ------------------ | Branch (1181:14): [True: 0, False: 631] ------------------ 1182| | /* 1183| | * A TKEY must be in the additional section if this 1184| | * is a query, and the answer section if this is a 1185| | * response. Unless it's a Win2000 client. 1186| | * 1187| | * Its class is ignored. 1188| | */ 1189| 0| dns_section_t tkeysection; 1190| | 1191| 0| if ((msg->flags & DNS_MESSAGEFLAG_QR) == 0) { ------------------ | Branch (1191:8): [True: 0, False: 0] ------------------ 1192| 0| tkeysection = DNS_SECTION_ADDITIONAL; 1193| 0| } else { 1194| 0| tkeysection = DNS_SECTION_ANSWER; 1195| 0| } 1196| 0| if (sectionid != tkeysection && ------------------ | Branch (1196:8): [True: 0, False: 0] ------------------ 1197| 0| sectionid != DNS_SECTION_ANSWER) ------------------ | Branch (1197:8): [True: 0, False: 0] ------------------ 1198| 0| { 1199| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1200| 0| } 1201| 0| } 1202| | 1203| | /* 1204| | * ... now get ttl and rdatalen, and check buffer. 1205| | */ 1206| 1.55k| ttl = isc_buffer_getuint32(source); 1207| 1.55k| rdatalen = isc_buffer_getuint16(source); 1208| 1.55k| r.length -= (2 + 2 + 4 + 2); 1209| 1.55k| if (r.length < rdatalen) { ------------------ | Branch (1209:7): [True: 0, False: 1.55k] ------------------ 1210| 0| CLEANUP(ISC_R_UNEXPECTEDEND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1211| 0| } 1212| | 1213| | /* 1214| | * Read the rdata from the wire format. Interpret the 1215| | * rdata according to its actual class, even if it had a 1216| | * DynDNS meta-class in the packet (unless this is a TSIG). 1217| | * Then put the meta-class back into the finished rdata. 1218| | */ 1219| 1.55k| rdata = newrdata(msg); 1220| 1.55k| if (msg->opcode == dns_opcode_update && ------------------ | Branch (1220:7): [True: 220, False: 1.33k] ------------------ 1221| 220| update(sectionid, rdclass)) ------------------ | Branch (1221:7): [True: 0, False: 220] ------------------ 1222| 0| { 1223| 0| if (rdatalen != 0) { ------------------ | Branch (1223:8): [True: 0, False: 0] ------------------ 1224| 0| CLEANUP(DNS_R_FORMERR); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1225| 0| } 1226| | /* 1227| | * When the rdata is empty, the data pointer is 1228| | * never dereferenced, but it must still be non-NULL. 1229| | * Casting 1 rather than "" avoids warnings about 1230| | * discarding the const attribute of a string, 1231| | * for compilers that would warn about such things. 1232| | */ 1233| 0| rdata->data = (unsigned char *)1; 1234| 0| rdata->length = 0; 1235| 0| rdata->rdclass = rdclass; 1236| 0| rdata->type = rdtype; 1237| 0| rdata->flags = DNS_RDATA_UPDATE; ------------------ | | 168| 0|#define DNS_RDATA_UPDATE 0x0001 /*%< update pseudo record. */ ------------------ 1238| 0| result = ISC_R_SUCCESS; 1239| 1.55k| } else if (rdclass == dns_rdataclass_none && ------------------ | | 32| 3.10k|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (1239:14): [True: 0, False: 1.55k] ------------------ 1240| 0| msg->opcode == dns_opcode_update && ------------------ | Branch (1240:7): [True: 0, False: 0] ------------------ 1241| 0| sectionid == DNS_SECTION_UPDATE) ------------------ | | 186| 0|#define DNS_SECTION_UPDATE DNS_SECTION_AUTHORITY ------------------ | Branch (1241:7): [True: 0, False: 0] ------------------ 1242| 0| { 1243| 0| result = getrdata(source, msg, msg->rdclass, rdtype, 1244| 0| rdatalen, rdata); 1245| 1.55k| } else { 1246| 1.55k| result = getrdata(source, msg, rdclass, rdtype, 1247| 1.55k| rdatalen, rdata); 1248| 1.55k| } 1249| 1.55k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1249:7): [True: 480, False: 1.07k] ------------------ 1250| 480| goto cleanup; 1251| 480| } 1252| 1.07k| rdata->rdclass = rdclass; 1253| 1.07k| if (rdtype == dns_rdatatype_rrsig && rdata->flags == 0) { ------------------ | | 161| 2.14k|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1253:7): [True: 0, False: 1.07k] | Branch (1253:40): [True: 0, False: 0] ------------------ 1254| 0| covers = dns_rdata_covers(rdata); 1255| | /* A signature can only cover a real rdata type */ 1256| 0| if (covers == dns_rdatatype_none || ------------------ | | 115| 0|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1256:8): [True: 0, False: 0] ------------------ 1257| 0| dns_rdatatype_ismeta(covers) || ------------------ | Branch (1257:8): [True: 0, False: 0] ------------------ 1258| 0| dns_rdatatype_issig(covers)) ------------------ | Branch (1258:8): [True: 0, False: 0] ------------------ 1259| 0| { 1260| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1261| 0| } 1262| 1.07k| } else if (rdtype == dns_rdatatype_sig /* SIG(0) */ && ------------------ | | 139| 2.14k|#define dns_rdatatype_sig ((dns_rdatatype_t)dns_rdatatype_sig) ------------------ | Branch (1262:14): [True: 512, False: 560] ------------------ 1263| 512| rdata->flags == 0) ------------------ | Branch (1263:7): [True: 512, False: 0] ------------------ 1264| 512| { 1265| 512| covers = dns_rdata_covers(rdata); 1266| 512| if (covers == dns_rdatatype_none) { ------------------ | | 115| 512|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1266:8): [True: 421, False: 91] ------------------ 1267| 421| if (sectionid != DNS_SECTION_ADDITIONAL || ------------------ | Branch (1267:9): [True: 0, False: 421] ------------------ 1268| 421| count != msg->counts[sectionid] - 1 || ------------------ | Branch (1268:9): [True: 0, False: 421] ------------------ 1269| 421| !dns_name_isroot(dns_linkedname_name(name))) ------------------ | Branch (1269:9): [True: 0, False: 421] ------------------ 1270| 0| { 1271| 0| DO_ERROR(DNS_R_BADSIG0); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1272| 421| } else { 1273| 421| skip_name_search = true; 1274| 421| skip_type_search = true; 1275| 421| issigzero = true; 1276| 421| } 1277| 421| } else { 1278| 91| covers = dns_rdatatype_none; ------------------ | | 115| 91|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1279| 91| } 1280| 560| } else { 1281| 560| covers = dns_rdatatype_none; ------------------ | | 115| 560|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 1282| 560| } 1283| | 1284| | /* 1285| | * Check the ownername of NSEC3 records 1286| | */ 1287| 1.07k| if (rdtype == dns_rdatatype_nsec3 && ------------------ | | 165| 2.14k|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1287:7): [True: 0, False: 1.07k] ------------------ 1288| 0| !dns_rdata_checkowner(name, msg->rdclass, rdtype, false)) ------------------ | | 836| 0| dns__rdata_checkowner(DNS_NAME__RO_ARG(name), rdclass, type, wildcard) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (1288:7): [True: 0, False: 0] ------------------ 1289| 0| { 1290| 0| CLEANUP(DNS_R_BADOWNERNAME); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1291| 0| } 1292| | 1293| | /* 1294| | * If we are doing a dynamic update or this is a meta-type, 1295| | * don't bother searching for a name, just append this one 1296| | * to the end of the message. 1297| | */ 1298| 1.07k| if (preserve_order || msg->opcode == dns_opcode_update || ------------------ | Branch (1298:7): [True: 0, False: 1.07k] | Branch (1298:25): [True: 158, False: 914] ------------------ 1299| 914| skip_name_search) ------------------ | Branch (1299:7): [True: 827, False: 87] ------------------ 1300| 985| { 1301| 985| if (!isedns && !istsig && !issigzero) { ------------------ | Branch (1301:8): [True: 985, False: 0] | Branch (1301:19): [True: 425, False: 560] | Branch (1301:30): [True: 4, False: 421] ------------------ 1302| 4| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 4| do { \ | | 101| 4| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 4| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 4| do { \ | | | | 89| 4| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 4] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 4| } else { \ | | | | 92| 4| (list).head = (elt); \ | | | | 93| 4| } \ | | | | 94| 4| (elt)->link.prev = (list).tail; \ | | | | 95| 4| (elt)->link.next = NULL; \ | | | | 96| 4| (list).tail = (elt); \ | | | | 97| 4| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 4] | | | | ------------------ | | ------------------ | | 103| 4| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 4] | | ------------------ ------------------ 1303| 4| free_name = false; 1304| 4| } 1305| 985| } else { 1306| 87| if (name_map == NULL) { ------------------ | Branch (1306:8): [True: 87, False: 0] ------------------ 1307| 87| result = ISC_R_SUCCESS; 1308| 87| goto skip_name_check; 1309| 87| } 1310| | 1311| | /* 1312| | * Run through the section, looking to see if this name 1313| | * is already there. If it is found, put back the 1314| | * allocated name since we no longer need it, and set 1315| | * our name pointer to point to the name we found. 1316| | */ 1317| 0| result = isc_hashmap_add(name_map, dns_name_hash(name), ------------------ | | 1531| 0|#define dns_name_hash(name) dns_name__hash(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1318| 0| name_match, name, name, 1319| 0| (void **)&found_name); 1320| | 1321| | /* 1322| | * If it is a new name, append to the section. 1323| | */ 1324| 87| skip_name_check: 1325| 87| switch (result) { 1326| 87| case ISC_R_SUCCESS: ------------------ | Branch (1326:4): [True: 87, False: 0] ------------------ 1327| 87| ISC_LIST_APPEND(*section, name, link); ------------------ | | 100| 87| do { \ | | 101| 87| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 87| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 87| do { \ | | | | 89| 87| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 87] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 87| } else { \ | | | | 92| 87| (list).head = (elt); \ | | | | 93| 87| } \ | | | | 94| 87| (elt)->link.prev = (list).tail; \ | | | | 95| 87| (elt)->link.next = NULL; \ | | | | 96| 87| (list).tail = (elt); \ | | | | 97| 87| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 87] | | | | ------------------ | | ------------------ | | 103| 87| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 87] | | ------------------ ------------------ 1328| 87| break; 1329| 0| case ISC_R_EXISTS: ------------------ | Branch (1329:4): [True: 0, False: 87] ------------------ 1330| 0| dns_message_puttempname(msg, &name); 1331| 0| name = found_name; 1332| 0| found_name = NULL; 1333| 0| break; 1334| 0| default: ------------------ | Branch (1334:4): [True: 0, False: 87] ------------------ 1335| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 1336| 87| } 1337| 87| free_name = false; 1338| 87| } 1339| | 1340| 1.07k| rdatalist = newrdatalist(msg); 1341| 1.07k| rdatalist->type = rdtype; 1342| 1.07k| rdatalist->covers = covers; 1343| 1.07k| rdatalist->rdclass = rdclass; 1344| 1.07k| rdatalist->ttl = ttl; 1345| | 1346| 1.07k| dns_message_gettemprdataset(msg, &rdataset); 1347| 1.07k| dns_rdatalist_tordataset(rdatalist, rdataset); 1348| 1.07k| dns_rdataset_setownercase(rdataset, name); ------------------ | | 599| 1.07k| dns__rdataset_setownercase(rdataset, DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 1.07k| _Generic((arg), \ | | | | 1508| 1.07k| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 1.07k| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 1.07k| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 1.07k| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 1.07k| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 1.07k| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1349| 1.07k| rdatalist = NULL; 1350| | 1351| | /* 1352| | * Search name for the particular type and class. 1353| | * Skip this stage if in update mode or this is a meta-type. 1354| | */ 1355| 1.07k| if (isedns || istsig || issigzero) { ------------------ | Branch (1355:7): [True: 0, False: 1.07k] | Branch (1355:17): [True: 560, False: 512] | Branch (1355:27): [True: 421, False: 91] ------------------ 1356| | /* Skip adding the rdataset to the tables */ 1357| 981| } else if (preserve_order || msg->opcode == dns_opcode_update || ------------------ | Branch (1357:14): [True: 0, False: 91] | Branch (1357:32): [True: 4, False: 87] ------------------ 1358| 87| skip_type_search) ------------------ | Branch (1358:7): [True: 0, False: 87] ------------------ 1359| 4| { 1360| 4| result = ISC_R_SUCCESS; 1361| | 1362| 4| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 4| do { \ | | 101| 4| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 4| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 4| do { \ | | | | 89| 4| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 4] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 4| } else { \ | | | | 92| 4| (list).head = (elt); \ | | | | 93| 4| } \ | | | | 94| 4| (elt)->link.prev = (list).tail; \ | | | | 95| 4| (elt)->link.next = NULL; \ | | | | 96| 4| (list).tail = (elt); \ | | | | 97| 4| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 4] | | | | ------------------ | | ------------------ | | 103| 4| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 4] | | ------------------ ------------------ 1363| 87| } else { 1364| | /* 1365| | * If this is a type that can only occur in 1366| | * the question section, fail. 1367| | */ 1368| 87| if (dns_rdatatype_questiononly(rdtype)) { ------------------ | Branch (1368:8): [True: 0, False: 87] ------------------ 1369| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1370| 0| } 1371| | 1372| 87| if (ISC_LIST_EMPTY(name->list)) { ------------------ | | 64| 87|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (64:30): [True: 87, False: 0] | | ------------------ ------------------ 1373| 87| result = ISC_R_SUCCESS; 1374| 87| goto skip_rds_check; 1375| 87| } 1376| | 1377| 0| if (name->hashmap == NULL) { ------------------ | Branch (1377:8): [True: 0, False: 0] ------------------ 1378| 0| isc_hashmap_create(msg->mctx, 1, 1379| 0| &name->hashmap); 1380| 0| free_hashmaps = true; 1381| | 1382| 0| INSIST(ISC_LIST_HEAD(name->list) == ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1383| 0| ISC_LIST_TAIL(name->list)); 1384| | 1385| 0| dns_rdataset_t *old_rdataset = 1386| 0| ISC_LIST_HEAD(name->list); ------------------ | | 62| 0|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1387| | 1388| 0| result = isc_hashmap_add( 1389| 0| name->hashmap, rds_hash(old_rdataset), 1390| 0| rds_match, old_rdataset, old_rdataset, 1391| 0| NULL); 1392| | 1393| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1394| 0| } 1395| | 1396| 0| result = isc_hashmap_add( 1397| 0| name->hashmap, rds_hash(rdataset), rds_match, 1398| 0| rdataset, rdataset, (void **)&found_rdataset); 1399| | 1400| | /* 1401| | * If we found an rdataset that matches, we need to 1402| | * append this rdata to that set. If we did not, we 1403| | * need to create a new rdatalist, store the important 1404| | * bits there, convert it to an rdataset, and link the 1405| | * latter to the name. Yuck. When appending, make 1406| | * certain that the type isn't a singleton type, such as 1407| | * SOA or CNAME. 1408| | * 1409| | * Note that this check will be bypassed when preserving 1410| | * order, the opcode is an update, or the type search is 1411| | * skipped. 1412| | */ 1413| 87| skip_rds_check: 1414| 87| switch (result) { 1415| 0| case ISC_R_EXISTS: ------------------ | Branch (1415:4): [True: 0, False: 87] ------------------ 1416| | /* Free the rdataset we used as the key */ 1417| 0| dns__message_putassociatedrdataset(msg, 1418| 0| &rdataset); 1419| 0| result = ISC_R_SUCCESS; 1420| 0| rdataset = found_rdataset; 1421| | 1422| 0| if (dns_rdatatype_issingleton(rdtype)) { ------------------ | Branch (1422:9): [True: 0, False: 0] ------------------ 1423| 0| if (!best_effort) { ------------------ | Branch (1423:10): [True: 0, False: 0] ------------------ 1424| 0| dns_message_puttemprdata( 1425| 0| msg, &rdata); 1426| 0| } 1427| 0| DO_ERROR(DNS_R_FORMERR); ------------------ | | 901| 0| do { \ | | 902| 0| if (best_effort) { \ | | ------------------ | | | Branch (902:7): [True: 0, False: 0] | | ------------------ | | 903| 0| seen_problem = true; \ | | 904| 0| } else { \ | | 905| 0| result = r; \ | | 906| 0| goto cleanup; \ | | 907| 0| } \ | | 908| 0| } while (0) | | ------------------ | | | Branch (908:11): [Folded, False: 0] | | ------------------ ------------------ 1428| 0| } 1429| 0| break; 1430| 87| case ISC_R_SUCCESS: ------------------ | Branch (1430:4): [True: 87, False: 0] ------------------ 1431| 87| ISC_LIST_APPEND(name->list, rdataset, link); ------------------ | | 100| 87| do { \ | | 101| 87| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 87| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 87| do { \ | | | | 89| 87| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 87] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 87| } else { \ | | | | 92| 87| (list).head = (elt); \ | | | | 93| 87| } \ | | | | 94| 87| (elt)->link.prev = (list).tail; \ | | | | 95| 87| (elt)->link.next = NULL; \ | | | | 96| 87| (list).tail = (elt); \ | | | | 97| 87| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 87] | | | | ------------------ | | ------------------ | | 103| 87| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 87] | | ------------------ ------------------ 1432| 87| break; 1433| 0| default: ------------------ | Branch (1433:4): [True: 0, False: 87] ------------------ 1434| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 1435| 87| } 1436| 87| } 1437| | 1438| | /* 1439| | * Minimize TTLs. 1440| | * 1441| | * Section 5.2 of RFC2181 says we should drop 1442| | * nonauthoritative rrsets where the TTLs differ, but we 1443| | * currently treat them the as if they were authoritative and 1444| | * minimize them. 1445| | */ 1446| 1.07k| if (ttl != rdataset->ttl) { ------------------ | Branch (1446:7): [True: 0, False: 1.07k] ------------------ 1447| 0| rdataset->attributes.ttladjusted = true; 1448| 0| if (ttl < rdataset->ttl) { ------------------ | Branch (1448:8): [True: 0, False: 0] ------------------ 1449| 0| rdataset->ttl = ttl; 1450| 0| } 1451| 0| } 1452| | 1453| | /* Append this rdata to the rdataset. */ 1454| 1.07k| if (rdata != NULL) { ------------------ | Branch (1454:7): [True: 1.07k, False: 0] ------------------ 1455| 1.07k| dns_rdatalist_fromrdataset(rdataset, &rdatalist); 1456| 1.07k| ISC_LIST_APPEND(rdatalist->rdata, rdata, link); ------------------ | | 100| 1.07k| do { \ | | 101| 1.07k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.07k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.07k| do { \ | | | | 89| 1.07k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.07k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.07k| } else { \ | | | | 92| 1.07k| (list).head = (elt); \ | | | | 93| 1.07k| } \ | | | | 94| 1.07k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.07k| (elt)->link.next = NULL; \ | | | | 96| 1.07k| (list).tail = (elt); \ | | | | 97| 1.07k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.07k] | | | | ------------------ | | ------------------ | | 103| 1.07k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.07k] | | ------------------ ------------------ 1457| 1.07k| } 1458| | 1459| | /* 1460| | * If this is an OPT, SIG(0) or TSIG record, remember it. 1461| | * Also, set the extended rcode for TSIG. 1462| | * 1463| | * Note msg->opt, msg->sig0 and msg->tsig will only be 1464| | * already set if best-effort parsing is enabled otherwise 1465| | * there will only be at most one of each. 1466| | */ 1467| 1.07k| if (isedns) { ------------------ | Branch (1467:7): [True: 0, False: 1.07k] ------------------ 1468| 0| dns_rcode_t ercode; 1469| | 1470| 0| msg->opt = rdataset; 1471| 0| ercode = (dns_rcode_t)((msg->opt->ttl & 1472| 0| DNS_MESSAGE_EDNSRCODE_MASK) >> ------------------ | | 90| 0|#define DNS_MESSAGE_EDNSRCODE_MASK 0xff000000U ------------------ 1473| 0| 20); 1474| 0| msg->rcode |= ercode; 1475| 0| dns_message_puttempname(msg, &name); 1476| 0| free_name = false; 1477| 1.07k| } else if (issigzero) { ------------------ | Branch (1477:14): [True: 421, False: 651] ------------------ 1478| 421| msg->sig0 = rdataset; 1479| 421| msg->sig0name = name; 1480| 421| msg->sigstart = recstart; 1481| 421| free_name = false; 1482| 651| } else if (istsig) { ------------------ | Branch (1482:14): [True: 560, False: 91] ------------------ 1483| 560| msg->tsig = rdataset; 1484| 560| msg->tsigname = name; 1485| 560| msg->sigstart = recstart; 1486| | /* 1487| | * Windows doesn't like TSIG names to be compressed. 1488| | */ 1489| 560| dns_linkedname_attrs(msg->tsigname)->nocompress = true; 1490| 560| free_name = false; 1491| 560| } else if (rdtype == dns_rdatatype_dname && ------------------ | | 154| 182|#define dns_rdatatype_dname ((dns_rdatatype_t)dns_rdatatype_dname) ------------------ | Branch (1491:14): [True: 0, False: 91] ------------------ 1492| 0| sectionid == DNS_SECTION_ANSWER && ------------------ | Branch (1492:7): [True: 0, False: 0] ------------------ 1493| 0| msg->opcode == dns_opcode_query) ------------------ | Branch (1493:7): [True: 0, False: 0] ------------------ 1494| 0| { 1495| 0| msg->has_dname = 1; 1496| 0| } 1497| 1.07k| rdataset = NULL; 1498| | 1499| 1.07k| if (seen_problem) { ------------------ | Branch (1499:7): [True: 0, False: 1.07k] ------------------ 1500| 0| if (free_name) { ------------------ | Branch (1500:8): [True: 0, False: 0] ------------------ 1501| | /* XXX test coverage */ 1502| 0| dns_message_puttempname(msg, &name); 1503| 0| } 1504| 0| free_name = false; 1505| 0| } 1506| 1.07k| INSIST(!free_name); ------------------ | | 202| 1.07k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 1.07k, False: 0] | | | | ------------------ | | | | 54| 1.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1507| 1.07k| } 1508| | 1509| 4.23k| if (seen_problem) { ------------------ | Branch (1509:6): [True: 0, False: 4.23k] ------------------ 1510| 0| result = DNS_R_RECOVERABLE; 1511| 0| } 1512| | 1513| 4.71k|cleanup: 1514| 4.71k| if (rdataset != NULL && rdataset != found_rdataset) { ------------------ | Branch (1514:6): [True: 0, False: 4.71k] | Branch (1514:26): [True: 0, False: 0] ------------------ 1515| 0| dns__message_putassociatedrdataset(msg, &rdataset); 1516| 0| } 1517| 4.71k| if (free_name) { ------------------ | Branch (1517:6): [True: 480, False: 4.23k] ------------------ 1518| 480| dns_message_puttempname(msg, &name); 1519| 480| } 1520| | 1521| 4.71k| if (free_hashmaps) { ------------------ | Branch (1521:6): [True: 0, False: 4.71k] ------------------ 1522| 0| cleanup_name_hashmaps(section); 1523| 0| } 1524| | 1525| 4.71k| if (name_map != NULL) { ------------------ | Branch (1525:6): [True: 0, False: 4.71k] ------------------ 1526| 0| isc_hashmap_destroy(&name_map); 1527| 0| } 1528| | 1529| 4.71k| return result; 1530| 4.23k|} message.c:update: 1033| 220|update(dns_section_t section, dns_rdataclass_t rdclass) { 1034| 220| if (section == DNS_SECTION_PREREQUISITE) { ------------------ | | 185| 220|#define DNS_SECTION_PREREQUISITE DNS_SECTION_ANSWER ------------------ | Branch (1034:6): [True: 0, False: 220] ------------------ 1035| 0| return rdclass == dns_rdataclass_any || ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (1035:10): [True: 0, False: 0] ------------------ 1036| 0| rdclass == dns_rdataclass_none; ------------------ | | 32| 0|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (1036:10): [True: 0, False: 0] ------------------ 1037| 0| } 1038| 220| if (section == DNS_SECTION_UPDATE) { ------------------ | | 186| 220|#define DNS_SECTION_UPDATE DNS_SECTION_AUTHORITY ------------------ | Branch (1038:6): [True: 0, False: 220] ------------------ 1039| 0| return rdclass == dns_rdataclass_any; ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ 1040| 0| } 1041| 220| return false; 1042| 220|} message.c:getrdata: 843| 1.55k| dns_rdatatype_t rdtype, unsigned int rdatalen, dns_rdata_t *rdata) { 844| 1.55k| isc_buffer_t *scratch; 845| 1.55k| isc_result_t result; 846| 1.55k| unsigned int tries; 847| 1.55k| unsigned int trysize; 848| | 849| 1.55k| scratch = currentbuffer(msg); 850| | 851| 1.55k| isc_buffer_setactive(source, rdatalen); 852| | 853| | /* 854| | * First try: use current buffer. 855| | * Second try: allocate a new buffer of size 856| | * max(SCRATCHPAD_SIZE, 2 * compressed_rdatalen) 857| | * (the data will fit if it was not more than 50% compressed) 858| | * Subsequent tries: double buffer size on each try. 859| | */ 860| 1.55k| tries = 0; 861| 1.55k| trysize = 0; 862| | /* XXX possibly change this to a while (tries < 2) loop */ 863| 1.92k| for (;;) { 864| 1.92k| result = dns_rdata_fromwire(rdata, rdclass, rdtype, source, 865| 1.92k| DNS_DECOMPRESS_DEFAULT, scratch); 866| | 867| 1.92k| if (result == ISC_R_NOSPACE) { ------------------ | Branch (867:7): [True: 368, False: 1.55k] ------------------ 868| 368| if (tries == 0) { ------------------ | Branch (868:8): [True: 368, False: 0] ------------------ 869| 368| trysize = 2 * rdatalen; 870| 368| if (trysize < SCRATCHPAD_SIZE) { ------------------ | | 125| 368|#define SCRATCHPAD_SIZE 1232 ------------------ | Branch (870:9): [True: 0, False: 368] ------------------ 871| 0| trysize = SCRATCHPAD_SIZE; ------------------ | | 125| 0|#define SCRATCHPAD_SIZE 1232 ------------------ 872| 0| } 873| 368| } else { 874| 0| INSIST(trysize != 0); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 875| 0| if (trysize >= 65535) { ------------------ | Branch (875:9): [True: 0, False: 0] ------------------ 876| 0| return ISC_R_NOSPACE; 877| 0| } 878| | /* XXX DNS_R_RRTOOLONG? */ 879| 0| trysize *= 2; 880| 0| } 881| 368| tries++; 882| 368| newbuffer(msg, trysize); 883| | 884| 368| scratch = currentbuffer(msg); 885| 1.55k| } else if (result == DNS_R_DISALLOWED) { ------------------ | Branch (885:14): [True: 9, False: 1.54k] ------------------ 886| | /* 887| | * A compression pointer in a type whose 888| | * specification forbids one (RFC 3597 section 4) 889| | * is a malformed message, not something we have 890| | * declined by policy, so report it the way every 891| | * other bad name is reported: as a format error. 892| | */ 893| 9| return DNS_R_FORMERR; 894| 1.54k| } else { 895| 1.54k| return result; 896| 1.54k| } 897| 1.92k| } 898| 1.55k|} message.c:currentbuffer: 321| 1.92k|currentbuffer(dns_message_t *msg) { 322| 1.92k| isc_buffer_t *dynbuf; 323| | 324| 1.92k| dynbuf = ISC_LIST_TAIL(msg->scratchpad); ------------------ | | 63| 1.92k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 325| 1.92k| INSIST(dynbuf != NULL); ------------------ | | 202| 1.92k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 1.92k, False: 0] | | | | ------------------ | | | | 54| 1.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 326| | 327| 1.92k| return dynbuf; 328| 1.92k|} message.c:newbuffer: 312| 368|newbuffer(dns_message_t *msg, unsigned int size) { 313| 368| isc_buffer_t *dynbuf = NULL; 314| | 315| 368| isc_buffer_allocate(msg->mctx, &dynbuf, size); 316| | 317| | 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] | | ------------------ ------------------ 318| 368|} message.c:msgresetnames: 474| 1.57k|msgresetnames(dns_message_t *msg, unsigned int first_section) { 475| | /* Clean up name lists. */ 476| 7.88k| for (size_t i = first_section; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (476:33): [True: 6.30k, False: 1.57k] ------------------ 477| 6.30k| ISC_LIST_FOREACH(msg->sections[i], name, link) { ------------------ | | 234| 6.30k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 6.30k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 6.30k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 1.66k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 1.66k, False: 4.64k] | | ------------------ | | 236| 7.97k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 1.66k, False: 6.30k] | | ------------------ | | 237| 6.30k| elt = elt##_next, \ | | 238| 1.66k| 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.66k] | | ------------------ ------------------ 478| | ISC_LIST_UNLINK(msg->sections[i], name, link); ------------------ | | 137| 1.66k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.66k| do { \ | | | | 133| 1.66k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.66k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.66k| do { \ | | | | | | 110| 1.66k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.66k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.66k| } else { \ | | | | | | 113| 1.66k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.66k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.66k| } \ | | | | | | 116| 1.66k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.66k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.66k| } else { \ | | | | | | 119| 1.66k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.66k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.66k| } \ | | | | | | 122| 1.66k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.66k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.66k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.66k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.66k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.66k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.66k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.66k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.66k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.66k] | | | | ------------------ | | ------------------ ------------------ 479| 1.66k| msgresetname(msg, name); 480| 1.66k| dns_message_puttempname(msg, &name); 481| 1.66k| } 482| 6.30k| } 483| 1.57k|} message.c:msgresetname: 466| 1.66k|msgresetname(dns_message_t *msg, dns_linkedname_t *name) { 467| 1.66k| ISC_LIST_FOREACH(name->list, rds, link) { ------------------ | | 234| 1.66k| for (typeof((list).head) elt = ISC_LIST_HEAD(list), \ | | ------------------ | | | | 62| 1.66k|#define ISC_LIST_HEAD(list) ((list).head) | | ------------------ | | 235| 1.66k| elt##_next = (elt != NULL) ? ISC_LIST_NEXT(elt, link) : NULL; \ | | ------------------ | | | | 140| 1.66k|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) | | ------------------ | | | Branch (235:20): [True: 1.66k, False: 0] | | ------------------ | | 236| 3.32k| elt != NULL; \ | | ------------------ | | | Branch (236:7): [True: 1.66k, False: 1.66k] | | ------------------ | | 237| 1.66k| elt = elt##_next, \ | | 238| 1.66k| 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.66k] | | ------------------ ------------------ 468| | ISC_LIST_UNLINK(name->list, rds, link); ------------------ | | 137| 1.66k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 1.66k| do { \ | | | | 133| 1.66k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 1.66k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 1.66k| do { \ | | | | | | 110| 1.66k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 1.66k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 1.66k| } else { \ | | | | | | 113| 1.66k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 114| 1.66k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 1.66k| } \ | | | | | | 116| 1.66k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 0, False: 1.66k] | | | | | | ------------------ | | | | | | 117| 0| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.66k| } else { \ | | | | | | 119| 1.66k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.66k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.66k| } \ | | | | | | 122| 1.66k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.66k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 1.66k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 1.66k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 1.66k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 1.66k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.66k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.66k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.66k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 1.66k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 1.66k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 1.66k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 1.66k] | | | | ------------------ | | ------------------ ------------------ 469| 1.66k| dns__message_putassociatedrdataset(msg, &rds); 470| 1.66k| } 471| 1.66k|} message.c:newrdata: 336| 1.80k|newrdata(dns_message_t *msg) { 337| 1.80k| dns_msgblock_t *msgblock; 338| 1.80k| dns_rdata_t *rdata; 339| | 340| 1.80k| rdata = ISC_LIST_HEAD(msg->freerdata); ------------------ | | 62| 1.80k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 341| 1.80k| if (rdata != NULL) { ------------------ | Branch (341:6): [True: 0, False: 1.80k] ------------------ 342| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 343| 0| dns_rdata_reset(rdata); 344| 0| return rdata; 345| 0| } 346| | 347| 1.80k| msgblock = ISC_LIST_TAIL(msg->rdatas); ------------------ | | 63| 1.80k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 348| 1.80k| rdata = msgblock_get(msgblock, dns_rdata_t); ------------------ | | 205| 1.80k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 349| 1.80k| if (rdata == NULL) { ------------------ | Branch (349:6): [True: 1.55k, False: 247] ------------------ 350| 1.55k| msgblock = msgblock_allocate(msg->mctx, sizeof(dns_rdata_t), 351| 1.55k| RDATA_COUNT); ------------------ | | 129| 1.55k|#define RDATA_COUNT 8 ------------------ 352| 1.55k| ISC_LIST_APPEND(msg->rdatas, msgblock, link); ------------------ | | 100| 1.55k| do { \ | | 101| 1.55k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.55k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.55k| do { \ | | | | 89| 1.55k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.55k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.55k| } else { \ | | | | 92| 1.55k| (list).head = (elt); \ | | | | 93| 1.55k| } \ | | | | 94| 1.55k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.55k| (elt)->link.next = NULL; \ | | | | 96| 1.55k| (list).tail = (elt); \ | | | | 97| 1.55k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.55k] | | | | ------------------ | | ------------------ | | 103| 1.55k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.55k] | | ------------------ ------------------ 353| | 354| 1.55k| rdata = msgblock_get(msgblock, dns_rdata_t); ------------------ | | 205| 1.55k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 355| 1.55k| } 356| | 357| 1.80k| dns_rdata_init(rdata); 358| 1.80k| return rdata; 359| 1.80k|} message.c:msgblock_internalget: 273| 7.81k|msgblock_internalget(dns_msgblock_t *block, unsigned int sizeof_type) { 274| 7.81k| void *ptr; 275| | 276| 7.81k| if (block == NULL || block->remaining == 0) { ------------------ | Branch (276:6): [True: 3.12k, False: 4.69k] | Branch (276:23): [True: 0, False: 4.69k] ------------------ 277| 3.12k| return NULL; 278| 3.12k| } 279| | 280| 4.69k| block->remaining--; 281| | 282| 4.69k| ptr = (((unsigned char *)block) + sizeof(dns_msgblock_t) + 283| 4.69k| (sizeof_type * block->remaining)); 284| | 285| 4.69k| return ptr; 286| 7.81k|} message.c:msgblock_allocate: 252| 3.12k| unsigned int count) { 253| 3.12k| dns_msgblock_t *block; 254| 3.12k| unsigned int length; 255| | 256| 3.12k| length = sizeof(dns_msgblock_t) + (sizeof_type * count); 257| | 258| 3.12k| block = isc_mem_get(mctx, length); ------------------ | | 144| 3.12k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 259| | 260| 3.12k| block->count = count; 261| 3.12k| block->remaining = count; 262| | 263| 3.12k| ISC_LINK_INIT(block, link); ------------------ | | 57| 3.12k|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 3.12k| do { \ | | | | 54| 3.12k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 3.12k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 3.12k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 3.12k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 3.12k| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 3.12k] | | | | ------------------ | | ------------------ ------------------ 264| | 265| 3.12k| return block; 266| 3.12k|} message.c:newrdatalist: 367| 2.89k|newrdatalist(dns_message_t *msg) { 368| 2.89k| dns_msgblock_t *msgblock; 369| 2.89k| dns_rdatalist_t *rdatalist; 370| | 371| 2.89k| rdatalist = ISC_LIST_HEAD(msg->freerdatalist); ------------------ | | 62| 2.89k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 372| 2.89k| if (rdatalist != NULL) { ------------------ | Branch (372:6): [True: 0, False: 2.89k] ------------------ 373| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 374| 0| dns_rdatalist_init(rdatalist); 375| 0| goto out; 376| 0| } 377| | 378| 2.89k| msgblock = ISC_LIST_TAIL(msg->rdatalists); ------------------ | | 63| 2.89k|#define ISC_LIST_TAIL(list) ((list).tail) ------------------ 379| 2.89k| rdatalist = msgblock_get(msgblock, dns_rdatalist_t); ------------------ | | 205| 2.89k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 380| 2.89k| if (rdatalist == NULL) { ------------------ | Branch (380:6): [True: 1.57k, False: 1.32k] ------------------ 381| 1.57k| msgblock = msgblock_allocate(msg->mctx, sizeof(dns_rdatalist_t), 382| 1.57k| RDATALIST_COUNT); ------------------ | | 130| 1.57k|#define RDATALIST_COUNT 8 ------------------ 383| 1.57k| ISC_LIST_APPEND(msg->rdatalists, msgblock, link); ------------------ | | 100| 1.57k| do { \ | | 101| 1.57k| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 102| 1.57k| __ISC_LIST_APPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 88| 1.57k| do { \ | | | | 89| 1.57k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 0, False: 1.57k] | | | | ------------------ | | | | 90| 0| (list).tail->link.next = (elt); \ | | | | 91| 1.57k| } else { \ | | | | 92| 1.57k| (list).head = (elt); \ | | | | 93| 1.57k| } \ | | | | 94| 1.57k| (elt)->link.prev = (list).tail; \ | | | | 95| 1.57k| (elt)->link.next = NULL; \ | | | | 96| 1.57k| (list).tail = (elt); \ | | | | 97| 1.57k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 1.57k] | | | | ------------------ | | ------------------ | | 103| 1.57k| } while (0) | | ------------------ | | | Branch (103:11): [Folded, False: 1.57k] | | ------------------ ------------------ 384| | 385| 1.57k| rdatalist = msgblock_get(msgblock, dns_rdatalist_t); ------------------ | | 205| 1.57k| ((type *)msgblock_internalget(block, sizeof(type))) ------------------ 386| 1.57k| } 387| 2.89k|out: 388| 2.89k| dns_rdatalist_init(rdatalist); 389| 2.89k| return rdatalist; 390| 2.89k|} message.c:dns__message_putassociatedrdataset: 2471| 2.89k|dns__message_putassociatedrdataset(dns_message_t *msg, dns_rdataset_t **item) { 2472| 2.89k| dns_rdataset_disassociate(*item); ------------------ | | 306| 2.89k| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 2473| 2.89k| dns_message_puttemprdataset(msg, item); 2474| 2.89k|} message.c:msgresetopt: 486| 1.57k|msgresetopt(dns_message_t *msg) { 487| 1.57k| if (msg->opt != NULL) { ------------------ | Branch (487:6): [True: 0, False: 1.57k] ------------------ 488| 0| if (msg->opt_reserved > 0) { ------------------ | Branch (488:7): [True: 0, False: 0] ------------------ 489| 0| dns_message_renderrelease(msg, msg->opt_reserved); 490| 0| msg->opt_reserved = 0; 491| 0| } 492| 0| dns__message_putassociatedrdataset(msg, &msg->opt); 493| | msg->opt = NULL; 494| 0| msg->cc_ok = 0; 495| 0| msg->cc_bad = 0; 496| 0| } 497| 1.57k|} message.c:msgresetsigs: 500| 1.57k|msgresetsigs(dns_message_t *msg, bool replying) { 501| 1.57k| if (msg->sig_reserved > 0) { ------------------ | Branch (501:6): [True: 0, False: 1.57k] ------------------ 502| 0| dns_message_renderrelease(msg, msg->sig_reserved); 503| 0| msg->sig_reserved = 0; 504| 0| } 505| 1.57k| if (msg->tsig != NULL) { ------------------ | Branch (505:6): [True: 560, False: 1.01k] ------------------ 506| 560| INSIST(dns_rdataset_isassociated(msg->tsig)); ------------------ | | 202| 560|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 560| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 560, False: 0] | | | | ------------------ | | | | 54| 560| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 507| 560| INSIST(msg->namepool != NULL); ------------------ | | 202| 560|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 560| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 560, False: 0] | | | | ------------------ | | | | 54| 560| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 508| 560| if (replying) { ------------------ | Branch (508:7): [True: 0, False: 560] ------------------ 509| 0| INSIST(msg->querytsig == NULL); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 510| 0| msg->querytsig = msg->tsig; 511| 560| } else { 512| 560| dns__message_putassociatedrdataset(msg, &msg->tsig); 513| 560| if (msg->querytsig != NULL) { ------------------ | Branch (513:8): [True: 193, False: 367] ------------------ 514| 193| dns__message_putassociatedrdataset( 515| 193| msg, &msg->querytsig); 516| 193| } 517| 560| } 518| 560| dns_message_puttempname(msg, &msg->tsigname); 519| 560| msg->tsig = NULL; 520| 1.01k| } else if (msg->querytsig != NULL && !replying) { ------------------ | Branch (520:13): [True: 56, False: 961] | Branch (520:39): [True: 56, False: 0] ------------------ 521| 56| dns__message_putassociatedrdataset(msg, &msg->querytsig); 522| 56| msg->querytsig = NULL; 523| 56| } 524| 1.57k| if (msg->sig0 != NULL) { ------------------ | Branch (524:6): [True: 421, False: 1.15k] ------------------ 525| 421| dns__message_putassociatedrdataset(msg, &msg->sig0); 526| 421| msg->sig0 = NULL; 527| 421| } 528| 1.57k| if (msg->sig0name != NULL) { ------------------ | Branch (528:6): [True: 421, False: 1.15k] ------------------ 529| 421| dns_message_puttempname(msg, &msg->sig0name); 530| 421| } 531| 1.57k|} message.c:msginitprivate: 402| 1.57k|msginitprivate(dns_message_t *m) { 403| 1.57k| unsigned int i; 404| | 405| 7.88k| for (i = 0; i < DNS_SECTION_MAX; i++) { ------------------ | Branch (405:14): [True: 6.30k, False: 1.57k] ------------------ 406| 6.30k| m->cursors[i] = NULL; 407| 6.30k| m->counts[i] = 0; 408| 6.30k| } 409| 1.57k| m->opt = NULL; 410| 1.57k| m->sig0 = NULL; 411| 1.57k| m->sig0name = NULL; 412| 1.57k| m->tsig = NULL; 413| 1.57k| m->tsigname = NULL; 414| 1.57k| m->state = DNS_SECTION_ANY; /* indicate nothing parsed or rendered */ 415| 1.57k| m->opt_reserved = 0; 416| 1.57k| m->sig_reserved = 0; 417| 1.57k| m->reserved = 0; 418| 1.57k| m->padding = 0; 419| 1.57k| m->padding_off = 0; 420| | m->buffer = NULL; 421| 1.57k|} message.c:msgresetedns: 534| 1.57k|msgresetedns(dns_message_t *msg) { 535| 1.57k| if (msg->edns.opts != NULL) { ------------------ | Branch (535:6): [True: 0, False: 1.57k] ------------------ 536| 0| INSIST(msg->edns.maxopts != 0); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 537| 0| for (size_t i = 0; i < msg->edns.count; i++) { ------------------ | Branch (537:22): [True: 0, False: 0] ------------------ 538| 0| if (msg->edns.opts[i].value != NULL) { ------------------ | Branch (538:8): [True: 0, False: 0] ------------------ 539| 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] | | ------------------ ------------------ 540| 0| msg->edns.opts[i].length); 541| 0| } 542| 0| } 543| | 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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] | | ------------------ ------------------ 544| 0| (size_t)msg->edns.maxopts, sizeof(dns_ednsopt_t)); 545| 0| } 546| 1.57k| msg->edns.maxopts = 0; 547| 1.57k| msg->edns.count = 0; 548| 1.57k|} dns_name_hasbuffer: 120| 208|dns_name_hasbuffer(const dns_name_t *name) { 121| | /* 122| | * Does 'name' have a dedicated buffer? 123| | */ 124| | 125| 208| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 126| | 127| 208| if (name->buffer != NULL) { ------------------ | Branch (127:6): [True: 208, False: 0] ------------------ 128| 208| return true; 129| 208| } 130| | 131| 0| return false; 132| 208|} dns_name__isabsolute: 135| 96|dns_name__isabsolute(const dns_name_t *name) { 136| | /* 137| | * Does 'name' end in the root label? 138| | */ 139| | 140| 96| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 96, False: 0] | | | | | Branch (41:11): [True: 96, False: 0] | | | | ------------------ | | | | 42| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 141| | 142| 96| return name->attributes.absolute; 143| 96|} dns_name__iswildcard: 259| 6|dns_name__iswildcard(const dns_name_t *name) { 260| 6| unsigned char *ndata; 261| | 262| | /* 263| | * Is 'name' a wildcard name? 264| | */ 265| | 266| 6| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 267| 6| REQUIRE(name->length > 0); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 268| | 269| 6| if (name->length >= 2) { ------------------ | Branch (269:6): [True: 6, False: 0] ------------------ 270| 6| ndata = name->ndata; 271| 6| if (ndata[0] == 1 && ndata[1] == '*') { ------------------ | Branch (271:7): [True: 0, False: 6] | Branch (271:24): [True: 0, False: 0] ------------------ 272| 0| return true; 273| 0| } 274| 6| } 275| | 276| 6| return false; 277| 6|} dns_name_hash_ex: 315| 590|dns_name_hash_ex(isc_hash32_t *hash, const dns_name_t *name) { 316| 590| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 590|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 590, False: 0] | | | | | Branch (41:11): [True: 590, False: 0] | | | | ------------------ | | | | 42| 590| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 317| | 318| | isc_hash32_hash(hash, name->ndata, name->length, false); 319| 590|} dns_name__hash: 322| 590|dns_name__hash(const dns_name_t *name) { 323| 590| isc_hash32_t hash; 324| | 325| 590| isc_hash32_init(&hash); 326| | 327| 590| dns_name_hash_ex(&hash, name); 328| | 329| 590| return isc_hash32_finalize(&hash); 330| 590|} dns_name__fullcompare: 334| 14| int *orderp, unsigned int *nlabelsp) { 335| 14| unsigned int l1, l2, l, count1, count2, count, nlabels; 336| 14| int cdiff, ldiff, diff; 337| 14| unsigned char *label1, *label2; 338| 14| dns_offsets_t offsets1, offsets2; 339| 14| dns_namereln_t namereln = dns_namereln_none; 340| | 341| | /* 342| | * Determine the relative ordering under the DNSSEC order relation of 343| | * 'name1' and 'name2', and also determine the hierarchical 344| | * relationship of the names. 345| | * 346| | * Note: It makes no sense for one of the names to be relative and the 347| | * other absolute. If both names are relative, then to be meaningfully 348| | * compared the caller must ensure that they are both relative to the 349| | * same domain. 350| | */ 351| | 352| 14| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 353| 14| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 354| 14| REQUIRE(orderp != NULL); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 355| 14| REQUIRE(nlabelsp != NULL); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 356| | /* 357| | * Either name1 is absolute and name2 is absolute, or neither is. 358| | */ 359| 14| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 360| | 361| 14| if (name1 == name2) { ------------------ | Branch (361:6): [True: 0, False: 14] ------------------ 362| 0| *orderp = 0; 363| 0| *nlabelsp = dns_name_countlabels(name1); ------------------ | | 1546| 0|#define dns_name_countlabels(name) dns_name__countlabels(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 364| | 365| 0| return dns_namereln_equal; 366| 0| } 367| | 368| 14| l1 = dns_name_offsets(name1, offsets1); 369| 14| l2 = dns_name_offsets(name2, offsets2); 370| | 371| 14| nlabels = 0; 372| 14| if (l2 > l1) { ------------------ | Branch (372:6): [True: 2, False: 12] ------------------ 373| 2| l = l1; 374| 2| ldiff = 0 - (l2 - l1); 375| 12| } else { 376| 12| l = l2; 377| 12| ldiff = l1 - l2; 378| 12| } 379| | 380| 40| while (l-- > 0) { ------------------ | Branch (380:9): [True: 26, False: 14] ------------------ 381| 26| l1--; 382| 26| l2--; 383| 26| label1 = &name1->ndata[offsets1[l1]]; 384| 26| label2 = &name2->ndata[offsets2[l2]]; 385| 26| count1 = *label1++; 386| 26| count2 = *label2++; 387| | 388| 26| cdiff = (int)count1 - (int)count2; 389| 26| if (cdiff < 0) { ------------------ | Branch (389:7): [True: 0, False: 26] ------------------ 390| 0| count = count1; 391| 26| } else { 392| 26| count = count2; 393| 26| } 394| | 395| 26| diff = isc_ascii_lowercmp(label1, label2, count); 396| 26| if (diff != 0) { ------------------ | Branch (396:7): [True: 0, False: 26] ------------------ 397| 0| *orderp = diff; 398| 0| goto done; 399| 0| } 400| | 401| 26| if (cdiff != 0) { ------------------ | Branch (401:7): [True: 0, False: 26] ------------------ 402| 0| *orderp = cdiff; 403| 0| goto done; 404| 0| } 405| 26| nlabels++; 406| 26| } 407| | 408| 14| *orderp = ldiff; 409| 14| if (ldiff < 0) { ------------------ | Branch (409:6): [True: 2, False: 12] ------------------ 410| 2| namereln = dns_namereln_contains; 411| 12| } else if (ldiff > 0) { ------------------ | Branch (411:13): [True: 0, False: 12] ------------------ 412| 0| namereln = dns_namereln_subdomain; 413| 12| } else { 414| 12| namereln = dns_namereln_equal; 415| 12| } 416| 14| *nlabelsp = nlabels; 417| 14| return namereln; 418| | 419| 0|done: 420| 0| *nlabelsp = nlabels; 421| 0| if (nlabels > 0) { ------------------ | Branch (421:6): [True: 0, False: 0] ------------------ 422| 0| namereln = dns_namereln_commonancestor; 423| 0| } 424| | 425| 0| return namereln; 426| 14|} dns_name__equal: 449| 4.49k|dns_name__equal(const dns_name_t *name1, const dns_name_t *name2) { 450| 4.49k| unsigned int length; 451| | 452| | /* 453| | * Are 'name1' and 'name2' equal? 454| | * 455| | * Note: It makes no sense for one of the names to be relative and the 456| | * other absolute. If both names are relative, then to be meaningfully 457| | * compared the caller must ensure that they are both relative to the 458| | * same domain. 459| | */ 460| | 461| 4.49k| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 198| 4.49k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8.98k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4.49k, False: 0] | | | | | Branch (41:11): [True: 4.49k, False: 0] | | | | ------------------ | | | | 42| 4.49k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 462| 4.49k| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 198| 4.49k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8.98k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4.49k, False: 0] | | | | | Branch (41:11): [True: 4.49k, False: 0] | | | | ------------------ | | | | 42| 4.49k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 463| | /* 464| | * Either name1 is absolute and name2 is absolute, or neither is. 465| | */ 466| 4.49k| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 198| 4.49k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.49k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4.49k, False: 0] | | | | ------------------ | | | | 42| 4.49k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 467| | 468| 4.49k| if (name1 == name2) { ------------------ | Branch (468:6): [True: 0, False: 4.49k] ------------------ 469| 0| return true; 470| 0| } 471| | 472| 4.49k| length = name1->length; 473| 4.49k| if (length != name2->length) { ------------------ | Branch (473:6): [True: 3.46k, False: 1.02k] ------------------ 474| 3.46k| return false; 475| 3.46k| } 476| | 477| | /* label lengths are < 64 so tolower() does not affect them */ 478| 1.02k| return isc_ascii_lowerequal(name1->ndata, name2->ndata, length); 479| 4.49k|} dns_name_caseequal: 482| 4|dns_name_caseequal(const dns_name_t *name1, const dns_name_t *name2) { 483| | /* 484| | * Are 'name1' and 'name2' equal? 485| | * 486| | * Note: It makes no sense for one of the names to be relative and the 487| | * other absolute. If both names are relative, then to be meaningfully 488| | * compared the caller must ensure that they are both relative to the 489| | * same domain. 490| | */ 491| | 492| 4| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 493| 4| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 494| | /* 495| | * Either name1 is absolute and name2 is absolute, or neither is. 496| | */ 497| 4| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 498| | 499| 4| if (name1->length != name2->length) { ------------------ | Branch (499:6): [True: 0, False: 4] ------------------ 500| 0| return false; 501| 0| } 502| | 503| 4| if (memcmp(name1->ndata, name2->ndata, name1->length) != 0) { ------------------ | Branch (503:6): [True: 0, False: 4] ------------------ 504| 0| return false; 505| 0| } 506| | 507| 4| return true; 508| 4|} dns_name__issubdomain: 529| 14|dns_name__issubdomain(const dns_name_t *name1, const dns_name_t *name2) { 530| 14| int order; 531| 14| unsigned int nlabels; 532| 14| dns_namereln_t namereln; 533| | 534| | /* 535| | * Is 'name1' a subdomain of 'name2'? 536| | * 537| | * Note: It makes no sense for one of the names to be relative and the 538| | * other absolute. If both names are relative, then to be meaningfully 539| | * compared the caller must ensure that they are both relative to the 540| | * same domain. 541| | */ 542| | 543| 14| namereln = dns_name_fullcompare(name1, name2, &order, &nlabels); ------------------ | | 1534| 14| dns_name__fullcompare(DNS_NAME__RO_ARG(name1), \ | | ------------------ | | | | 1507| 14| _Generic((arg), \ | | | | 1508| 14| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 14| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 14| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 14| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 14| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 14| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | 1535| 14| DNS_NAME__RO_ARG(name2), orderp, nlabelsp) | | ------------------ | | | | 1507| 14| _Generic((arg), \ | | | | 1508| 14| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 14| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 14| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 14| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 14| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 14| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 544| 14| if (namereln == dns_namereln_subdomain || ------------------ | Branch (544:6): [True: 0, False: 14] ------------------ 545| 14| namereln == dns_namereln_equal) ------------------ | Branch (545:6): [True: 12, False: 2] ------------------ 546| 12| { 547| 12| return true; 548| 12| } 549| | 550| 2| return false; 551| 14|} dns_name__clone: 651| 1.54k|dns_name__clone(const dns_name_t *source, dns_name_t *target) { 652| | /* 653| | * Make 'target' refer to the same name as 'source'. 654| | */ 655| | 656| 1.54k| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 1.54k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.08k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.54k, False: 0] | | | | | Branch (41:11): [True: 1.54k, False: 0] | | | | ------------------ | | | | 42| 1.54k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 657| 1.54k| REQUIRE(DNS_NAME_VALID(target)); ------------------ | | 198| 1.54k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.08k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.54k, False: 0] | | | | | Branch (41:11): [True: 1.54k, False: 0] | | | | ------------------ | | | | 42| 1.54k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 658| 1.54k| REQUIRE(DNS_NAME_BINDABLE(target)); ------------------ | | 198| 1.54k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.08k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.54k, False: 0] | | | | | Branch (41:11): [True: 1.54k, False: 0] | | | | ------------------ | | | | 42| 1.54k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 659| | 660| 1.54k| target->ndata = source->ndata; 661| 1.54k| target->length = source->length; 662| 1.54k| target->attributes = source->attributes; 663| 1.54k| target->attributes.readonly = false; 664| | target->attributes.dynamic = false; 665| 1.54k|} dns_name_fromregion: 668| 1.25k|dns_name_fromregion(dns_name_t *name, const isc_region_t *r) { 669| 1.25k| size_t length; 670| 1.25k| isc_region_t r2 = { .base = NULL, .length = 0 }; 671| | 672| | /* 673| | * Make 'name' refer to region 'r'. 674| | */ 675| | 676| 1.25k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.51k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 677| 1.25k| REQUIRE(r != NULL); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 678| 1.25k| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.51k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 679| | 680| 1.25k| name->ndata = r->base; 681| 1.25k| if (name->buffer != NULL) { ------------------ | Branch (681:6): [True: 4, False: 1.25k] ------------------ 682| 4| isc_buffer_clear(name->buffer); 683| 4| isc_buffer_availableregion(name->buffer, &r2); 684| 4| length = (r->length < r2.length) ? r->length : r2.length; ------------------ | Branch (684:12): [True: 4, False: 0] ------------------ 685| 4| if (length > DNS_NAME_MAXWIRE) { ------------------ | | 245| 4|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (685:7): [True: 0, False: 4] ------------------ 686| 0| length = DNS_NAME_MAXWIRE; ------------------ | | 245| 0|#define DNS_NAME_MAXWIRE 255 ------------------ 687| 0| } 688| 1.25k| } else { 689| 1.25k| length = (r->length <= DNS_NAME_MAXWIRE) ? r->length ------------------ | | 245| 1.25k|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (689:12): [True: 945, False: 307] ------------------ 690| 1.25k| : DNS_NAME_MAXWIRE; ------------------ | | 245| 1.55k|#define DNS_NAME_MAXWIRE 255 ------------------ 691| 1.25k| } 692| | 693| 1.25k| name->attributes.absolute = false; 694| | 695| 1.25k| if (length > 0) { ------------------ | Branch (695:6): [True: 1.25k, False: 0] ------------------ 696| 1.25k| size_t offset = 0; 697| 1.25k| uint8_t nlabels = 0; 698| 12.8k| while (offset != length) { ------------------ | Branch (698:10): [True: 12.8k, False: 0] ------------------ 699| 12.8k| uint8_t count; 700| | 701| 12.8k| INSIST(nlabels < DNS_NAME_MAXLABELS); ------------------ | | 202| 12.8k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 12.8k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 12.8k, False: 0] | | | | ------------------ | | | | 54| 12.8k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 702| 12.8k| nlabels++; 703| | 704| 12.8k| count = r->base[offset]; 705| 12.8k| INSIST(count <= DNS_NAME_LABELLEN); ------------------ | | 202| 12.8k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 12.8k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 12.8k, False: 0] | | | | ------------------ | | | | 54| 12.8k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 706| | 707| 12.8k| offset += count + 1; 708| 12.8k| INSIST(offset <= length); ------------------ | | 202| 12.8k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 12.8k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 12.8k, False: 0] | | | | ------------------ | | | | 54| 12.8k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 709| | 710| 12.8k| if (count == 0) { ------------------ | Branch (710:8): [True: 1.25k, False: 11.5k] ------------------ 711| 1.25k| name->attributes.absolute = true; 712| 1.25k| break; 713| 1.25k| } 714| 12.8k| } 715| 1.25k| name->length = offset; 716| 1.25k| } 717| | 718| 1.25k| if (name->buffer != NULL) { ------------------ | Branch (718:6): [True: 4, False: 1.25k] ------------------ 719| | /* 720| | * name->length has been updated by set_offsets to the actual 721| | * length of the name data so we can now copy the actual name 722| | * data and not anything after it. 723| | */ 724| 4| if (name->length > 0) { ------------------ | Branch (724:7): [True: 4, False: 0] ------------------ 725| 4| memmove(r2.base, r->base, name->length); 726| 4| } 727| 4| name->ndata = r2.base; 728| 4| isc_buffer_add(name->buffer, name->length); 729| 4| } 730| 1.25k|} dns_name_fromtext: 978| 16| const dns_name_t *origin, unsigned int options) { 979| 16| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 16, False: 0] | | | | | Branch (41:11): [True: 16, False: 0] | | | | ------------------ | | | | 42| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 980| 16| REQUIRE(ISC_BUFFER_VALID(name->buffer)); ------------------ | | 198| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 16, False: 0] | | | | | Branch (41:11): [True: 16, False: 0] | | | | ------------------ | | | | 42| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 981| | 982| 16| isc_buffer_clear(name->buffer); 983| 16| return convert_text(source, origin, options, name, name->buffer); 984| 16|} dns_name__totext: 988| 2| isc_buffer_t *target) { 989| 2| isc_result_t result; 990| 2| unsigned char *ndata = NULL; 991| 2| unsigned int nlen; 992| 2| unsigned int labels; 993| 2| bool saw_root = false; 994| 2| unsigned int oused; 995| 2| bool omit_final_dot = ((options & DNS_NAME_OMITFINALDOT) != 0); ------------------ | | 983| 2|#define DNS_NAME_OMITFINALDOT 0x01U ------------------ 996| 2| bool minimal = ((options & DNS_NAME_QUOTED) != 0); ------------------ | | 985| 2|#define DNS_NAME_QUOTED 0x04U /* minimal escaping within double quotes */ ------------------ 997| 2| bool principal = ((options & DNS_NAME_PRINCIPAL) != 0); ------------------ | | 984| 2|#define DNS_NAME_PRINCIPAL 0x02U /* do not escape $ and @ */ ------------------ 998| 2| bool first = true; 999| | 1000| | /* 1001| | * This function assumes the name is in proper uncompressed 1002| | * wire format. 1003| | */ 1004| 2| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1005| 2| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1006| | 1007| 2| oused = target->used; 1008| | 1009| 2| ndata = name->ndata; 1010| 2| nlen = name->length; 1011| 2| labels = dns_name_countlabels(name); ------------------ | | 1546| 2|#define dns_name_countlabels(name) dns_name__countlabels(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1012| | 1013| 2| if (labels == 0 && nlen == 0) { ------------------ | Branch (1013:6): [True: 0, False: 2] | Branch (1013:21): [True: 0, False: 0] ------------------ 1014| | /* 1015| | * Special handling for an empty name. 1016| | */ 1017| 0| omit_final_dot = true; 1018| 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| } ------------------ 1019| 0| isc_buffer_putuint8(target, '@'); 1020| | 1021| | /* 1022| | * Skip the while() loop. 1023| | */ 1024| 0| nlen = 0; 1025| 2| } else if (nlen == 1 && labels == 1 && *ndata == '\0') { ------------------ | Branch (1025:13): [True: 0, False: 2] | Branch (1025:26): [True: 0, False: 0] | Branch (1025:41): [True: 0, False: 0] ------------------ 1026| | /* 1027| | * Special handling for the root label. 1028| | */ 1029| 0| saw_root = true; 1030| 0| omit_final_dot = false; 1031| | 1032| | /* 1033| | * Skip the while() loop. 1034| | */ 1035| 0| nlen = 0; 1036| 0| } 1037| | 1038| 4| while (labels > 0 && nlen > 0) { ------------------ | Branch (1038:9): [True: 4, False: 0] | Branch (1038:23): [True: 4, False: 0] ------------------ 1039| 4| unsigned int count = *ndata++; 1040| 4| labels--; 1041| 4| nlen--; 1042| 4| if (count == 0) { ------------------ | Branch (1042:7): [True: 2, False: 2] ------------------ 1043| 2| saw_root = true; 1044| 2| break; 1045| 2| } else if (!first) { ------------------ | Branch (1045:14): [True: 0, False: 2] ------------------ 1046| 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| } ------------------ 1047| 0| isc_buffer_putuint8(target, '.'); 1048| 0| } 1049| 2| first = false; 1050| | 1051| 2| if (count <= DNS_NAME_LABELLEN) { ------------------ | | 247| 2|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (1051:7): [True: 2, False: 0] ------------------ 1052| 2| unsigned char c; 1053| | 1054| 2| INSIST(nlen >= count); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1055| | 1056| 16| while (count > 0) { ------------------ | Branch (1056:11): [True: 14, False: 2] ------------------ 1057| 14| uint32_t value; 1058| | 1059| 14| c = *ndata; 1060| 14| switch (c) { 1061| | /* Special modifiers in zone files. */ 1062| 0| case 0x40: /* '@' */ ------------------ | Branch (1062:5): [True: 0, False: 14] ------------------ 1063| 0| case 0x24: /* '$' */ ------------------ | Branch (1063:5): [True: 0, False: 14] ------------------ 1064| 0| if (principal) { ------------------ | Branch (1064:10): [True: 0, False: 0] ------------------ 1065| 0| goto no_escape; 1066| 0| } 1067| 0| FALLTHROUGH; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 1068| 0| case 0x28: /* '(' */ ------------------ | Branch (1068:5): [True: 0, False: 14] ------------------ 1069| 0| case 0x29: /* ')' */ ------------------ | Branch (1069:5): [True: 0, False: 14] ------------------ 1070| 0| case 0x3B: /* ';' */ ------------------ | Branch (1070:5): [True: 0, False: 14] ------------------ 1071| 0| if (minimal) { ------------------ | Branch (1071:10): [True: 0, False: 0] ------------------ 1072| 0| goto no_escape; 1073| 0| } 1074| 0| FALLTHROUGH; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 1075| 0| case 0x22: /* '"' */ ------------------ | Branch (1075:5): [True: 0, False: 14] ------------------ 1076| 0| case 0x2E: /* '.' */ ------------------ | Branch (1076:5): [True: 0, False: 14] ------------------ 1077| 0| case 0x5C: /* '\\' */ ------------------ | Branch (1077:5): [True: 0, False: 14] ------------------ 1078| 0| value = '\\' << 8 | c; 1079| 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| } ------------------ 1080| 0| isc_buffer_putuint16(target, value); 1081| 0| ndata++; 1082| 0| nlen--; 1083| 0| break; 1084| 0| no_escape: 1085| 14| default: ------------------ | Branch (1085:5): [True: 14, False: 0] ------------------ 1086| 14| if ((c > 0x20 && c < 0x7f) || ------------------ | Branch (1086:11): [True: 14, False: 0] | Branch (1086:23): [True: 14, False: 0] ------------------ 1087| 0| (c == 0x20 && minimal)) ------------------ | Branch (1087:11): [True: 0, False: 0] | Branch (1087:24): [True: 0, False: 0] ------------------ 1088| 14| { 1089| 14| CHECK(isc_buffer_reserve(target, ------------------ | | 255| 14| { \ | | 256| 14| result = (r); \ | | 257| 14| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 14] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 14| } ------------------ 1090| 14| 1)); 1091| 14| isc_buffer_putuint8(target, c); 1092| 14| ndata++; 1093| 14| nlen--; 1094| 14| } else { 1095| 0| value = 0x5c << 24; 1096| 0| value |= (0x30 + 1097| 0| ((c / 100) % 10)) 1098| 0| << 16; 1099| 0| value |= 1100| 0| (0x30 + ((c / 10) % 10)) 1101| 0| << 8; 1102| 0| value |= 0x30 + (c % 10); 1103| 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| } ------------------ 1104| 0| 4)); 1105| 0| isc_buffer_putuint32(target, 1106| 0| value); 1107| 0| ndata++; 1108| 0| nlen--; 1109| 0| } 1110| 14| } 1111| 14| count--; 1112| 14| } 1113| 2| } else { 1114| 0| FATAL_ERROR("Unexpected label type %02x", count); ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1115| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 1116| 0| } 1117| 2| } 1118| | 1119| 2| if (saw_root && !omit_final_dot) { ------------------ | Branch (1119:6): [True: 2, False: 0] | Branch (1119:18): [True: 0, False: 2] ------------------ 1120| 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| } ------------------ 1121| 0| isc_buffer_putuint8(target, '.'); 1122| 0| } 1123| | 1124| 2| if (isc_buffer_availablelength(target) > 1) { ------------------ | | 162| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1124:6): [True: 2, False: 0] ------------------ 1125| 2| uint8_t *p = isc_buffer_used(target); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1126| 2| *p = 0; 1127| 2| } 1128| | 1129| 2| if (totext_filter_proc != NULL) { ------------------ | Branch (1129:6): [True: 0, False: 2] ------------------ 1130| 0| return (totext_filter_proc)(target, oused); 1131| 0| } 1132| | 1133| 2| return ISC_R_SUCCESS; 1134| | 1135| 0|cleanup: 1136| 0| return result; 1137| 2|} dns_name_downcase: 1255| 304|dns_name_downcase(const dns_name_t *source, dns_name_t *name) { 1256| | /* 1257| | * Downcase 'source'. 1258| | */ 1259| | 1260| 304| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 304|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 608| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 304, False: 0] | | | | | Branch (41:11): [True: 304, False: 0] | | | | ------------------ | | | | 42| 304| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1261| 304| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 304|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 608| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 304, False: 0] | | | | | Branch (41:11): [True: 304, False: 0] | | | | ------------------ | | | | 42| 304| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1262| | 1263| 304| if (source == name) { ------------------ | Branch (1263:6): [True: 304, False: 0] ------------------ 1264| 304| REQUIRE(!name->attributes.readonly); ------------------ | | 198| 304|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 304| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 304, False: 0] | | | | ------------------ | | | | 42| 304| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1265| 304| isc_ascii_lowercopy(name->ndata, source->ndata, source->length); 1266| 304| return ISC_R_SUCCESS; 1267| 304| } 1268| | 1269| 0| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 198| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1270| 0| REQUIRE(ISC_BUFFER_VALID(name->buffer)); ------------------ | | 198| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1271| | 1272| 0| isc_buffer_clear(name->buffer); 1273| 0| name->ndata = (uint8_t *)name->buffer->base + name->buffer->used; 1274| | 1275| | /* label lengths are < 64 so tolower() does not affect them */ 1276| 0| name->length = source->length; 1277| 0| isc_ascii_lowercopy(name->ndata, source->ndata, source->length); 1278| | 1279| 0| name->attributes = (struct dns_name_attrs){ 1280| 0| .absolute = source->attributes.absolute 1281| 0| }; 1282| 0| isc_buffer_add(name->buffer, name->length); 1283| | 1284| 0| return ISC_R_SUCCESS; 1285| 304|} dns_name_fromwire: 1289| 5.21k| const dns_decompress_t dctx, isc_buffer_t *target) { 1290| | /* 1291| | * Copy the name at source into target, decompressing it. 1292| | * 1293| | * *** WARNING *** 1294| | * 1295| | * dns_name_fromwire() deals with raw network data. An error in this 1296| | * routine could result in the failure or hijacking of the server. 1297| | * 1298| | * The description of name compression in RFC 1035 section 4.1.4 is 1299| | * subtle wrt certain edge cases. The first important sentence is: 1300| | * 1301| | * > In this scheme, an entire domain name or a list of labels at the 1302| | * > end of a domain name is replaced with a pointer to a prior 1303| | * > occurrence of the same name. 1304| | * 1305| | * The key word is "prior". This says that compression pointers must 1306| | * point strictly earlier in the message (before our "marker" variable), 1307| | * which is enough to prevent DoS attacks due to compression loops. 1308| | * 1309| | * The next important sentence is: 1310| | * 1311| | * > If a domain name is contained in a part of the message subject to a 1312| | * > length field (such as the RDATA section of an RR), and compression 1313| | * > is used, the length of the compressed name is used in the length 1314| | * > calculation, rather than the length of the expanded name. 1315| | * 1316| | * When decompressing, this means that the amount of the source buffer 1317| | * that we consumed (which is checked wrt the container's length field) 1318| | * is the length of the compressed name. A compressed name is defined as 1319| | * a sequence of labels ending with the root label or a compression 1320| | * pointer, that is, the segment of the name that dns_name_fromwire() 1321| | * examines first. 1322| | * 1323| | * This matters when handling names that play dirty tricks, like: 1324| | * 1325| | * +---+---+---+---+---+---+ 1326| | * | 4 | 1 |'a'|192| 0 | 0 | 1327| | * +---+---+---+---+---+---+ 1328| | * 1329| | * We start at octet 1. There is an ordinary single character label "a", 1330| | * followed by a compression pointer that refers back to octet zero. 1331| | * Here there is a label of length 4, which weirdly re-uses the octets 1332| | * we already examined as the data for the label. It is followed by the 1333| | * root label, 1334| | * 1335| | * The specification says that the compressed name ends after the first 1336| | * zero octet (after the compression pointer) not the second zero octet, 1337| | * even though the second octet is later in the message. This shows the 1338| | * correct way to set our "consumed" variable. 1339| | */ 1340| | 1341| 5.21k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 5.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 5.21k, False: 0] | | | | | Branch (41:11): [True: 5.21k, False: 0] | | | | ------------------ | | | | 42| 5.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1342| 5.21k| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 198| 5.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 5.21k, False: 0] | | | | | Branch (41:11): [True: 5.21k, False: 0] | | | | ------------------ | | | | 42| 5.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1343| 5.21k| REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) || ------------------ | | 198| 5.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 32.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.90k, False: 0] | | | | | Branch (41:11): [True: 1.90k, False: 0] | | | | | Branch (41:11): [True: 1.90k, False: 3.31k] | | | | | Branch (41:11): [True: 3.31k, False: 0] | | | | | Branch (41:11): [True: 3.31k, False: 0] | | | | | Branch (41:11): [True: 3.31k, False: 0] | | | | ------------------ | | | | 42| 5.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1344| 5.21k| (target == NULL && ISC_BUFFER_VALID(name->buffer))); 1345| | 1346| 5.21k| if (target == NULL && name->buffer != NULL) { ------------------ | Branch (1346:6): [True: 3.31k, False: 1.90k] | Branch (1346:24): [True: 3.31k, False: 0] ------------------ 1347| 3.31k| target = name->buffer; 1348| 3.31k| isc_buffer_clear(target); 1349| 3.31k| } 1350| | 1351| 5.21k| uint8_t *const name_buf = isc_buffer_used(target); ------------------ | | 150| 5.21k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1352| 5.21k| const uint32_t name_max = ISC_MIN(DNS_NAME_MAXWIRE, ------------------ | | 77| 5.21k|#define ISC_MIN(a, b) ((a) < (b) ? (a) : (b)) | | ------------------ | | | Branch (77:24): [True: 1.90k, False: 3.31k] | | ------------------ ------------------ 1353| 5.21k| isc_buffer_availablelength(target)); 1354| 5.21k| uint32_t name_len = 0; 1355| | 1356| | /* 1357| | * After chasing a compression pointer, these variables refer to the 1358| | * source buffer as follows: 1359| | * 1360| | * sb --- mr --- cr --- st --- cd --- sm 1361| | * 1362| | * sb = source_buf (const) 1363| | * mr = marker 1364| | * cr = cursor 1365| | * st = start (const) 1366| | * cd = consumed 1367| | * sm = source_max (const) 1368| | * 1369| | * The marker hops backwards for each pointer. 1370| | * The cursor steps forwards for each label. 1371| | * The amount of the source we consumed is set once. 1372| | */ 1373| 5.21k| const uint8_t *const source_buf = isc_buffer_base(source); ------------------ | | 144| 5.21k|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 1374| 5.21k| const uint8_t *const source_max = isc_buffer_active(source); ------------------ | | 148| 5.21k| ((void *)((unsigned char *)(b)->base + (b)->active)) /*c*/ ------------------ 1375| 5.21k| const uint8_t *const start = isc_buffer_current(source); ------------------ | | 146| 5.21k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1376| 5.21k| const uint8_t *marker = start; 1377| 5.21k| const uint8_t *cursor = start; 1378| 5.21k| const uint8_t *consumed = NULL; 1379| | 1380| | /* 1381| | * One iteration per label. 1382| | */ 1383| 45.4k| while (cursor < source_max) { ------------------ | Branch (1383:9): [True: 45.3k, False: 26] ------------------ 1384| 45.3k| const uint8_t label_len = *cursor++; 1385| 45.3k| if (label_len <= DNS_NAME_LABELLEN) { ------------------ | | 247| 45.3k|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (1385:7): [True: 44.6k, False: 798] ------------------ 1386| | /* 1387| | * Normal label: record its offset, and check bounds on 1388| | * the name length, which also ensures we don't overrun 1389| | * the offsets array. Don't touch any source bytes yet! 1390| | * The source bounds check will happen when we loop. 1391| | */ 1392| | /* and then a step to the ri-i-i-i-i-ight */ 1393| 44.6k| cursor += label_len; 1394| 44.6k| name_len += label_len + 1; 1395| 44.6k| if (name_len > name_max) { ------------------ | Branch (1395:8): [True: 10, False: 44.5k] ------------------ 1396| 10| return name_max == DNS_NAME_MAXWIRE ------------------ | | 245| 10|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (1396:12): [True: 10, False: 0] ------------------ 1397| 10| ? DNS_R_NAMETOOLONG 1398| 10| : ISC_R_NOSPACE; 1399| 44.5k| } else if (label_len == 0) { ------------------ | Branch (1399:15): [True: 5.14k, False: 39.4k] ------------------ 1400| 5.14k| goto root_label; 1401| 5.14k| } 1402| 44.6k| } else if (label_len < 192) { ------------------ | Branch (1402:14): [True: 23, False: 775] ------------------ 1403| 23| return DNS_R_BADLABELTYPE; 1404| 775| } else if (!dns_decompress_getpermitted(dctx)) { ------------------ | Branch (1404:14): [True: 9, False: 766] ------------------ 1405| 9| return DNS_R_DISALLOWED; 1406| 766| } else if (cursor < source_max) { ------------------ | Branch (1406:14): [True: 765, False: 1] ------------------ 1407| | /* 1408| | * Compression pointer. Ensure it does not loop. 1409| | * 1410| | * Copy multiple labels in one go, to make the most of 1411| | * memmove() performance. Start at the marker and finish 1412| | * just before the pointer's hi+lo bytes, before the 1413| | * cursor. Bounds were already checked. 1414| | */ 1415| 765| const uint32_t hi = label_len & 0x3F; 1416| 765| const uint32_t lo = *cursor++; 1417| 765| const uint8_t *pointer = source_buf + (256 * hi + lo); 1418| 765| if (pointer >= marker) { ------------------ | Branch (1418:8): [True: 4, False: 761] ------------------ 1419| 4| return DNS_R_BADPOINTER; 1420| 4| } 1421| 761| const uint32_t copy_len = (cursor - 2) - marker; 1422| 761| uint8_t *const dest = name_buf + name_len - copy_len; 1423| 761| memmove(dest, marker, copy_len); 1424| 761| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1424:15): [True: 272, False: 489] ------------------ 1425| | /* it's just a jump to the left */ 1426| 761| cursor = marker = pointer; 1427| 761| } 1428| 45.3k| } 1429| 26| return ISC_R_UNEXPECTEDEND; 1430| 5.14k|root_label:; 1431| | /* 1432| | * Copy labels almost like we do for compression pointers, 1433| | * from the marker up to and including the root label. 1434| | */ 1435| 5.14k| const uint32_t copy_len = cursor - marker; 1436| 5.14k| memmove(name_buf + name_len - copy_len, marker, copy_len); 1437| 5.14k| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1437:13): [True: 473, False: 4.67k] ------------------ 1438| 5.14k| isc_buffer_forward(source, consumed - start); 1439| | 1440| 5.14k| name->attributes.absolute = true; 1441| 5.14k| name->ndata = name_buf; 1442| 5.14k| name->length = name_len; 1443| 5.14k| isc_buffer_add(target, name_len); 1444| | 1445| 5.14k| return ISC_R_SUCCESS; 1446| 5.21k|} dns_name_towire: 1450| 6| isc_buffer_t *target) { 1451| 6| bool compress, multi; 1452| 6| unsigned int here; 1453| 6| unsigned int prefix_length; 1454| 6| unsigned int suffix_coff; 1455| | 1456| | /* 1457| | * Convert 'name' into wire format, compressing it as specified by the 1458| | * compression context 'cctx' (or without compressing if 'cctx' 1459| | * is NULL), and storing the result in 'target'. 1460| | */ 1461| | 1462| 6| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1463| 6| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1464| | 1465| 6| if (cctx == NULL) { ------------------ | Branch (1465:6): [True: 6, False: 0] ------------------ 1466| 6| if (isc_buffer_availablelength(target) < name->length) { ------------------ | | 162| 6|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1466:7): [True: 0, False: 6] ------------------ 1467| 0| return ISC_R_NOSPACE; 1468| 0| } 1469| 6| memmove(isc_buffer_used(target), name->ndata, name->length); ------------------ | | 150| 6| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1470| 6| isc_buffer_add(target, name->length); 1471| 6| return ISC_R_SUCCESS; 1472| 6| } 1473| | 1474| 0| compress = !name->attributes.nocompress && ------------------ | Branch (1474:13): [True: 0, False: 0] ------------------ 1475| 0| dns_compress_getpermitted(cctx); ------------------ | Branch (1475:6): [True: 0, False: 0] ------------------ 1476| 0| multi = compress && dns_compress_getmultiuse(cctx); ------------------ | Branch (1476:10): [True: 0, False: 0] | Branch (1476:22): [True: 0, False: 0] ------------------ 1477| | 1478| | /* 1479| | * Write a compression pointer directly if the caller passed us 1480| | * a pointer to this name's offset that we saved previously. 1481| | */ 1482| 0| if (multi && cctx->coff < 0x4000) { ------------------ | Branch (1482:6): [True: 0, False: 0] | Branch (1482:15): [True: 0, False: 0] ------------------ 1483| 0| if (isc_buffer_availablelength(target) < 2) { ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1483:7): [True: 0, False: 0] ------------------ 1484| 0| return ISC_R_NOSPACE; 1485| 0| } 1486| 0| isc_buffer_putuint16(target, cctx->coff | 0xc000); 1487| 0| return ISC_R_SUCCESS; 1488| 0| } 1489| | 1490| | /* 1491| | * Always add the name to the compression context; if compression 1492| | * is off, reset the return values before writing the name. 1493| | */ 1494| 0| prefix_length = name->length; 1495| 0| suffix_coff = 0; 1496| 0| dns_compress_name(cctx, target, name, &prefix_length, &suffix_coff); 1497| 0| if (!compress) { ------------------ | Branch (1497:6): [True: 0, False: 0] ------------------ 1498| 0| prefix_length = name->length; 1499| 0| suffix_coff = 0; 1500| 0| } 1501| | 1502| | /* 1503| | * Return this name's compression offset for use next time, provided 1504| | * it isn't too short for compression to help (i.e. it's the root) 1505| | */ 1506| 0| here = isc_buffer_usedlength(target); ------------------ | | 158| 0|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1507| 0| if (multi && here < 0x4000 && prefix_length > 1) { ------------------ | Branch (1507:6): [True: 0, False: 0] | Branch (1507:15): [True: 0, False: 0] | Branch (1507:32): [True: 0, False: 0] ------------------ 1508| 0| cctx->coff = (uint16_t)here; 1509| 0| } 1510| | 1511| 0| if (prefix_length > 0) { ------------------ | Branch (1511:6): [True: 0, False: 0] ------------------ 1512| 0| if (isc_buffer_availablelength(target) < prefix_length) { ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1512:7): [True: 0, False: 0] ------------------ 1513| 0| return ISC_R_NOSPACE; 1514| 0| } 1515| 0| memmove(isc_buffer_used(target), name->ndata, prefix_length); ------------------ | | 150| 0| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1516| 0| isc_buffer_add(target, prefix_length); 1517| 0| } 1518| | 1519| 0| if (suffix_coff > 0) { ------------------ | Branch (1519:6): [True: 0, False: 0] ------------------ 1520| 0| if (multi && prefix_length == 0) { ------------------ | Branch (1520:7): [True: 0, False: 0] | Branch (1520:16): [True: 0, False: 0] ------------------ 1521| 0| cctx->coff = suffix_coff; 1522| 0| } 1523| 0| if (isc_buffer_availablelength(target) < 2) { ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1523:7): [True: 0, False: 0] ------------------ 1524| 0| return ISC_R_NOSPACE; 1525| 0| } 1526| 0| isc_buffer_putuint16(target, suffix_coff | 0xc000); 1527| 0| } 1528| | 1529| 0| return ISC_R_SUCCESS; 1530| 0|} dns_name__dup: 1619| 96|dns_name__dup(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) { 1620| | /* 1621| | * Make 'target' a dynamically allocated copy of 'source'. 1622| | */ 1623| | 1624| 96| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 96, False: 0] | | | | | Branch (41:11): [True: 96, False: 0] | | | | ------------------ | | | | 42| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1625| 96| REQUIRE(source->length > 0); ------------------ | | 198| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 96| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 96, False: 0] | | | | ------------------ | | | | 42| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1626| 96| REQUIRE(DNS_NAME_VALID(target)); ------------------ | | 198| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 96, False: 0] | | | | | Branch (41:11): [True: 96, False: 0] | | | | ------------------ | | | | 42| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1627| 96| REQUIRE(DNS_NAME_BINDABLE(target)); ------------------ | | 198| 96|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 192| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 96, False: 0] | | | | | Branch (41:11): [True: 96, False: 0] | | | | ------------------ | | | | 42| 96| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1628| | 1629| 96| target->ndata = isc_mem_get(mctx, source->length); ------------------ | | 144| 96|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1630| 96| target->length = source->length; 1631| | 1632| 96| memmove(target->ndata, source->ndata, source->length); 1633| | 1634| | target->attributes = (struct dns_name_attrs){ .dynamic = true }; 1635| 96| target->attributes.absolute = source->attributes.absolute; 1636| 96|} dns_name_free: 1639| 82|dns_name_free(dns_name_t *name, isc_mem_t *mctx) { 1640| 82| size_t size; 1641| | 1642| | /* 1643| | * Free 'name'. 1644| | */ 1645| | 1646| 82| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 82, False: 0] | | | | | Branch (41:11): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1647| 82| REQUIRE(name->attributes.dynamic); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1648| | 1649| 82| size = name->length; 1650| | isc_mem_put(mctx, name->ndata, size); ------------------ | | 171| 82| do { \ | | 172| 82| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 82| (p) = NULL; \ | | 174| 82| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 82] | | ------------------ ------------------ 1651| 82| dns_name_invalidate(name); 1652| 82|} dns_name__dynamic: 1689| 3.12k|dns_name__dynamic(const dns_name_t *name) { 1690| 3.12k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 3.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | | Branch (41:11): [True: 3.12k, False: 0] | | | | ------------------ | | | | 42| 3.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1691| | 1692| | /* 1693| | * Returns whether there is dynamic memory associated with this name. 1694| | */ 1695| | 1696| 3.12k| return name->attributes.dynamic; 1697| 3.12k|} dns_name_fromstring: 1786| 4| isc_mem_t *mctx) { 1787| 4| isc_buffer_t buf; 1788| 4| dns_fixedname_t fn; 1789| 4| dns_name_t *name; 1790| | 1791| 4| REQUIRE(src != NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1792| | 1793| 4| isc_buffer_constinit(&buf, src, strlen(src)); ------------------ | | 613| 4| do { \ | | 614| 4| union { \ | | 615| 4| void *_var; \ | | 616| 4| const void *_const; \ | | 617| 4| } _deconst; \ | | 618| 4| _deconst._const = (_d); \ | | 619| 4| isc_buffer_init((_b), _deconst._var, (_l)); \ | | 620| 4| } while (0) | | ------------------ | | | Branch (620:11): [Folded, False: 4] | | ------------------ ------------------ 1794| 4| isc_buffer_add(&buf, strlen(src)); 1795| 4| if (DNS_NAME_BINDABLE(target) && target->buffer != NULL) { ------------------ | | 161| 8| (!name->attributes.readonly && !name->attributes.dynamic) | | ------------------ | | | Branch (161:3): [True: 4, False: 0] | | | Branch (161:33): [True: 4, False: 0] | | ------------------ ------------------ | Branch (1795:35): [True: 4, False: 0] ------------------ 1796| 4| name = target; 1797| 4| } else { 1798| 0| name = dns_fixedname_initname(&fn); 1799| 0| } 1800| | 1801| 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| } ------------------ 1802| | 1803| 4| if (name != target) { ------------------ | Branch (1803:6): [True: 0, False: 4] ------------------ 1804| 0| dns_name_dup(name, mctx, target); ------------------ | | 1522| 0| dns_name__dup(DNS_NAME__RO_ARG(source), mctx, target) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1805| 0| } 1806| | 1807| 4| return ISC_R_SUCCESS; 1808| 4|} dns_name__copy: 1811| 512|dns_name__copy(const dns_name_t *source, dns_name_t *dest) { 1812| 512| isc_buffer_t *target = NULL; 1813| 512| unsigned char *ndata = NULL; 1814| | 1815| 512| REQUIRE(DNS_NAME_VALID(source)); ------------------ | | 198| 512|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 512, False: 0] | | | | | Branch (41:11): [True: 512, False: 0] | | | | ------------------ | | | | 42| 512| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1816| 512| REQUIRE(DNS_NAME_VALID(dest)); ------------------ | | 198| 512|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 512, False: 0] | | | | | Branch (41:11): [True: 512, False: 0] | | | | ------------------ | | | | 42| 512| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1817| 512| REQUIRE(DNS_NAME_BINDABLE(dest)); ------------------ | | 198| 512|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 512, False: 0] | | | | | Branch (41:11): [True: 512, False: 0] | | | | ------------------ | | | | 42| 512| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1818| | 1819| 512| target = dest->buffer; 1820| | 1821| 512| REQUIRE(target != NULL); ------------------ | | 198| 512|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 512| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 512, False: 0] | | | | ------------------ | | | | 42| 512| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1822| 512| REQUIRE(target->length >= source->length); ------------------ | | 198| 512|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 512| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 512, False: 0] | | | | ------------------ | | | | 42| 512| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1823| | 1824| 512| isc_buffer_clear(target); 1825| | 1826| 512| ndata = (unsigned char *)target->base; 1827| 512| dest->ndata = target->base; 1828| | 1829| 512| if (source->length != 0) { ------------------ | Branch (1829:6): [True: 512, False: 0] ------------------ 1830| 512| memmove(ndata, source->ndata, source->length); 1831| 512| } 1832| | 1833| 512| dest->ndata = ndata; 1834| 512| dest->length = source->length; 1835| 512| dest->attributes.absolute = source->attributes.absolute; 1836| | 1837| 512| isc_buffer_add(target, dest->length); 1838| 512|} dns_name_offsets: 2125| 1.48k|dns_name_offsets(const dns_name_t *name, dns_offsets_t offsets) { 2126| 1.48k| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 1.48k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.96k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.48k, False: 0] | | | | | Branch (41:11): [True: 1.48k, False: 0] | | | | ------------------ | | | | 42| 1.48k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2127| 1.48k| unsigned int offset, count, length, nlabels; 2128| 1.48k| unsigned char *ndata; 2129| | 2130| 1.48k| ndata = name->ndata; 2131| 1.48k| length = name->length; 2132| 1.48k| offset = 0; 2133| 1.48k| nlabels = 0; 2134| 17.5k| while (offset != length) { ------------------ | Branch (2134:9): [True: 17.5k, False: 0] ------------------ 2135| 17.5k| INSIST(nlabels < DNS_NAME_MAXLABELS); ------------------ | | 202| 17.5k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 17.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 17.5k, False: 0] | | | | ------------------ | | | | 54| 17.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2136| 17.5k| if (offsets != NULL) { ------------------ | Branch (2136:7): [True: 17.5k, False: 28] ------------------ 2137| 17.5k| offsets[nlabels] = offset; 2138| 17.5k| } 2139| 17.5k| nlabels++; 2140| 17.5k| count = *ndata; 2141| 17.5k| INSIST(count <= DNS_NAME_LABELLEN); ------------------ | | 202| 17.5k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 17.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 17.5k, False: 0] | | | | ------------------ | | | | 54| 17.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2142| 17.5k| offset += count + 1; 2143| 17.5k| ndata += count + 1; 2144| 17.5k| INSIST(offset <= length); ------------------ | | 202| 17.5k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 17.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 17.5k, False: 0] | | | | ------------------ | | | | 54| 17.5k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2145| 17.5k| if (count == 0) { ------------------ | Branch (2145:7): [True: 1.48k, False: 16.0k] ------------------ 2146| | /* Final root label */ 2147| 1.48k| break; 2148| 1.48k| } 2149| 17.5k| } 2150| 1.48k| INSIST(offset == name->length); ------------------ | | 202| 1.48k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.48k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 1.48k, False: 0] | | | | ------------------ | | | | 54| 1.48k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2151| | 2152| 1.48k| return nlabels; 2153| 1.48k|} name.c:convert_text: 734| 16| unsigned int options, dns_name_t *name, isc_buffer_t *target) { 735| 16| unsigned char *ndata = NULL, *label = NULL; 736| 16| char *tdata = NULL; 737| 16| char c; 738| 16| ft_state state; 739| 16| unsigned int value = 0, count = 0; 740| 16| unsigned int n1 = 0, n2 = 0; 741| 16| unsigned int tlen, nrem, nused, digits = 0, labels, tused; 742| 16| bool done; 743| 16| bool downcase; 744| | 745| 16| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 198| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 16, False: 0] | | | | | Branch (41:11): [True: 16, False: 0] | | | | ------------------ | | | | 42| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 746| 16| REQUIRE(ISC_BUFFER_VALID(source)); ------------------ | | 198| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 16, False: 0] | | | | | Branch (41:11): [True: 16, False: 0] | | | | ------------------ | | | | 42| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 747| 16| REQUIRE(ISC_BUFFER_VALID(target)); ------------------ | | 198| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 16, False: 0] | | | | | Branch (41:11): [True: 16, False: 0] | | | | ------------------ | | | | 42| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 748| | 749| 16| downcase = ((options & DNS_NAME_DOWNCASE) != 0); ------------------ | | 166| 16|#define DNS_NAME_DOWNCASE 0x0001 ------------------ 750| | 751| 16| if (target == NULL && name->buffer != NULL) { ------------------ | Branch (751:6): [True: 0, False: 16] | Branch (751:24): [True: 0, False: 0] ------------------ 752| 0| target = name->buffer; 753| 0| isc_buffer_clear(target); 754| 0| } 755| | 756| 16| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 198| 16|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 32| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 16, False: 0] | | | | | Branch (41:11): [True: 16, False: 0] | | | | ------------------ | | | | 42| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 757| | 758| | /* 759| | * Set up the state machine. 760| | */ 761| 16| tdata = (char *)source->base + source->current; 762| 16| tlen = isc_buffer_remaininglength(source); ------------------ | | 160| 16|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 763| 16| tused = 0; 764| 16| ndata = isc_buffer_used(target); ------------------ | | 150| 16| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 765| 16| nrem = isc_buffer_availablelength(target); ------------------ | | 162| 16|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 766| 16| if (nrem > DNS_NAME_MAXWIRE) { ------------------ | | 245| 16|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (766:6): [True: 0, False: 16] ------------------ 767| 0| nrem = DNS_NAME_MAXWIRE; ------------------ | | 245| 0|#define DNS_NAME_MAXWIRE 255 ------------------ 768| 0| } 769| 16| nused = 0; 770| 16| labels = 0; 771| 16| done = false; 772| 16| state = ft_init; 773| | 774| 100| while (nrem > 0 && tlen > 0 && !done) { ------------------ | Branch (774:9): [True: 100, False: 0] | Branch (774:21): [True: 84, False: 16] | Branch (774:33): [True: 84, False: 0] ------------------ 775| 84| c = *tdata++; 776| 84| tlen--; 777| 84| tused++; 778| | 779| 84| switch (state) { 780| 16| case ft_init: ------------------ | Branch (780:3): [True: 16, False: 68] ------------------ 781| | /* 782| | * Is this the root name? 783| | */ 784| 16| if (c == '.') { ------------------ | Branch (784:8): [True: 6, False: 10] ------------------ 785| 6| if (tlen != 0) { ------------------ | Branch (785:9): [True: 0, False: 6] ------------------ 786| 0| return DNS_R_EMPTYLABEL; 787| 0| } 788| 6| labels++; 789| 6| *ndata++ = 0; 790| 6| nrem--; 791| 6| nused++; 792| 6| done = true; 793| 6| break; 794| 6| } 795| 10| if (c == '@' && tlen == 0) { ------------------ | Branch (795:8): [True: 0, False: 10] | Branch (795:20): [True: 0, False: 0] ------------------ 796| 0| state = ft_at; 797| 0| break; 798| 0| } 799| | 800| 10| FALLTHROUGH; ------------------ | | 105| 10|#define FALLTHROUGH [[fallthrough]] ------------------ 801| 10| case ft_start: ------------------ | Branch (801:3): [True: 0, False: 84] ------------------ 802| 10| label = ndata; 803| 10| ndata++; 804| 10| nrem--; 805| 10| nused++; 806| 10| count = 0; 807| 10| if (c == '\\') { ------------------ | Branch (807:8): [True: 0, False: 10] ------------------ 808| 0| state = ft_initialescape; 809| 0| break; 810| 0| } 811| 10| state = ft_ordinary; 812| 10| if (nrem == 0) { ------------------ | Branch (812:8): [True: 0, False: 10] ------------------ 813| 0| return ISC_R_NOSPACE; 814| 0| } 815| 10| FALLTHROUGH; ------------------ | | 105| 10|#define FALLTHROUGH [[fallthrough]] ------------------ 816| 78| case ft_ordinary: ------------------ | Branch (816:3): [True: 68, False: 16] ------------------ 817| 78| if (c == '.') { ------------------ | Branch (817:8): [True: 6, False: 72] ------------------ 818| 6| if (count == 0) { ------------------ | Branch (818:9): [True: 0, False: 6] ------------------ 819| 0| return DNS_R_EMPTYLABEL; 820| 0| } 821| 6| *label = count; 822| 6| labels++; 823| 6| INSIST(labels < DNS_NAME_MAXLABELS); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 824| 6| if (tlen == 0) { ------------------ | Branch (824:9): [True: 6, False: 0] ------------------ 825| 6| labels++; 826| 6| *ndata++ = 0; 827| 6| nrem--; 828| 6| nused++; 829| 6| done = true; 830| 6| } 831| 6| state = ft_start; 832| 72| } else if (c == '\\') { ------------------ | Branch (832:15): [True: 0, False: 72] ------------------ 833| 0| state = ft_escape; 834| 72| } else { 835| 72| if (count >= DNS_NAME_LABELLEN) { ------------------ | | 247| 72|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (835:9): [True: 0, False: 72] ------------------ 836| 0| return DNS_R_LABELTOOLONG; 837| 0| } 838| 72| count++; 839| 72| if (downcase) { ------------------ | Branch (839:9): [True: 0, False: 72] ------------------ 840| 0| c = isc_ascii_tolower(c); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 841| 0| } 842| 72| *ndata++ = c; 843| 72| nrem--; 844| 72| nused++; 845| 72| } 846| 78| break; 847| 78| case ft_initialescape: ------------------ | Branch (847:3): [True: 0, False: 84] ------------------ 848| 0| if (c == '[') { ------------------ | Branch (848:8): [True: 0, False: 0] ------------------ 849| | /* 850| | * This looks like a bitstring label, which 851| | * was deprecated. Intentionally drop it. 852| | */ 853| 0| return DNS_R_BADLABELTYPE; 854| 0| } 855| 0| state = ft_escape; 856| 0| POST(state); ------------------ | | 74| 0|#define POST(x) (void)(x) ------------------ 857| 0| FALLTHROUGH; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 858| 0| case ft_escape: ------------------ | Branch (858:3): [True: 0, False: 84] ------------------ 859| 0| if (!isdigit((unsigned char)c)) { ------------------ | Branch (859:8): [True: 0, False: 0] ------------------ 860| 0| if (count >= DNS_NAME_LABELLEN) { ------------------ | | 247| 0|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (860:9): [True: 0, False: 0] ------------------ 861| 0| return DNS_R_LABELTOOLONG; 862| 0| } 863| 0| count++; 864| 0| if (downcase) { ------------------ | Branch (864:9): [True: 0, False: 0] ------------------ 865| 0| c = isc_ascii_tolower(c); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 866| 0| } 867| 0| *ndata++ = c; 868| 0| nrem--; 869| 0| nused++; 870| 0| state = ft_ordinary; 871| 0| break; 872| 0| } 873| 0| digits = 0; 874| 0| value = 0; 875| 0| state = ft_escdecimal; 876| 0| FALLTHROUGH; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 877| 0| case ft_escdecimal: ------------------ | Branch (877:3): [True: 0, False: 84] ------------------ 878| 0| if (!isdigit((unsigned char)c)) { ------------------ | Branch (878:8): [True: 0, False: 0] ------------------ 879| 0| return DNS_R_BADESCAPE; 880| 0| } 881| 0| value = 10 * value + c - '0'; 882| 0| digits++; 883| 0| if (digits == 3) { ------------------ | Branch (883:8): [True: 0, False: 0] ------------------ 884| 0| if (value > 255) { ------------------ | Branch (884:9): [True: 0, False: 0] ------------------ 885| 0| return DNS_R_BADESCAPE; 886| 0| } 887| 0| if (count >= DNS_NAME_LABELLEN) { ------------------ | | 247| 0|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (887:9): [True: 0, False: 0] ------------------ 888| 0| return DNS_R_LABELTOOLONG; 889| 0| } 890| 0| count++; 891| 0| if (downcase) { ------------------ | Branch (891:9): [True: 0, False: 0] ------------------ 892| 0| value = isc_ascii_tolower(value); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 893| 0| } 894| 0| *ndata++ = value; 895| 0| nrem--; 896| 0| nused++; 897| 0| state = ft_ordinary; 898| 0| } 899| 0| break; 900| 0| default: ------------------ | Branch (900:3): [True: 0, False: 84] ------------------ 901| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 902| | /* Does not return. */ 903| 84| } 904| 84| } 905| | 906| 16| if (!done) { ------------------ | Branch (906:6): [True: 4, False: 12] ------------------ 907| 4| if (nrem == 0) { ------------------ | Branch (907:7): [True: 0, False: 4] ------------------ 908| 0| return ISC_R_NOSPACE; 909| 0| } 910| 4| INSIST(tlen == 0); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 911| 4| if (state != ft_ordinary && state != ft_at) { ------------------ | Branch (911:7): [True: 0, False: 4] | Branch (911:31): [True: 0, False: 0] ------------------ 912| 0| return ISC_R_UNEXPECTEDEND; 913| 0| } 914| 4| if (state == ft_ordinary) { ------------------ | Branch (914:7): [True: 4, False: 0] ------------------ 915| 4| INSIST(count != 0); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 916| 4| INSIST(label != NULL); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 917| 4| *label = count; 918| 4| labels++; 919| 4| INSIST(labels < DNS_NAME_MAXLABELS); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 920| 4| } 921| 4| if (origin != NULL) { ------------------ | Branch (921:7): [True: 4, False: 0] ------------------ 922| 4| if (nrem < origin->length) { ------------------ | Branch (922:8): [True: 0, False: 4] ------------------ 923| 0| return ISC_R_NOSPACE; 924| 0| } 925| 4| label = origin->ndata; 926| 4| n1 = origin->length; 927| 4| nrem -= n1; 928| 4| POST(nrem); ------------------ | | 74| 4|#define POST(x) (void)(x) ------------------ 929| 8| while (n1 > 0) { ------------------ | Branch (929:11): [True: 4, False: 4] ------------------ 930| 4| n2 = *label++; 931| 4| INSIST(n2 <= DNS_NAME_LABELLEN); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 932| 4| *ndata++ = n2; 933| 4| n1 -= n2 + 1; 934| 4| nused += n2 + 1; 935| 4| while (n2 > 0) { ------------------ | Branch (935:12): [True: 0, False: 4] ------------------ 936| 0| c = *label++; 937| 0| if (downcase) { ------------------ | Branch (937:10): [True: 0, False: 0] ------------------ 938| 0| c = isc_ascii_tolower(c); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 939| 0| } 940| 0| *ndata++ = c; 941| 0| n2--; 942| 0| } 943| 4| labels++; 944| 4| if (n1 > 0) { ------------------ | Branch (944:9): [True: 0, False: 4] ------------------ 945| 0| INSIST(labels < DNS_NAME_MAXLABELS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 946| 0| } 947| 4| } 948| 4| if (origin->attributes.absolute) { ------------------ | Branch (948:8): [True: 4, False: 0] ------------------ 949| 4| name->attributes.absolute = true; 950| 4| } 951| 4| } 952| 12| } else { 953| 12| name->attributes.absolute = true; 954| 12| } 955| | 956| 16| name->ndata = (unsigned char *)target->base + target->used; 957| 16| name->length = nused; 958| | 959| 16| isc_buffer_forward(source, tused); 960| 16| isc_buffer_add(target, name->length); 961| | 962| 16| return ISC_R_SUCCESS; 963| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 154| 2| REQUIRE(name != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 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, ------------------ | | 210| 2|#define DNS_NAME_INITEMPTY { .magic = DNS_NAME_MAGIC } | | ------------------ | | | | 153| 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)) | | | | ------------------ | | ------------------ ------------------ 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); ------------------ | | 1522| 2| dns_name__dup(DNS_NAME__RO_ARG(source), mctx, target) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 130| | 131| 2| return node; 132| 2|} dns_notifyctx_init: 45| 4|dns_notifyctx_init(dns_notifyctx_t *nctx, dns_rdatatype_t type) { 46| 4| dns_notifyctx_t ctx = { 47| 4| .type = type, 48| 4| .notifytype = dns_notifytype_yes, 49| 4| .notifydelay = 5, 50| 4| .notifies = ISC_LIST_INITIALIZER, ------------------ | | 21| 4| { \ | | 22| 4| .head = NULL, \ | | 23| 4| .tail = NULL, \ | | 24| 4| } ------------------ 51| 4| }; 52| | 53| 4| *nctx = ctx; 54| 4|} dst__openssl_keypair_destroy: 148| 82|dst__openssl_keypair_destroy(dst_key_t *key) { 149| 82| if (key->keydata.pkeypair.priv != key->keydata.pkeypair.pub) { ------------------ | Branch (149:6): [True: 82, False: 0] ------------------ 150| 82| EVP_PKEY_free(key->keydata.pkeypair.priv); 151| 82| } 152| 82| EVP_PKEY_free(key->keydata.pkeypair.pub); 153| 82| key->keydata.pkeypair.pub = NULL; 154| | key->keydata.pkeypair.priv = NULL; 155| 82|} 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 53| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 12, False: 0] | | | | ------------------ | | | | 54| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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| 12|opensslrsa_createctx(dst_key_t *key, dst_context_t *dctx) { 90| 12| EVP_MD_CTX *evp_md_ctx; 91| 12| const EVP_MD *type = NULL; 92| | 93| 12| UNUSED(key); ------------------ | | 69| 12|#define UNUSED(x) (void)(x) ------------------ 94| 12| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 95| 12| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 96| | 97| | /* 98| | * Reject incorrect RSA key lengths. 99| | */ 100| 12| switch (dctx->key->key_alg) { 101| 0| case DST_ALG_RSASHA1: ------------------ | Branch (101:2): [True: 0, False: 12] ------------------ 102| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (102:2): [True: 0, False: 12] ------------------ 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| 12| case DST_ALG_RSASHA256: ------------------ | Branch (108:2): [True: 12, False: 0] ------------------ 109| 12| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (109:2): [True: 0, False: 12] ------------------ 110| | /* From RFC 5702 */ 111| 12| if (dctx->key->key_size < 512 || dctx->key->key_size > 4096) { ------------------ | Branch (111:7): [True: 0, False: 12] | Branch (111:36): [True: 0, False: 12] ------------------ 112| 0| return ISC_R_FAILURE; 113| 0| } 114| 12| break; 115| 12| case DST_ALG_RSASHA512: ------------------ | Branch (115:2): [True: 0, False: 12] ------------------ 116| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (116:2): [True: 0, False: 12] ------------------ 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: 12] ------------------ 123| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 124| 12| } 125| | 126| 12| evp_md_ctx = EVP_MD_CTX_create(); 127| 12| if (evp_md_ctx == NULL) { ------------------ | Branch (127:6): [True: 0, False: 12] ------------------ 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| 12| switch (dctx->key->key_alg) { 132| 0| case DST_ALG_RSASHA1: ------------------ | Branch (132:2): [True: 0, False: 12] ------------------ 133| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (133:2): [True: 0, False: 12] ------------------ 134| 0| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 135| 0| break; 136| 12| case DST_ALG_RSASHA256: ------------------ | Branch (136:2): [True: 12, False: 0] ------------------ 137| 12| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (137:2): [True: 0, False: 12] ------------------ 138| 12| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 139| 12| break; 140| 0| case DST_ALG_RSASHA512: ------------------ | Branch (140:2): [True: 0, False: 12] ------------------ 141| 0| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (141:2): [True: 0, False: 12] ------------------ 142| 0| type = isc__crypto_md[ISC_MD_SHA512]; 143| 0| break; 144| 0| default: ------------------ | Branch (144:2): [True: 0, False: 12] ------------------ 145| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 146| 12| } 147| | 148| 12| if (!EVP_DigestInit_ex(evp_md_ctx, type, NULL)) { ------------------ | Branch (148:6): [True: 0, False: 12] ------------------ 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| 12| dctx->ctxdata.evp_md_ctx = evp_md_ctx; 154| | 155| 12| return ISC_R_SUCCESS; 156| 12|} opensslrsa_link.c:opensslrsa_valid_key_alg: 74| 154|opensslrsa_valid_key_alg(unsigned int key_alg) { 75| 154| switch (key_alg) { 76| 0| case DST_ALG_RSASHA1: ------------------ | Branch (76:2): [True: 0, False: 154] ------------------ 77| 0| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (77:2): [True: 0, False: 154] ------------------ 78| 154| case DST_ALG_RSASHA256: ------------------ | Branch (78:2): [True: 154, False: 0] ------------------ 79| 154| case DST_ALG_RSASHA512: ------------------ | Branch (79:2): [True: 0, False: 154] ------------------ 80| 154| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (80:2): [True: 0, False: 154] ------------------ 81| 154| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (81:2): [True: 0, False: 154] ------------------ 82| 154| return true; 83| 0| default: ------------------ | Branch (83:2): [True: 0, False: 154] ------------------ 84| | return false; 85| 154| } 86| 154|} opensslrsa_link.c:opensslrsa_destroyctx: 159| 12|opensslrsa_destroyctx(dst_context_t *dctx) { 160| 12| EVP_MD_CTX *evp_md_ctx = NULL; 161| | 162| 12| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 163| 12| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 164| | 165| 12| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 166| | 167| 12| if (evp_md_ctx != NULL) { ------------------ | Branch (167:6): [True: 12, False: 0] ------------------ 168| 12| EVP_MD_CTX_destroy(evp_md_ctx); 169| | dctx->ctxdata.evp_md_ctx = NULL; 170| 12| } 171| 12|} opensslrsa_link.c:opensslrsa_adddata: 174| 36|opensslrsa_adddata(dst_context_t *dctx, const isc_region_t *data) { 175| 36| EVP_MD_CTX *evp_md_ctx = NULL; 176| | 177| 36| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 36|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 72| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 36, False: 0] | | | | | Branch (41:11): [True: 36, False: 0] | | | | ------------------ | | | | 42| 36| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 178| 36| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 36|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 36| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 36, False: 0] | | | | ------------------ | | | | 42| 36| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 179| | 180| 36| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 181| | 182| 36| if (!EVP_DigestUpdate(evp_md_ctx, data->base, data->length)) { ------------------ | Branch (182:6): [True: 0, False: 36] ------------------ 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| 36| return ISC_R_SUCCESS; 187| 36|} opensslrsa_link.c:opensslrsa_verify: 247| 12|opensslrsa_verify(dst_context_t *dctx, const isc_region_t *sig) { 248| 12| dst_key_t *key = NULL; 249| 12| int status = 0; 250| 12| EVP_MD_CTX *evp_md_ctx = NULL; 251| 12| EVP_PKEY *pkey = NULL; 252| 12| const unsigned char *base = sig->base; 253| 12| unsigned int length = sig->length; 254| | 255| 12| REQUIRE(dctx != NULL && dctx->key != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 256| 12| REQUIRE(opensslrsa_valid_key_alg(dctx->key->key_alg)); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 257| | 258| 12| key = dctx->key; 259| 12| evp_md_ctx = dctx->ctxdata.evp_md_ctx; 260| 12| pkey = key->keydata.pkeypair.pub; 261| | 262| 12| if (!isc_ossl_wrap_rsa_modulus_bits_in_range(pkey, rsa_min_modulus_bits, ------------------ | Branch (262:6): [True: 0, False: 12] ------------------ 263| 12| rsa_max_modulus_bits) || 264| 12| !isc_ossl_wrap_rsa_exponent_is_allowed(pkey)) ------------------ | Branch (264:6): [True: 0, False: 12] ------------------ 265| 0| { 266| 0| return DST_R_VERIFYFAILURE; 267| 0| } 268| | 269| | /* 270| | * Check identifying OID in front of public key material. 271| | */ 272| 12| switch (key->key_alg) { ------------------ | Branch (272:10): [True: 0, False: 12] ------------------ 273| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (273:2): [True: 0, False: 12] ------------------ 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: 12] ------------------ 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| 12| } 292| | 293| 12| status = EVP_VerifyFinal(evp_md_ctx, base, length, pkey); 294| 12| switch (status) { 295| 1| case 1: ------------------ | Branch (295:2): [True: 1, False: 11] ------------------ 296| 1| return ISC_R_SUCCESS; 297| 11| case 0: ------------------ | Branch (297:2): [True: 11, False: 1] ------------------ 298| 11| return dst__openssl_toresult(DST_R_VERIFYFAILURE); ------------------ | | 28| 11| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 11| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 11| __FILE__, __LINE__) ------------------ 299| 0| default: ------------------ | Branch (299:2): [True: 0, False: 12] ------------------ 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| 12| DST_R_VERIFYFAILURE); 302| 12| } 303| 12|} opensslrsa_link.c:opensslrsa_fromdns: 429| 82|opensslrsa_fromdns(dst_key_t *key, isc_buffer_t *data) { 430| 82| isc_result_t result; 431| 82| isc_region_t r; 432| 82| unsigned int e_bytes; 433| 82| unsigned int length; 434| 82| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 435| | 436| 82| REQUIRE(opensslrsa_valid_key_alg(key->key_alg)); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 437| | 438| 82| isc_buffer_remainingregion(data, &r); 439| 82| if (r.length == 0) { ------------------ | Branch (439:6): [True: 0, False: 82] ------------------ 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| 82| switch (key->key_alg) { ------------------ | Branch (446:10): [True: 0, False: 82] ------------------ 447| 0| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (447:2): [True: 0, False: 82] ------------------ 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)); ------------------ | | 51| 0| do { \ | | 52| 0| isc_region_t *_r = (r); \ | | 53| 0| unsigned int _l = (l); \ | | 54| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 0| _r->base += _l; \ | | 56| 0| _r->length -= _l; \ | | 57| 0| } while (0) | | ------------------ | | | Branch (57: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: 82] ------------------ 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)); ------------------ | | 51| 0| do { \ | | 52| 0| isc_region_t *_r = (r); \ | | 53| 0| unsigned int _l = (l); \ | | 54| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 0| _r->base += _l; \ | | 56| 0| _r->length -= _l; \ | | 57| 0| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 0] | | ------------------ ------------------ 463| 0| isc_buffer_forward(data, sizeof(oid_rsasha512)); 464| 0| break; 465| 82| } 466| | 467| 82| length = r.length; 468| 82| if (r.length < 1) { ------------------ | Branch (468:6): [True: 0, False: 82] ------------------ 469| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 470| 0| } 471| | 472| 82| e_bytes = *r.base; 473| 82| isc_region_consume(&r, 1); ------------------ | | 51| 82| do { \ | | 52| 82| isc_region_t *_r = (r); \ | | 53| 82| unsigned int _l = (l); \ | | 54| 82| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 82| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 82, False: 0] | | | | | | ------------------ | | | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 82| _r->base += _l; \ | | 56| 82| _r->length -= _l; \ | | 57| 82| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 82] | | ------------------ ------------------ 474| | 475| 82| if (e_bytes == 0) { ------------------ | Branch (475:6): [True: 0, False: 82] ------------------ 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); ------------------ | | 51| 0| do { \ | | 52| 0| isc_region_t *_r = (r); \ | | 53| 0| unsigned int _l = (l); \ | | 54| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 0| _r->base += _l; \ | | 56| 0| _r->length -= _l; \ | | 57| 0| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 0] | | ------------------ ------------------ 481| 0| e_bytes += *r.base; 482| 0| isc_region_consume(&r, 1); ------------------ | | 51| 0| do { \ | | 52| 0| isc_region_t *_r = (r); \ | | 53| 0| unsigned int _l = (l); \ | | 54| 0| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 0| _r->base += _l; \ | | 56| 0| _r->length -= _l; \ | | 57| 0| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 0] | | ------------------ ------------------ 483| 0| } 484| | 485| 82| if (r.length < e_bytes) { ------------------ | Branch (485:6): [True: 0, False: 82] ------------------ 486| 0| CLEANUP(DST_R_INVALIDPUBLICKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 487| 0| } 488| 82| if (e_bytes > rsa_max_exponent_bytes || ------------------ | Branch (488:6): [True: 0, False: 82] ------------------ 489| 82| r.length - e_bytes > rsa_max_modulus_bytes) ------------------ | Branch (489:6): [True: 0, False: 82] ------------------ 490| 0| { 491| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 492| 0| } 493| 82| c.e = BN_bin2bn(r.base, e_bytes, NULL); 494| 82| isc_region_consume(&r, e_bytes); ------------------ | | 51| 82| do { \ | | 52| 82| isc_region_t *_r = (r); \ | | 53| 82| unsigned int _l = (l); \ | | 54| 82| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 82|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 82| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 82, False: 0] | | | | | | ------------------ | | | | | | 54| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 82| _r->base += _l; \ | | 56| 82| _r->length -= _l; \ | | 57| 82| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 82] | | ------------------ ------------------ 495| 82| c.n = BN_bin2bn(r.base, r.length, NULL); 496| 82| if (c.e == NULL || c.n == NULL) { ------------------ | Branch (496:6): [True: 0, False: 82] | Branch (496:21): [True: 0, False: 82] ------------------ 497| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 498| 0| } 499| 82| if (BN_num_bits(c.n) < rsa_min_modulus_bits || ------------------ | Branch (499:6): [True: 0, False: 82] ------------------ 500| 82| BN_num_bits(c.n) > rsa_max_modulus_bits) ------------------ | Branch (500:6): [True: 0, False: 82] ------------------ 501| 0| { 502| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 503| 0| } 504| 82| if (!rsa_exponent_in_range(c.e)) { ------------------ | Branch (504:6): [True: 0, False: 82] ------------------ 505| 0| CLEANUP(ISC_R_RANGE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 506| 0| } 507| 82| isc_buffer_forward(data, length); 508| | 509| 82| key->key_size = BN_num_bits(c.n); 510| 82| result = isc_ossl_wrap_load_rsa_public_from_components( 511| 82| &c, &key->keydata.pkeypair.pub); 512| | 513| 82|cleanup: 514| 82| isc_ossl_wrap_rsa_components_cleanup(&c); 515| 82| return result; 516| 82|} opensslrsa_link.c:rsa_exponent_in_range: 49| 82|rsa_exponent_in_range(const BIGNUM *e) { 50| 82| if (!BN_is_odd(e)) { ------------------ | Branch (50:6): [True: 0, False: 82] ------------------ 51| 0| return false; 52| 0| } 53| | 54| 82| if (BN_cmp(e, rsa_exponent_min) < 0) { ------------------ | Branch (54:6): [True: 0, False: 82] ------------------ 55| 0| return false; 56| 0| } 57| | 58| 82| if (BN_cmp(e, rsa_exponent_max) > 0) { ------------------ | Branch (58:6): [True: 0, False: 82] ------------------ 59| 0| return false; 60| 0| } 61| | 62| 82| return true; 63| 82|} 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, Folded] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 47| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 2, False: 0] | | | | ------------------ | | | | 48| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 217| 2|} dns_qpkey_fromname: 243| 1.44k| dns_namespace_t space) { 244| 1.44k| REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); ------------------ | | 198| 1.44k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.88k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | ------------------ | | | | 42| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 245| | 246| 1.44k| dns_offsets_t offsets; 247| 1.44k| size_t labels = dns_name_offsets(name, offsets); 248| 1.44k| size_t len = 0; 249| | 250| | /* namespace */ 251| 1.44k| key[len++] = ENCODE_NAMESPACE(space); ------------------ | | 124| 1.44k|#define ENCODE_NAMESPACE(c) dns_qp_bits_for_byte[(c) + (uint8_t)'0'] ------------------ 252| | /* name */ 253| 1.44k| if (labels == 0) { ------------------ | Branch (253:6): [True: 0, False: 1.44k] ------------------ 254| 0| key[len] = SHIFT_NOBYTE; 255| 0| return len; 256| 0| } 257| | 258| 1.44k| size_t label = labels; 259| 18.8k| while (label-- > 0) { ------------------ | Branch (259:9): [True: 17.4k, False: 1.44k] ------------------ 260| 17.4k| const uint8_t *ldata = name->ndata + offsets[label]; 261| 17.4k| size_t label_len = *ldata++; 262| 70.6k| while (label_len-- > 0) { ------------------ | Branch (262:10): [True: 53.1k, False: 17.4k] ------------------ 263| 53.1k| uint16_t bits = dns_qp_bits_for_byte[*ldata++]; 264| 53.1k| key[len++] = bits & 0xFF; /* bit_one */ 265| 53.1k| if ((bits >> 8) != 0) { /* escape? */ ------------------ | Branch (265:8): [True: 40.2k, False: 12.9k] ------------------ 266| 40.2k| key[len++] = bits >> 8; /* bit_two */ 267| 40.2k| } 268| 53.1k| } 269| | /* label terminator */ 270| 17.4k| key[len++] = SHIFT_NOBYTE; 271| 17.4k| } 272| | /* mark end with a double NOBYTE */ 273| 1.44k| key[len] = SHIFT_NOBYTE; 274| 1.44k| ENSURE(len < sizeof(dns_qpkey_t)); ------------------ | | 200| 1.44k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 1.44k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 1.44k, False: 0] | | | | ------------------ | | | | 48| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 275| 1.44k| return len; 276| 1.44k|} 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) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1022| 6| if (mode == DNS_QPGC_MAYBE && !QP_NEEDGC(qp)) { ------------------ | | 196| 6|#define QP_NEEDGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count) | | ------------------ | | | | 194| 6| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 160| 6|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 149| 6|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (194:3): [True: 0, False: 6] | | | | | Branch (194: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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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), ------------------ | | 196| 2|#define QP_NEEDGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count) | | ------------------ | | | | 194| 2| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 160| 2|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 149| 2|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (194:3): [True: 0, False: 2] | | | | | Branch (194: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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 2, False: 0] | | | | | Branch (53:11): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1261| 8| REQUIRE(qptp != NULL && *qptp == &multi->writer); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1262| 8| REQUIRE(multi->writer.transaction_mode == QP_WRITE || ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 53| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 8, False: 0] | | | | ------------------ | | | | 54| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1280| | 1281| | /* not the first commit? */ 1282| 8| if (multi->reader_ref != INVALID_REF) { ------------------ | | 230| 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1284| 2| free_twigs(qp, multi->reader_ref, READER_SIZE); ------------------ | | 841| 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); ------------------ | | 841| 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); ------------------ | | 841| 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) | | | | ------------------ | | | | | | 53| 16| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:11): [True: 8, False: 0] | | | | | | | Branch (53:11): [True: 8, False: 0] | | | | | | ------------------ | | | | | | 54| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 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)) { ------------------ | | 196| 8|#define QP_NEEDGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count) | | ------------------ | | | | 194| 8| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 160| 8|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 149| 8|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (194:3): [True: 0, False: 8] | | | | | Branch (194: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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| 603|dns_qpmulti_query(dns_qpmulti_t *multi, dns_qpread_t *qp) { 1398| 603| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 198| 603|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 603, False: 0] | | | | | Branch (41:11): [True: 603, False: 0] | | | | ------------------ | | | | 42| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1399| 603| REQUIRE(qp != NULL); ------------------ | | 198| 603|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 603| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 603, False: 0] | | | | ------------------ | | | | 42| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1400| | 1401| 603| qp->tid = isc_tid(); 1402| 603| rcu_read_lock(); 1403| | 1404| 603| dns_qpmulti_t *whence = reader_open(multi, qp); 1405| 603| INSIST(whence == multi); ------------------ | | 202| 603|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 603| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 603, False: 0] | | | | ------------------ | | | | 54| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1406| 603|} dns_qpread_destroy: 1409| 603|dns_qpread_destroy(dns_qpmulti_t *multi, dns_qpread_t *qp) { 1410| 603| REQUIRE(QPMULTI_VALID(multi)); ------------------ | | 198| 603|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 603, False: 0] | | | | | Branch (41:11): [True: 603, False: 0] | | | | ------------------ | | | | 42| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1411| 603| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 603|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 603, False: 0] | | | | | Branch (41:11): [True: 603, False: 0] | | | | ------------------ | | | | 42| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1412| 603| REQUIRE(qp->tid == isc_tid()); ------------------ | | 198| 603|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 603| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 603, False: 0] | | | | ------------------ | | | | 42| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1413| 603| *qp = (dns_qpread_t){}; 1414| | rcu_read_unlock(); 1415| 603|} dns_qpmulti_create: 1511| 8| dns_qpmulti_t **qpmp) { 1512| 8| REQUIRE(qpmp != NULL && *qpmp == NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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, ------------------ | | 371| 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, ------------------ | | 230| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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); ------------------ | | 394| 8| (*(qp) = (typeof(*(qp))){ \ | | 395| 8| .magic = QP_MAGIC, \ | | ------------------ | | | | 368| 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)) | | | | ------------------ | | ------------------ | | 396| 8| .root_ref = INVALID_REF, \ | | ------------------ | | | | 230| 8|#define INVALID_REF ((dns_qpref_t)~0UL) | | ------------------ | | 397| 8| .uctx = x, \ | | 398| 8| .methods = m, \ | | 399| 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) | | ------------------ | | | | 41| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 10, False: 0] | | | | | Branch (41:11): [True: 10, False: 0] | | | | ------------------ | | | | 42| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1778| 2| REQUIRE(search_keylen < sizeof(dns_qpkey_t)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1814| 0| INSIST(n == get_root(qp)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1815| 0| free_twigs(qp, qp->root_ref, 1); 1816| 0| qp->root_ref = INVALID_REF; ------------------ | | 230| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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| 597|dns_qpchain_init(dns_qpreadable_t qpr, dns_qpchain_t *chain) { 1862| 597| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 597|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1863| 597| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 597|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 597, False: 0] | | | | | Branch (41:11): [True: 597, False: 0] | | | | ------------------ | | | | 42| 597| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1864| 597| REQUIRE(chain != NULL); ------------------ | | 198| 597|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 597| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 597, False: 0] | | | | ------------------ | | | | 42| 597| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 597| chain->magic = QPCHAIN_MAGIC; ------------------ | | 370| 597|#define QPCHAIN_MAGIC ISC_MAGIC('q', 'p', 'c', 'h') | | ------------------ | | | | 31| 597|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1872| 597| chain->qp = qp; 1873| 597| chain->len = 0; 1874| 597|} dns_qpchain_length: 1877| 416|dns_qpchain_length(dns_qpchain_t *chain) { 1878| 416| REQUIRE(QPCHAIN_VALID(chain)); ------------------ | | 198| 416|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 832| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 416, False: 0] | | | | | Branch (41:11): [True: 416, False: 0] | | | | ------------------ | | | | 42| 416| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1879| | 1880| 416| return chain->len; 1881| 416|} dns_qpchain_node: 1885| 299| uint32_t *ival_r) { 1886| 299| dns_qpnode_t *node = NULL; 1887| | 1888| 299| REQUIRE(QPCHAIN_VALID(chain)); ------------------ | | 198| 299|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 598| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 299, False: 0] | | | | | Branch (41:11): [True: 299, False: 0] | | | | ------------------ | | | | 42| 299| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1889| 299| REQUIRE(level < chain->len); ------------------ | | 198| 299|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 299| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 299, False: 0] | | | | ------------------ | | | | 42| 299| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1890| | 1891| 299| node = chain->chain[level].node; 1892| 299| SET_IF_NOT_NULL(pval_r, leaf_pval(node)); ------------------ | | 104| 299| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 299, False: 0] | | ------------------ | | 105| 299| *(obj) = (val); \ | | 106| 299| } ------------------ 1893| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 104| 299| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 299] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 1894| 299|} dns_qpiter_init: 1901| 688|dns_qpiter_init(dns_qpreadable_t qpr, dns_qpiter_t *qpi) { 1902| 688| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 688|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1903| 688| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 688|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 688, False: 0] | | | | | Branch (41:11): [True: 688, False: 0] | | | | ------------------ | | | | 42| 688| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1904| 688| REQUIRE(qpi != NULL); ------------------ | | 198| 688|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 688| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 688, False: 0] | | | | ------------------ | | | | 42| 688| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 688| qpi->qp = qp; 1912| 688| qpi->sp = 0; 1913| 688| qpi->magic = QPITER_MAGIC; ------------------ | | 369| 688|#define QPITER_MAGIC ISC_MAGIC('q', 'p', 'i', 't') | | ------------------ | | | | 31| 688|#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| 688|} dns_qpiter_next: 2023| 273|dns_qpiter_next(dns_qpiter_t *qpi, void **pval_r, uint32_t *ival_r) { 2024| | return iterate(true, qpi, pval_r, ival_r); 2025| 273|} dns_qpiter_current: 2033| 91|dns_qpiter_current(dns_qpiter_t *qpi, void **pval_r, uint32_t *ival_r) { 2034| 91| dns_qpnode_t *node = NULL; 2035| | 2036| 91| REQUIRE(QPITER_VALID(qpi)); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 91, False: 0] | | | | | Branch (41:11): [True: 91, False: 0] | | | | ------------------ | | | | 42| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2037| | 2038| 91| node = qpi->stack[qpi->sp]; 2039| 91| if (node == NULL || is_branch(node)) { ------------------ | Branch (2039:6): [True: 0, False: 91] | Branch (2039:22): [True: 0, False: 91] ------------------ 2040| 0| return ISC_R_FAILURE; 2041| 0| } 2042| | 2043| 91| SET_IF_NOT_NULL(pval_r, leaf_pval(node)); ------------------ | | 104| 91| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 91, False: 0] | | ------------------ | | 105| 91| *(obj) = (val); \ | | 106| 91| } ------------------ 2044| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 104| 91| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 91] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 2045| 91| return ISC_R_SUCCESS; 2046| 91|} 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) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2063| 12| REQUIRE(search_keylen < sizeof(dns_qpkey_t)); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 597| void **pval_r, uint32_t *ival_r) { 2273| 597| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 597|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 2274| 597| dns_qpkey_t search, found; 2275| 597| size_t searchlen, foundlen; 2276| 597| size_t offset = 0; 2277| 597| dns_qpnode_t *n = NULL; 2278| 597| dns_qpshift_t bit = SHIFT_NOBYTE; 2279| 597| dns_qpchain_t oc; 2280| 597| dns_qpiter_t it; 2281| 597| bool matched = false; 2282| 597| bool setiter = true; 2283| | 2284| 597| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 597|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 597, False: 0] | | | | | Branch (41:11): [True: 597, False: 0] | | | | ------------------ | | | | 42| 597| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2285| | 2286| 597| searchlen = dns_qpkey_fromname(search, name, space); 2287| | 2288| 597| if (chain == NULL) { ------------------ | Branch (2288:6): [True: 0, False: 597] ------------------ 2289| 0| chain = &oc; 2290| 0| } 2291| 597| if (iter == NULL) { ------------------ | Branch (2291:6): [True: 389, False: 208] ------------------ 2292| 389| iter = ⁢ 2293| 389| setiter = false; 2294| 389| } 2295| 597| dns_qpchain_init(qp, chain); 2296| 597| dns_qpiter_init(qp, iter); 2297| | 2298| 597| n = get_root(qp); 2299| 597| if (n == NULL) { ------------------ | Branch (2299:6): [True: 0, False: 597] ------------------ 2300| 0| return ISC_R_NOTFOUND; 2301| 0| } 2302| 597| 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| 805| while (is_branch(n)) { ------------------ | Branch (2311:9): [True: 208, False: 597] ------------------ 2312| 208| prefetch_twigs(qp, n); 2313| | 2314| 208| offset = branch_key_offset(n); 2315| 208| bit = qpkey_bit(search, searchlen, offset); 2316| 208| 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| 208| if (bit != SHIFT_NOBYTE && branch_has_twig(n, SHIFT_NOBYTE) && ------------------ | Branch (2332:7): [True: 208, False: 0] | Branch (2332:30): [True: 0, False: 208] ------------------ 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| 208| matched = branch_has_twig(n, bit); 2340| 208| if (matched) { ------------------ | Branch (2340:7): [True: 208, 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| 208| n = branch_twig_ptr(qp, n, bit); 2347| 208| } 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| 208| iter->stack[++iter->sp] = n; 2357| 208| } 2358| | 2359| 597| if (setiter) { ------------------ | Branch (2359:6): [True: 208, False: 389] ------------------ 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| 208| fix_iterator(qp, iter, search, searchlen); 2366| 208| n = iter->stack[iter->sp]; 2367| 208| } 2368| | 2369| | /* at this point, n can only be a leaf node */ 2370| 597| INSIST(!is_branch(n)); ------------------ | | 202| 597|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 597| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 597, False: 0] | | | | ------------------ | | | | 54| 597| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2371| | 2372| 597| foundlen = leaf_qpkey(qp, n, found); 2373| 597| offset = qpkey_compare(search, searchlen, found, foundlen); 2374| | 2375| | /* the search ended with an exact or partial match */ 2376| 597| if (offset == QPKEY_EQUAL || offset == foundlen) { ------------------ | | 364| 1.19k|#define QPKEY_EQUAL (~(size_t)0) ------------------ | Branch (2376:6): [True: 234, False: 363] | Branch (2376:31): [True: 182, False: 181] ------------------ 2377| 416| isc_result_t result = ISC_R_SUCCESS; 2378| | 2379| 416| if (offset == foundlen) { ------------------ | Branch (2379:7): [True: 182, False: 234] ------------------ 2380| 182| fix_chain(chain, offset); 2381| 182| result = DNS_R_PARTIALMATCH; 2382| 182| } 2383| 416| add_link(chain, n, offset); 2384| | 2385| 416| SET_IF_NOT_NULL(pval_r, leaf_pval(n)); ------------------ | | 104| 416| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 416, False: 0] | | ------------------ | | 105| 416| *(obj) = (val); \ | | 106| 416| } ------------------ 2386| 416| SET_IF_NOT_NULL(ival_r, leaf_ival(n)); ------------------ | | 104| 416| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 416] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 2387| 416| return result; 2388| 416| } 2389| | 2390| | /* 2391| | * the requested name was not found, but if an ancestor 2392| | * was, we can retrieve that from the chain. 2393| | */ 2394| 181| int len = chain->len; 2395| 181| while (len-- > 0) { ------------------ | Branch (2395:9): [True: 0, False: 181] ------------------ 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| 181| return ISC_R_NOTFOUND; 2413| 181|} 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) | | ------------------ | | | | 47| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 6, False: 0] | | | | ------------------ | | | | 48| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 582| 6| realloc_chunk_arrays(qp, GROWTH_FACTOR(chunk)); ------------------ | | 203| 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) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 512| 6| INSIST(qp->usage[chunk].used == 0); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 513| 6| INSIST(qp->usage[chunk].free == 0); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 514| 6| INSIST(qp->chunk_capacity <= QP_CHUNK_SIZE); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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; ------------------ | | 373| 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) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1153| 8| REQUIRE(qptp != NULL && *qptp == NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | ------------------ | | | | 53| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 8, False: 0] | | | | | Branch (53:11): [True: 8, False: 0] | | | | ------------------ | | | | 54| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 47| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 4, False: 0] | | | | ------------------ | | | | 48| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 628| 4| ENSURE(qp->usage[chunk].free <= qp->usage[chunk].used); ------------------ | | 200| 4|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 4, False: 0] | | | | ------------------ | | | | 48| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 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) | | ------------------ | | | | 47| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 2, False: 0] | | | | ------------------ | | | | 48| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 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, ------------------ | | 374| 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| 603|reader_open(dns_qpmulti_t *multi, dns_qpreadable_t qpr) { 1382| 603| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 603|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 1383| 603| dns_qpnode_t *reader = rcu_dereference(multi->reader); 1384| 603| if (reader == NULL) { ------------------ | Branch (1384:6): [True: 0, False: 603] ------------------ 1385| 0| QP_INIT(qp, multi->writer.methods, multi->writer.uctx); ------------------ | | 394| 0| (*(qp) = (typeof(*(qp))){ \ | | 395| 0| .magic = QP_MAGIC, \ | | ------------------ | | | | 368| 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)) | | | | ------------------ | | ------------------ | | 396| 0| .root_ref = INVALID_REF, \ | | ------------------ | | | | 230| 0|#define INVALID_REF ((dns_qpref_t)~0UL) | | ------------------ | | 397| 0| .uctx = x, \ | | 398| 0| .methods = m, \ | | 399| 0| }) ------------------ 1386| 603| } else { 1387| 603| multi = unpack_reader(qp, reader); 1388| 603| } 1389| 603| return multi; 1390| 603|} 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| 821| const dns_qpkey_t key_b, const size_t keylen_b) { 382| 821| size_t keylen = ISC_MAX(keylen_a, keylen_b); ------------------ | | 76| 821|#define ISC_MAX(a, b) ((a) > (b) ? (a) : (b)) | | ------------------ | | | Branch (76:24): [True: 422, False: 399] | | ------------------ ------------------ 383| 7.70k| for (size_t offset = 0; offset < keylen; offset++) { ------------------ | Branch (383:26): [True: 7.33k, False: 363] ------------------ 384| 7.33k| if (qpkey_bit(key_a, keylen_a, offset) != ------------------ | Branch (384:7): [True: 458, False: 6.88k] ------------------ 385| 7.33k| qpkey_bit(key_b, keylen_b, offset)) 386| 458| { 387| 458| return offset; 388| 458| } 389| 7.33k| } 390| 363| return QPKEY_EQUAL; ------------------ | | 364| 363|#define QPKEY_EQUAL (~(size_t)0) ------------------ 391| 821|} 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)); ------------------ | | 735| 0| (&(dns_qpnode_t){ \ | | 736| 0| .biglo = BRANCH_TAG | (1 << SHIFT_NOBYTE), \ | | 737| 0| .small = qp->root_ref, \ | | 738| 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)) { ------------------ | | 197| 2|#define QP_AUTOGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count - (qp)->hold_count) | | ------------------ | | | | 194| 2| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 160| 2|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 149| 2|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (194:3): [True: 0, False: 2] | | | | | Branch (194: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)) { ------------------ | | 197| 0|#define QP_AUTOGC(qp) QP_GC_HEURISTIC(qp, (qp)->free_count - (qp)->hold_count) | | ------------------ | | | | 194| 0| ((free) > QP_CHUNK_SIZE * 4 && (free) > (qp)->used_count / 2) | | | | ------------------ | | | | | | 160| 0|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | | | | | ------------------ | | | | | | | | 149| 0|#define QP_CHUNK_LOG_MAX 7 | | | | | | ------------------ | | | | ------------------ | | | | | Branch (194:3): [True: 0, False: 0] | | | | | Branch (194: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)); ------------------ | | 917| 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| 273|iterate(bool forward, dns_qpiter_t *qpi, void **pval_r, uint32_t *ival_r) { 1945| 273| dns_qpnode_t *node = NULL; 1946| 273| bool initial_branch = true; 1947| | 1948| 273| REQUIRE(QPITER_VALID(qpi)); ------------------ | | 198| 273|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 546| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 273, False: 0] | | | | | Branch (41:11): [True: 273, False: 0] | | | | ------------------ | | | | 42| 273| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1949| | 1950| 273| dns_qpreader_t *qp = qpi->qp; 1951| | 1952| 273| REQUIRE(QP_VALID(qp)); ------------------ | | 198| 273|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 546| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 273, False: 0] | | | | | Branch (41:11): [True: 273, False: 0] | | | | ------------------ | | | | 42| 273| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1953| | 1954| 273| node = get_root(qp); 1955| 273| if (node == NULL) { ------------------ | Branch (1955:6): [True: 0, False: 273] ------------------ 1956| 0| return ISC_R_NOMORE; 1957| 0| } 1958| | 1959| 364| do { 1960| 364| if (qpi->stack[qpi->sp] == NULL) { ------------------ | Branch (1960:7): [True: 0, False: 364] ------------------ 1961| | /* newly initialized iterator: use the root node */ 1962| 0| INSIST(qpi->sp == 0); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1963| 0| qpi->stack[0] = node; 1964| 364| } else if (!initial_branch) { ------------------ | Branch (1964:14): [True: 0, False: 364] ------------------ 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1973| 364| } else if (last_twig(qpi, forward)) { ------------------ | Branch (1973:14): [True: 182, False: 182] ------------------ 1974| | /* 1975| | * we've stepped to the end (or the beginning, 1976| | * if we're iterating backwards) of a set of twigs. 1977| | */ 1978| 182| if (qpi->sp == 0) { ------------------ | Branch (1978:8): [True: 91, False: 91] ------------------ 1979| | /* 1980| | * we've finished iterating. reinitialize 1981| | * the iterator, then return ISC_R_NOMORE. 1982| | */ 1983| 91| dns_qpiter_init(qpi->qp, qpi); 1984| 91| return ISC_R_NOMORE; 1985| 91| } 1986| | 1987| | /* 1988| | * pop the stack, and resume at the parent branch. 1989| | */ 1990| 91| qpi->stack[qpi->sp] = NULL; 1991| 91| qpi->sp--; 1992| 91| continue; 1993| 182| } else { 1994| | /* 1995| | * there are more twigs in the current branch, 1996| | * so step the node pointer forward (or back). 1997| | */ 1998| 182| qpi->stack[qpi->sp] += (forward ? 1 : -1); ------------------ | Branch (1998:28): [True: 182, False: 0] ------------------ 1999| 182| node = qpi->stack[qpi->sp]; 2000| 182| } 2001| | 2002| | /* 2003| | * if we're at a branch now, we loop down to the 2004| | * left- or rightmost leaf. 2005| | */ 2006| 182| if (is_branch(node)) { ------------------ | Branch (2006:7): [True: 0, False: 182] ------------------ 2007| 0| qpi->sp++; 2008| 0| INSIST(qpi->sp < DNS_QP_MAXKEY); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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| 273| } while (is_branch(node)); ------------------ | Branch (2014:11): [True: 91, False: 182] ------------------ 2015| | 2016| | /* we're at a leaf: return its data to the caller */ 2017| 182| SET_IF_NOT_NULL(pval_r, leaf_pval(node)); ------------------ | | 104| 182| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 91, False: 91] | | ------------------ | | 105| 91| *(obj) = (val); \ | | 106| 91| } ------------------ 2018| | SET_IF_NOT_NULL(ival_r, leaf_ival(node)); ------------------ | | 104| 182| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 0, False: 182] | | ------------------ | | 105| 0| *(obj) = (val); \ | | 106| 0| } ------------------ 2019| 182| return ISC_R_SUCCESS; 2020| 273|} qp.c:last_twig: 1925| 364|last_twig(dns_qpiter_t *qpi, bool forward) { 1926| 364| dns_qpweight_t pos = 0, max = 0; 1927| 364| if (qpi->sp > 0) { ------------------ | Branch (1927:6): [True: 273, False: 91] ------------------ 1928| 273| dns_qpnode_t *child = qpi->stack[qpi->sp]; 1929| 273| dns_qpnode_t *parent = qpi->stack[qpi->sp - 1]; 1930| 273| pos = child - ref_ptr(qpi->qp, branch_twigs_ref(parent)); 1931| 273| if (forward) { ------------------ | Branch (1931:7): [True: 273, False: 0] ------------------ 1932| 273| max = branch_twigs_size(parent) - 1; 1933| 273| } 1934| 273| } 1935| 364| return pos == max; 1936| 364|} qp.c:add_link: 2100| 416|add_link(dns_qpchain_t *chain, dns_qpnode_t *node, size_t offset) { 2101| | /* prevent duplication */ 2102| 416| if (chain->len != 0 && chain->chain[chain->len - 1].node == node) { ------------------ | Branch (2102:6): [True: 0, False: 416] | Branch (2102:25): [True: 0, False: 0] ------------------ 2103| 0| return; 2104| 0| } 2105| 416| chain->chain[chain->len].node = node; 2106| 416| chain->chain[chain->len].offset = offset; 2107| 416| chain->len++; 2108| 416| INSIST(chain->len <= DNS_NAME_MAXLABELS); ------------------ | | 202| 416|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 416, False: 0] | | | | ------------------ | | | | 54| 416| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2109| 416|} qp.c:fix_iterator: 2164| 208| size_t len) { 2165| 208| dns_qpnode_t *n = it->stack[it->sp]; 2166| | 2167| 208| REQUIRE(!is_branch(n)); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2168| | 2169| 208| dns_qpkey_t found; 2170| 208| size_t foundlen = leaf_qpkey(qp, n, found); 2171| 208| 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| 208| if (to == QPKEY_EQUAL) { ------------------ | | 364| 208|#define QPKEY_EQUAL (~(size_t)0) ------------------ | Branch (2174:6): [True: 117, False: 91] ------------------ 2175| 117| return; 2176| 117| } 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| 91| if (to < branch_key_offset(it->stack[0])) { ------------------ | Branch (2185:6): [True: 0, False: 91] ------------------ 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| 91| while (it->sp > 0) { ------------------ | Branch (2195:9): [True: 91, False: 0] ------------------ 2196| 91| dns_qpnode_t *b = it->stack[it->sp - 1]; 2197| 91| if (branch_key_offset(b) < to) { ------------------ | Branch (2197:7): [True: 91, False: 0] ------------------ 2198| 91| break; 2199| 91| } 2200| 0| it->sp--; 2201| 0| } 2202| 91| 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| 91| dns_qpshift_t kbit = qpkey_bit(key, len, to); 2210| 91| dns_qpshift_t fbit = qpkey_bit(found, foundlen, to); 2211| 91| dns_qpshift_t sbit = 0; 2212| | 2213| 91| if (is_branch(n) && branch_key_offset(n) == to) { ------------------ | Branch (2213:6): [True: 0, False: 91] | Branch (2213:22): [True: 0, False: 0] ------------------ 2214| | /* We are on the correct branch now. */ 2215| 0| sbit = kbit; 2216| 91| } else if (it->sp == 0) { ------------------ | Branch (2216:13): [True: 0, False: 91] ------------------ 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| 91| } else { 2226| | /* We are at the first unmatched node, pop up the stack. */ 2227| 91| n = it->stack[--it->sp]; 2228| 91| sbit = qpkey_bit(key, len, branch_key_offset(n)); 2229| 91| } 2230| | 2231| 91| INSIST(is_branch(n)); ------------------ | | 202| 91|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 91| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 91, False: 0] | | | | ------------------ | | | | 54| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2232| | 2233| 91| prefetch_twigs(qp, n); 2234| 91| dns_qpnode_t *twigs = branch_twigs(qp, n); 2235| 91| int toff = twig_offset(n, sbit, kbit, fbit); 2236| 91| if (toff >= 0) { ------------------ | Branch (2236:6): [True: 91, 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| 91| greatest_leaf(qp, twigs + toff, it); 2243| 91| } 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| 91|} qp.c:twig_offset: 2141| 91| dns_qpshift_t fbit) { 2142| 91| dns_qpweight_t pos = branch_twig_pos(n, sbit); 2143| 91| if (branch_has_twig(n, sbit)) { ------------------ | Branch (2143:6): [True: 91, False: 0] ------------------ 2144| 91| return pos - (kbit < fbit); 2145| 91| } 2146| 0| return pos - 1; 2147| 91|} qp.c:greatest_leaf: 2121| 91|greatest_leaf(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpiter_t *iter) { 2122| 91| while (is_branch(n)) { ------------------ | Branch (2122:9): [True: 0, False: 91] ------------------ 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| 91| iter->stack[++iter->sp] = n; 2129| 91|} qp.c:fix_chain: 2260| 182|fix_chain(dns_qpchain_t *chain, size_t offset) { 2261| 182| while (chain->len > 0 && chain->chain[chain->len - 1].offset >= offset) ------------------ | Branch (2261:9): [True: 0, False: 182] | 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| 182|} qp.c:qp_common_character: 931| 512|qp_common_character(uint8_t byte) { 932| 512| return ('-' <= byte && byte <= '9') || ('_' <= byte && byte <= 'z'); ------------------ | Branch (932:10): [True: 422, False: 90] | Branch (932:25): [True: 26, False: 396] | Branch (932:42): [True: 322, False: 164] | Branch (932:57): [True: 56, False: 266] ------------------ 933| 512|} qp.c:qpkey_bit: 672| 15.1k|qpkey_bit(const dns_qpkey_t key, size_t len, size_t offset) { 673| 15.1k| if (offset < len) { ------------------ | Branch (673:6): [True: 14.7k, False: 390] ------------------ 674| 14.7k| return key[offset]; 675| 14.7k| } else { 676| 390| return SHIFT_NOBYTE; 677| 390| } 678| 15.1k|} qp.c:make_ref: 211| 24|make_ref(dns_qpchunk_t chunk, dns_qpcell_t cell) { 212| 24| return QP_CHUNK_SIZE * chunk + cell; ------------------ | | 160| 24|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 149| 24|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 213| 24|} qp.c:ref_chunk: 216| 2.03k|ref_chunk(dns_qpref_t ref) { 217| 2.03k| return ref / QP_CHUNK_SIZE; ------------------ | | 160| 2.03k|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 149| 2.03k|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 218| 2.03k|} qp.c:ref_cell: 221| 2.03k|ref_cell(dns_qpref_t ref) { 222| 2.03k| return ref % QP_CHUNK_SIZE; ------------------ | | 160| 2.03k|#define QP_CHUNK_SIZE (1U << QP_CHUNK_LOG_MAX) | | ------------------ | | | | 149| 2.03k|#define QP_CHUNK_LOG_MAX 7 | | ------------------ ------------------ 223| 2.03k|} qp.c:zero_twigs: 803| 2|zero_twigs(dns_qpnode_t *twigs, dns_qpweight_t size) { 804| 2| memset(twigs, 0, size * sizeof(dns_qpnode_t)); 805| 2|} qp.c:ref_ptr: 358| 2.02k|ref_ptr(dns_qpreadable_t qpr, dns_qpref_t ref) { 359| 2.02k| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 2.02k|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 360| 2.02k| return qp->base->ptr[ref_chunk(ref)] + ref_cell(ref); 361| 2.02k|} qp.c:make_reader: 848| 8|make_reader(dns_qpnode_t *reader, dns_qpmulti_t *multi) { 849| 8| dns_qp_t *qp = &multi->writer; 850| 8| reader[0] = make_node(READER_TAG | (uintptr_t)multi, QPREADER_MAGIC); ------------------ | | 372| 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)) | | ------------------ ------------------ 851| 8| reader[1] = make_node(READER_TAG | (uintptr_t)qp->base, qp->root_ref); 852| 8|} qp.c:node_tag: 603| 1.21k|node_tag(dns_qpnode_t *n) { 604| 1.21k| return n->biglo & TAG_MASK; 605| 1.21k|} qp.c:node_pointer: 595| 2.95k|node_pointer(dns_qpnode_t *n) { 596| 2.95k| return (void *)(uintptr_t)(node64(n) & ~TAG_MASK); 597| 2.95k|} qp.c:node64: 564| 4.56k|node64(dns_qpnode_t *n) { 565| 4.56k| uint64_t lo = n->biglo; 566| 4.56k| uint64_t hi = n->bighi; 567| 4.56k| return lo | (hi << 32); 568| 4.56k|} qp.c:reader_valid: 855| 603|reader_valid(dns_qpnode_t *reader) { 856| 603| return reader != NULL && // ------------------ | Branch (856:9): [True: 603, False: 0] ------------------ 857| 603| node_tag(&reader[0]) == READER_TAG && ------------------ | Branch (857:9): [True: 603, False: 0] ------------------ 858| 603| node_tag(&reader[1]) == READER_TAG && ------------------ | Branch (858:9): [True: 603, False: 0] ------------------ 859| 603| node32(&reader[0]) == QPREADER_MAGIC; ------------------ | | 372| 603|#define QPREADER_MAGIC ISC_MAGIC('q', 'p', 'r', 'x') | | ------------------ | | | | 31| 1.20k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ | Branch (859:9): [True: 603, False: 0] ------------------ 860| 603|} qp.c:node32: 574| 3.15k|node32(dns_qpnode_t *n) { 575| 3.15k| return n->small; 576| 3.15k|} qp.c:unpack_reader: 867| 603|unpack_reader(dns_qpreader_t *qp, dns_qpnode_t *reader) { 868| 603| INSIST(reader_valid(reader)); ------------------ | | 202| 603|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 603| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 603, False: 0] | | | | ------------------ | | | | 54| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 869| 603| dns_qpmulti_t *multi = node_pointer(&reader[0]); 870| 603| dns_qpbase_t *base = node_pointer(&reader[1]); 871| 603| INSIST(QPMULTI_VALID(multi)); ------------------ | | 202| 603|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 603, False: 0] | | | | | Branch (53:11): [True: 603, False: 0] | | | | ------------------ | | | | 54| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 872| 603| INSIST(QPBASE_VALID(base)); ------------------ | | 202| 603|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 603, False: 0] | | | | | Branch (53:11): [True: 603, False: 0] | | | | ------------------ | | | | 54| 603| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 873| 603| *qp = (dns_qpreader_t){ 874| 603| .magic = QP_MAGIC, ------------------ | | 368| 603|#define QP_MAGIC ISC_MAGIC('t', 'r', 'i', 'e') | | ------------------ | | | | 31| 603|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 875| 603| .uctx = multi->writer.uctx, 876| 603| .methods = multi->writer.methods, 877| 603| .root_ref = node32(&reader[1]), 878| 603| .base = base, 879| 603| }; 880| 603| return multi; 881| 603|} qp.c:make_leaf: 637| 10|make_leaf(const void *pval, uint32_t ival) { 638| 10| dns_qpnode_t leaf = make_node((uintptr_t)pval, ival); 639| 10| REQUIRE(node_tag(&leaf) == LEAF_TAG); ------------------ | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 10, False: 0] | | | | ------------------ | | | | 42| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 640| 10| return leaf; 641| 10|} qp.c:leaf_qpkey: 901| 831|leaf_qpkey(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpkey_t key) { 902| 831| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 831|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 903| 831| size_t len = qp->methods->makekey(key, qp->uctx, leaf_pval(n), 904| 831| leaf_ival(n)); 905| 831| INSIST(len < sizeof(dns_qpkey_t)); ------------------ | | 202| 831|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 831| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 831, False: 0] | | | | ------------------ | | | | 54| 831| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 906| 831| return len; 907| 831|} qp.c:attach_leaf: 889| 10|attach_leaf(dns_qpreadable_t qpr, dns_qpnode_t *n) { 890| 10| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 10|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 891| 10| qp->methods->attach(qp->uctx, leaf_pval(n), leaf_ival(n)); 892| 10|} qp.c:is_branch: 611| 2.46k|is_branch(dns_qpnode_t *n) { 612| 2.46k| return n->biglo & BRANCH_TAG; 613| 2.46k|} qp.c:prefetch_twigs: 709| 315|prefetch_twigs(dns_qpreadable_t qpr, dns_qpnode_t *n) { 710| 315| __builtin_prefetch(ref_ptr(qpr, branch_twigs_ref(n))); 711| 315|} qp.c:branch_twigs_ref: 663| 1.11k|branch_twigs_ref(dns_qpnode_t *n) { 664| 1.11k| return node32(n); 665| 1.11k|} qp.c:branch_keybit: 692| 14|branch_keybit(dns_qpnode_t *n, const dns_qpkey_t key, size_t len) { 693| 14| return qpkey_bit(key, len, branch_key_offset(n)); 694| 14|} qp.c:branch_has_twig: 791| 523|branch_has_twig(dns_qpnode_t *n, dns_qpshift_t bit) { 792| 523| return branch_index(n) & (1ULL << bit); 793| 523|} qp.c:branch_twig_pos: 775| 313|branch_twig_pos(dns_qpnode_t *n, dns_qpshift_t bit) { 776| 313| return branch_count_bitmap_before(n, bit); 777| 313|} qp.c:branch_count_bitmap_before: 754| 588|branch_count_bitmap_before(dns_qpnode_t *n, dns_qpshift_t bit) { 755| 588| uint64_t mask = (1ULL << bit) - 1 - TAG_MASK; 756| 588| uint64_t bitmap = branch_index(n) & mask; 757| 588| return (dns_qpweight_t)stdc_count_ones(bitmap); ------------------ | | 30| 588|#define stdc_count_ones(x) __builtin_popcountg(x) ------------------ 758| 588|} qp.c:branch_key_offset: 684| 499|branch_key_offset(dns_qpnode_t *n) { 685| 499| return (size_t)(branch_index(n) >> SHIFT_OFFSET); 686| 499|} qp.c:branch_twig_ptr: 783| 220|branch_twig_ptr(dns_qpreadable_t qpr, dns_qpnode_t *n, dns_qpshift_t bit) { 784| 220| return ref_ptr(qpr, branch_twigs_ref(n) + branch_twig_pos(n, bit)); 785| 220|} qp.c:make_node: 582| 30|make_node(uint64_t big, uint32_t small) { 583| 30| return (dns_qpnode_t){ 584| 30| .biglo = (uint32_t)(big), 585| 30| .bighi = (uint32_t)(big >> 32), 586| 30| .small = small, 587| 30| }; 588| 30|} qp.c:branch_twigs_size: 767| 275|branch_twigs_size(dns_qpnode_t *n) { 768| 275| return branch_count_bitmap_before(n, SHIFT_OFFSET); 769| 275|} qp.c:branch_index: 655| 1.61k|branch_index(dns_qpnode_t *n) { 656| 1.61k| return node64(n); 657| 1.61k|} qp.c:move_twigs: 798| 4|move_twigs(dns_qpnode_t *to, dns_qpnode_t *from, dns_qpweight_t size) { 799| 4| memmove(to, from, size * sizeof(dns_qpnode_t)); 800| 4|} qp.c:get_root: 719| 884|get_root(dns_qpreadable_t qpr) { 720| 884| dns_qpreader_t *qp = dns_qpreader(qpr); ------------------ | | 177| 884|#define dns_qpreader(qpr) ((qpr).qp) ------------------ 721| 884| if (qp->root_ref == INVALID_REF) { ------------------ | | 230| 884|#define INVALID_REF ((dns_qpref_t)~0UL) ------------------ | Branch (721:6): [True: 2, False: 882] ------------------ 722| 2| return NULL; 723| 882| } else { 724| 882| return ref_ptr(qp, qp->root_ref); 725| 882| } 726| 884|} qp.c:leaf_pval: 621| 1.75k|leaf_pval(dns_qpnode_t *n) { 622| 1.75k| return node_pointer(n); 623| 1.75k|} qp.c:leaf_ival: 629| 841|leaf_ival(dns_qpnode_t *n) { 630| 841| return node32(n); 631| 841|} qp.c:branch_twigs: 701| 299|branch_twigs(dns_qpreadable_t qpr, dns_qpnode_t *n) { 702| 299| return ref_ptr(qpr, branch_twigs_ref(n)); 703| 299|} dns__qpzone_initialize: 475| 2|dns__qpzone_initialize(void) { 476| 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 (476:23): [True: 2.04k, False: 2] ------------------ 477| 2.04k| NODE_INITLOCK(&qpzone_buckets_g[idx].lock); ------------------ | | 28| 2.04k|#define NODE_INITLOCK(l) isc_rwlock_init((l)) ------------------ 478| 2.04k| } 479| 2|} dns__qpzone_create: 878| 2| dns_db_t **dbp) { 879| 2| qpzonedb_t *qpdb = NULL; 880| 2| isc_result_t result; 881| 2| dns_qp_t *qp = NULL; 882| | 883| 2| qpdb = isc_mem_getx(mctx, sizeof(*qpdb), ------------------ | | 148| 4|#define isc_mem_getx(c, s, f) isc__mem_get((c), (s), (f)_ISC_MEM_FILELINE) | | ------------------ | | | Branch (148:55): [True: 2, Folded] | | ------------------ ------------------ 884| 2| ISC_MEM_ALIGN(ISC_OS_CACHELINE_SIZE)); 885| 2| *qpdb = (qpzonedb_t){ 886| 2| .common.origin = DNS_NAME_INITEMPTY, ------------------ | | 210| 4|#define DNS_NAME_INITEMPTY { .magic = DNS_NAME_MAGIC } | | ------------------ | | | | 153| 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)) | | | | ------------------ | | ------------------ ------------------ 887| 2| .common.rdclass = rdclass, 888| 2| .common.references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 889| 2| .current_serial = 1, 890| 2| .least_serial = 1, 891| 2| .next_serial = 2, 892| 2| .open_versions = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 893| 2| }; 894| | 895| 2| qpdb->common.methods = &qpdb_zonemethods; 896| 2| if (type == dns_dbtype_stub) { ------------------ | Branch (896:6): [True: 0, False: 2] ------------------ 897| 0| qpdb->common.attributes |= DNS_DBATTR_STUB; 898| 0| } 899| | 900| 2| isc_rwlock_init(&qpdb->lock); 901| | 902| 2| qpdb->common.update_listeners = cds_lfht_new(16, 16, 0, 0, NULL); 903| | 904| 2| qpdb->heap = new_qpz_heap(mctx); 905| | 906| | /* 907| | * Attach to the mctx. The database will persist so long as there 908| | * are references to it, and attaching to the mctx ensures that our 909| | * mctx won't disappear out from under us. 910| | */ 911| 2| isc_mem_attach(mctx, &qpdb->common.mctx); 912| | 913| | /* 914| | * Make a copy of the origin name. 915| | */ 916| 2| dns_name_dup(origin, mctx, &qpdb->common.origin); ------------------ | | 1522| 2| dns_name__dup(DNS_NAME__RO_ARG(source), mctx, target) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 917| | 918| 2| dns_qpmulti_create(mctx, &qpmethods, qpdb, &qpdb->tree); 919| | 920| | /* 921| | * Version initialization. 922| | */ 923| 2| qpdb->current_version = allocate_version(mctx, 1, 1, false); 924| 2| qpdb->current_version->qpdb = qpdb; 925| | 926| 2| dns_qpmulti_write(qpdb->tree, &qp); 927| | 928| | /* 929| | * In order to set the node callback bit correctly in zone databases, 930| | * we need to know if the node has the origin name of the zone. 931| | * In loading_addrdataset() we could simply compare the new name 932| | * to the origin name, but this is expensive. Also, we don't know the 933| | * node name in addrdataset(), so we need another way of knowing the 934| | * zone's top. 935| | * 936| | * We now explicitly create a node for the zone's origin, and then 937| | * we simply remember the node data's address. 938| | */ 939| 2| qpdb->origin = new_qpznode(qpdb, &qpdb->common.origin, 940| 2| DNS_DBNAMESPACE_NORMAL); 941| | 942| 2| result = dns_qp_insert(qp, qpdb->origin, 0); 943| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 944| | 945| | /* 946| | * Add an apex node to the NSEC tree so that we can quickly skip over 947| | * the NSEC nodes while iterating over the full tree. 948| | */ 949| 2| qpdb->nsec_origin = new_qpznode(qpdb, &qpdb->common.origin, 950| 2| DNS_DBNAMESPACE_NSEC); 951| 2| result = dns_qp_insert(qp, qpdb->nsec_origin, 0); 952| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 953| | 954| | /* 955| | * Add an apex node to the NSEC3 tree so that NSEC3 searches 956| | * return partial matches when there is only a single NSEC3 957| | * record in the tree. 958| | */ 959| 2| qpdb->nsec3_origin = new_qpznode(qpdb, &qpdb->common.origin, 960| 2| DNS_DBNAMESPACE_NSEC3); 961| 2| result = dns_qp_insert(qp, qpdb->nsec3_origin, 0); 962| 2| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 963| | 964| 2| dns_qpmulti_commit(qpdb->tree, &qp); 965| | 966| | /* 967| | * Keep the current version in the open list so that list operation 968| | * won't happen in normal lookup operations. 969| | */ 970| 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] | | ------------------ ------------------ 971| | 972| 2| qpdb->common.magic = DNS_DB_MAGIC; ------------------ | | 186| 2|#define DNS_DB_MAGIC ISC_MAGIC('D', 'N', 'S', 'D') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 973| 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)) | | ------------------ ------------------ 974| | 975| 2| *dbp = (dns_db_t *)qpdb; 976| | 977| 2| return ISC_R_SUCCESS; 978| 2|} qpzone.c:new_qpz_heap: 782| 2|new_qpz_heap(isc_mem_t *mctx) { 783| 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) ------------------ 784| 2| *new_heap = (qpz_heap_t){ 785| 2| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 786| 2| }; 787| | 788| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 789| 2| isc_heap_create(mctx, resign_sooner, set_index, 0, &new_heap->heap); 790| 2| isc_mem_attach(mctx, &new_heap->mctx); 791| | 792| 2| isc_hashmap_create(mctx, 1u, &new_heap->hashmap); 793| | 794| 2| return new_heap; 795| 2|} qpzone.c:qp_attach: 5828| 6| uint32_t ival ISC_ATTR_UNUSED) { 5829| 6| qpznode_t *data = pval; 5830| 6| qpznode_ref(data); 5831| 6|} qpzone.c:qp_makekey: 5842| 438| uint32_t ival ISC_ATTR_UNUSED) { 5843| 438| qpznode_t *data = pval; 5844| 438| return dns_qpkey_fromname(key, &data->name, data->nspace); 5845| 438|} qpzone.c:allocate_version: 857| 2| bool writer) { 858| 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) ------------------ 859| 2| *version = (qpz_version_t){ 860| 2| .serial = serial, 861| 2| .writer = writer, 862| 2| .changed_list = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 863| 2| .resigned_list = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 864| 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| } | | ------------------ ------------------ 865| 2| .references = ISC_REFCOUNT_INITIALIZER(references), ------------------ | | 34| 2|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 866| 2| }; 867| | 868| 2| cds_wfs_init(&version->glue_stack); 869| 2| isc_rwlock_init(&version->rwlock); 870| | 871| 2| return version; 872| 2|} qpzone.c:new_qpznode: 834| 6|new_qpznode(qpzonedb_t *qpdb, const dns_name_t *name, dns_namespace_t nspace) { 835| 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) ------------------ 836| 6| *newdata = (qpznode_t){ 837| 6| .next_type = ISC_SLIST_INITIALIZER, ------------------ | | 25| 6| { \ | | 26| 6| .head = NULL, \ | | 27| 6| } ------------------ 838| 6| .methods = &qpznode_methods, 839| 6| .name = DNS_NAME_INITEMPTY, ------------------ | | 210| 6|#define DNS_NAME_INITEMPTY { .magic = DNS_NAME_MAGIC } | | ------------------ | | | | 153| 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)) | | | | ------------------ | | ------------------ ------------------ 840| 6| .nspace = nspace, 841| 6| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 6|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 842| 6| .locknum = qpzone_get_locknum(), 843| 6| }; 844| | 845| 6| isc_mem_attach(qpdb->common.mctx, &newdata->mctx); 846| 6| dns_name_dup(name, qpdb->common.mctx, &newdata->name); ------------------ | | 1522| 6| dns_name__dup(DNS_NAME__RO_ARG(source), mctx, target) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 847| | 848| |#if DNS_DB_NODETRACE 849| | fprintf(stderr, "new_qpznode:%s:%s:%d:%p->references = 1\n", __func__, 850| | __FILE__, __LINE__ + 1, name); 851| |#endif 852| 6| return newdata; 853| 6|} qpzone.c:qpzone_get_locknum: 494| 6|qpzone_get_locknum(void) { 495| 6| return isc_random_uniform(ARRAY_SIZE(qpzone_buckets_g)); ------------------ | | 98| 6|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ 496| 6|} qpzone.c:qpznode_acquire: 1000| 8|qpznode_acquire(qpznode_t *node DNS__DB_FLARG) { 1001| 8| qpznode_ref(node); 1002| 8| qpznode_erefs_increment(node DNS__DB_FLARG_PASS); 1003| 8|} qpzone.c:qpznode_erefs_increment: 989| 8|qpznode_erefs_increment(qpznode_t *node DNS__DB_FLARG) { 990| 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) | | | | ------------------ | | | | | | 53| 8| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 8, False: 0] | | | | | | ------------------ | | | | | | 54| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 8| __v; \ | | 73| 8| }) ------------------ 991| |#if DNS_DB_NODETRACE 992| | fprintf(stderr, "incr:node:%s:%s:%u:%p->erefs = %" PRIuFAST32 "\n", 993| | func, file, line, node, refs + 1); 994| |#else 995| 8| UNUSED(refs); ------------------ | | 69| 8|#define UNUSED(x) (void)(x) ------------------ 996| 8|#endif 997| 8|} qpzone.c:qpzone_detachnode: 4111| 8|qpzone_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) { 4112| 8| qpznode_t *node = NULL; 4113| 8| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 4114| 8| isc_rwlock_t *nlock = NULL; 4115| | 4116| 8| REQUIRE(nodep != NULL && *nodep != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4117| | 4118| 8| node = (qpznode_t *)(*nodep); 4119| | 4120| 8| *nodep = NULL; 4121| 8| nlock = qpzone_get_lock(node); 4122| | 4123| | /* 4124| | * qpzone_destroy() uses call_rcu() API to destroy the node locks, so it 4125| | * is safe to call it in the middle of NODE_LOCK, but we need to acquire 4126| | * the database reference to prevent destroying the database while the 4127| | * NODE_LOCK is locked. 4128| | */ 4129| | 4130| 8| rcu_read_lock(); 4131| 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() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 4132| 8| (void)qpznode_release(node DNS__DB_FLARG_PASS); 4133| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 8| } \ | | | | | | 293| 8| } | | | | ------------------ | | | | 42| 8| } | | ------------------ | | 40| 8| *tp = isc_rwlocktype_none; \ | | 41| 8| } ------------------ 4134| | rcu_read_unlock(); 4135| 8|} qpzone.c:qpzone_get_lock: 489| 418|qpzone_get_lock(qpznode_t *node) { 490| 418| return &qpzone_buckets_g[node->locknum].lock; 491| 418|} qpzone.c:qpznode_release: 1161| 8|qpznode_release(qpznode_t *node DNS__DB_FLARG) { 1162| 8| bool has_erefs = false; 1163| | 1164| 8| if (!qpznode_erefs_decrement(node DNS__DB_FLARG_PASS)) { ------------------ | Branch (1164:6): [True: 0, False: 8] ------------------ 1165| 0| has_erefs = true; 1166| 0| goto unref; 1167| 0| } 1168| | 1169| | /* Handle easy and typical case first. */ 1170| 8| if (!node->dirty && !ISC_SLIST_EMPTY(node->next_type)) { ------------------ | | 45| 8|#define ISC_SLIST_EMPTY(list) ((list).head == NULL) ------------------ | Branch (1170:6): [True: 8, False: 0] | Branch (1170:22): [True: 8, False: 0] ------------------ 1171| 8| has_erefs = true; 1172| 8| goto unref; 1173| 8| } 1174| | 1175| 8|unref: 1176| 8| qpznode_unref(node); 1177| 8| return has_erefs; 1178| 8|} qpzone.c:qpznode_erefs_decrement: 1134| 8|qpznode_erefs_decrement(qpznode_t *node DNS__DB_FLARG) { 1135| 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) | | | | ------------------ | | | | | | 53| 8| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 8, False: 0] | | | | | | ------------------ | | | | | | 54| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 8| __v; \ | | 99| 8| }) ------------------ 1136| | 1137| |#if DNS_DB_NODETRACE 1138| | fprintf(stderr, "decr:node:%s:%s:%u:%p->erefs = %" PRIuFAST32 "\n", 1139| | func, file, line, node, refs - 1); 1140| |#endif 1141| 8| if (refs > 1) { ------------------ | Branch (1141:6): [True: 0, False: 8] ------------------ 1142| 0| return false; 1143| 0| } 1144| | 1145| 8| return true; 1146| 8|} qpzone.c:beginload: 2344| 2|beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 2345| 2| qpz_load_t *loadctx = NULL; 2346| 2| qpzonedb_t *qpdb = NULL; 2347| 2| qpdb = (qpzonedb_t *)db; 2348| | 2349| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2350| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2351| | 2352| 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) ------------------ 2353| 2| *loadctx = (qpz_load_t){ .db = db }; 2354| | 2355| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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| } ------------------ 2356| | 2357| 2| REQUIRE((qpdb->attributes & (QPDB_ATTR_LOADED | QPDB_ATTR_LOADING)) == ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2358| 2| 0); 2359| 2| qpdb->attributes |= QPDB_ATTR_LOADING; ------------------ | | 71| 2|#define QPDB_ATTR_LOADING 0x02 ------------------ 2360| | 2361| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 2362| | 2363| 2| callbacks->update = loading_addrdataset; 2364| 2| callbacks->setup = loading_setup; 2365| 2| callbacks->commit = loading_commit; 2366| 2| callbacks->add_private = loadctx; 2367| | 2368| 2| return ISC_R_SUCCESS; 2369| 2|} qpzone.c:loading_addrdataset: 2234| 6| dns_diffop_t op ISC_ATTR_UNUSED DNS__DB_FLARG) { 2235| 6| qpz_load_t *loadctx = arg; 2236| 6| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2237| 6| qpznode_t *node = NULL; 2238| 6| isc_result_t result = ISC_R_SUCCESS; 2239| 6| isc_region_t region; 2240| 6| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 2241| 6| isc_rwlock_t *nlock = NULL; 2242| | 2243| 6| REQUIRE(rdataset->rdclass == qpdb->common.rdclass); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2244| | 2245| 6| if (!dns_name_issubdomain(name, &qpdb->common.origin)) { ------------------ | | 1544| 6| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (2245:6): [True: 0, False: 6] ------------------ 2246| 0| return DNS_R_OUTOFZONE; 2247| 0| } 2248| | 2249| | /* 2250| | * SOA records are only allowed at top of zone. 2251| | */ 2252| 6| if (rdataset->type == dns_rdatatype_soa && ------------------ | | 121| 12|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ | Branch (2252:6): [True: 2, False: 4] ------------------ 2253| 2| !dns_name_equal(name, &qpdb->common.origin)) ------------------ | | 1541| 2| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (2253:6): [True: 0, False: 2] ------------------ 2254| 0| { 2255| 0| return DNS_R_NOTZONETOP; 2256| 0| } 2257| | 2258| 6| if (rdataset->type != dns_rdatatype_nsec3 && ------------------ | | 165| 12|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2258:6): [True: 6, False: 0] ------------------ 2259| 6| rdataset->covers != dns_rdatatype_nsec3) ------------------ | | 165| 6|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2259:6): [True: 6, False: 0] ------------------ 2260| 6| { 2261| 6| addwildcards(qpdb, loadctx->tree, name, DNS_DBNAMESPACE_NORMAL); 2262| 6| } 2263| | 2264| 6| if (dns_name_iswildcard(name)) { ------------------ | | 1529| 6|#define dns_name_iswildcard(name) dns_name__iswildcard(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1529:35): [True: 0, False: 6] | | ------------------ ------------------ 2265| 0| if (rdataset->type == dns_rdatatype_ns) { ------------------ | | 117| 0|#define dns_rdatatype_ns ((dns_rdatatype_t)dns_rdatatype_ns) ------------------ | Branch (2265:7): [True: 0, False: 0] ------------------ 2266| | /* 2267| | * NS owners cannot legally be wild cards. 2268| | */ 2269| 0| return DNS_R_INVALIDNS; 2270| 0| } 2271| | 2272| 0| if (rdataset->type == dns_rdatatype_nsec3) { ------------------ | | 165| 0|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (2272:7): [True: 0, False: 0] ------------------ 2273| | /* 2274| | * NSEC3 owners cannot legally be wild cards. 2275| | */ 2276| 0| return DNS_R_INVALIDNSEC3; 2277| 0| } 2278| | 2279| 0| wildcardmagic(qpdb, loadctx->tree, name, 2280| 0| DNS_DBNAMESPACE_NORMAL); 2281| 0| } 2282| | 2283| 6| loading_addnode(loadctx, name, rdataset->type, rdataset->covers, &node); 2284| 6| result = dns_rdatavec_fromrdataset(rdataset, node->mctx, ®ion, 2285| 6| qpdb->maxrrperset); 2286| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2286:6): [True: 0, False: 6] ------------------ 2287| 0| if (result == DNS_R_TOOMANYRECORDS) { ------------------ | Branch (2287:7): [True: 0, False: 0] ------------------ 2288| 0| dns__db_logtoomanyrecords((dns_db_t *)qpdb, name, 2289| 0| rdataset->type, "adding", 2290| 0| qpdb->maxrrperset); 2291| 0| } 2292| 0| return result; 2293| 0| } 2294| | 2295| 6| dns_vecheader_t *newheader = (dns_vecheader_t *)region.base; 2296| 6| newheader->ttl = rdataset->ttl; 2297| 6| newheader->serial = 1; 2298| 6| atomic_store_release(&newheader->trust, rdataset->trust); ------------------ | | 49| 6| atomic_store_explicit((o), (v), memory_order_release) ------------------ 2299| | 2300| 6| dns_vecheader_setownercase(newheader, name); 2301| | 2302| 6| if (rdataset->attributes.resign) { ------------------ | Branch (2302:6): [True: 0, False: 6] ------------------ 2303| 0| DNS_VECHEADER_SETATTR(newheader, DNS_VECHEADERATTR_RESIGN); ------------------ | | 144| 0| atomic_fetch_or_release(&(header)->attributes, attribute) | | ------------------ | | | | 58| 0| atomic_fetch_or_explicit((o), (v), memory_order_release) | | ------------------ ------------------ 2304| 0| newheader->resign = dns_time64_from32(rdataset->resign); 2305| 0| } 2306| | 2307| 6| nlock = qpzone_get_lock(node); 2308| 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() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 2309| 6| result = add(qpdb, node, name, qpdb->current_version, newheader, 2310| 6| DNS_DBADD_MERGE, true, NULL, 0 DNS__DB_FLARG_PASS); ------------------ | | 301| 6|#define DNS_DBADD_MERGE 0x01 ------------------ 2311| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 6| } \ | | | | | | 293| 6| } | | | | ------------------ | | | | 42| 6| } | | ------------------ | | 40| 6| *tp = isc_rwlocktype_none; \ | | 41| 6| } ------------------ 2312| | 2313| 6| if (result == ISC_R_SUCCESS && ------------------ | Branch (2313:6): [True: 6, False: 0] ------------------ 2314| 6| delegating_type(qpdb, node, rdataset->type)) ------------------ | Branch (2314:6): [True: 0, False: 6] ------------------ 2315| 0| { 2316| 0| node->delegating = true; 2317| 6| } else if (result == DNS_R_UNCHANGED) { ------------------ | Branch (2317:13): [True: 0, False: 6] ------------------ 2318| 0| result = ISC_R_SUCCESS; 2319| 0| } 2320| | 2321| 6| return result; 2322| 6|} qpzone.c:addwildcards: 2214| 6| dns_namespace_t nspace) { 2215| 6| dns_name_t foundname; 2216| 6| unsigned int n, l, i; 2217| | 2218| 6| dns_name_init(&foundname); 2219| 6| n = dns_name_countlabels(name); ------------------ | | 1546| 6|#define dns_name_countlabels(name) dns_name__countlabels(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 2220| 6| l = dns_name_countlabels(&qpdb->common.origin); ------------------ | | 1546| 6|#define dns_name_countlabels(name) dns_name__countlabels(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 6| _Generic((arg), \ | | | | 1508| 6| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 6| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 6| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 6| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 6| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 6| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 2221| 6| i = l + 1; 2222| 6| while (i < n) { ------------------ | Branch (2222:9): [True: 0, False: 6] ------------------ 2223| 0| dns_name_getlabelsequence(name, n - i, i, &foundname); 2224| 0| if (dns_name_iswildcard(&foundname)) { ------------------ | | 1529| 0|#define dns_name_iswildcard(name) dns_name__iswildcard(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1529:35): [True: 0, False: 0] | | ------------------ ------------------ 2225| 0| wildcardmagic(qpdb, qp, &foundname, nspace); 2226| 0| } 2227| | 2228| 0| i++; 2229| 0| } 2230| 6|} qpzone.c:loading_addnode: 1777| 6| qpznode_t **nodep) { 1778| 6| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 1779| 6| isc_result_t result; 1780| 6| qpznode_t *node = NULL, *nsecnode = NULL; 1781| | 1782| 6| if (type == dns_rdatatype_nsec3 || covers == dns_rdatatype_nsec3) { ------------------ | | 165| 12|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ if (type == dns_rdatatype_nsec3 || covers == dns_rdatatype_nsec3) { ------------------ | | 165| 6|#define dns_rdatatype_nsec3 ((dns_rdatatype_t)dns_rdatatype_nsec3) ------------------ | Branch (1782:6): [True: 0, False: 6] | Branch (1782:37): [True: 0, False: 6] ------------------ 1783| 0| result = dns_qp_getname(loadctx->tree, name, 1784| 0| DNS_DBNAMESPACE_NSEC3, (void **)&node, 1785| 0| NULL); 1786| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1786:7): [True: 0, False: 0] ------------------ 1787| 0| *nodep = node; 1788| 0| } else { 1789| 0| node = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NSEC3); 1790| 0| result = dns_qp_insert(loadctx->tree, node, 0); 1791| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1792| 0| *nodep = node; 1793| 0| qpznode_detach(&node); 1794| 0| } 1795| 0| return; 1796| 0| } 1797| | 1798| 6| result = dns_qp_getname(loadctx->tree, name, DNS_DBNAMESPACE_NORMAL, 1799| 6| (void **)&node, NULL); 1800| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1800:6): [True: 6, False: 0] ------------------ 1801| 6| if (type == dns_rdatatype_nsec && node->havensec) { ------------------ | | 162| 12|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1801:7): [True: 0, False: 6] | Branch (1801:37): [True: 0, False: 0] ------------------ 1802| 0| goto done; 1803| 0| } 1804| 6| } else { 1805| 0| INSIST(node == NULL); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1806| 0| node = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NORMAL); 1807| 0| result = dns_qp_insert(loadctx->tree, node, 0); 1808| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1809| 0| qpznode_unref(node); 1810| 0| } 1811| 6| if (type != dns_rdatatype_nsec) { ------------------ | | 162| 6|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1811:6): [True: 6, False: 0] ------------------ 1812| 6| goto done; 1813| 6| } 1814| | 1815| | /* 1816| | * We're adding an NSEC record, so create a node in the nsec tree 1817| | * too. This tree speeds searches for closest NSECs that would 1818| | * otherwise need to examine many irrelevant nodes in large TLDs. 1819| | * If dns_qp_insert() fails, it means there's already an NSEC 1820| | * node there, so we can just detach the new one we created and 1821| | * move on. 1822| | */ 1823| 0| node->havensec = true; 1824| 0| nsecnode = new_qpznode(qpdb, name, DNS_DBNAMESPACE_NSEC); 1825| 0| (void)dns_qp_insert(loadctx->tree, nsecnode, 0); 1826| 0| qpznode_detach(&nsecnode); 1827| | 1828| 6|done: 1829| 6| *nodep = node; 1830| 6|} qpzone.c:add: 1917| 6| isc_stdtime_t now ISC_ATTR_UNUSED DNS__DB_FLARG) { 1918| 6| qpz_changed_t *changed = NULL; 1919| 6| dns_vectop_t *foundtop = NULL; 1920| 6| dns_vectop_t *priotop = NULL; 1921| 6| dns_vecheader_t *merged = NULL; 1922| 6| isc_result_t result; 1923| 6| bool merge = false; 1924| 6| uint32_t ntypes; 1925| | 1926| 6| if ((options & DNS_DBADD_MERGE) != 0) { ------------------ | | 301| 6|#define DNS_DBADD_MERGE 0x01 ------------------ | Branch (1926:6): [True: 6, False: 0] ------------------ 1927| 6| REQUIRE(version != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1928| 6| merge = true; 1929| 6| } 1930| | 1931| 6| if (!loading) { ------------------ | Branch (1931:6): [True: 0, False: 6] ------------------ 1932| | /* 1933| | * We always add a changed record, even if no changes end up 1934| | * being made to this node, because it's harmless and 1935| | * simplifies the code. 1936| | */ 1937| 0| changed = add_changed(qpdb, node, version DNS__DB_FLARG_PASS); 1938| 0| } 1939| | 1940| 6| ntypes = 0; 1941| 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] | | | | ------------------ | | ------------------ ------------------ 1942| 6| ++ntypes; 1943| 6| if (prio_type(top->typepair)) { ------------------ | Branch (1943:7): [True: 2, False: 4] ------------------ 1944| 2| priotop = top; 1945| 2| } 1946| 6| if (top->typepair == newheader->typepair) { ------------------ | Branch (1946:7): [True: 0, False: 6] ------------------ 1947| 0| foundtop = top; 1948| 0| break; 1949| 0| } 1950| 6| } 1951| | 1952| | /* 1953| | * If topheader isn't NULL, we've found the right type. There may be 1954| | * IGNORE rdatasets between the top of the chain and the first real 1955| | * data. We skip over them. 1956| | */ 1957| 6| dns_vecheader_t **header_p = NULL; 1958| 6| dns_vecheader_t *header = NULL; 1959| 6| if (foundtop != NULL) { ------------------ | Branch (1959:6): [True: 0, False: 6] ------------------ 1960| 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] | | ------------------ ------------------ 1961| 0| if (!IGNORE(*p)) { ------------------ | | 27| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 28| 0| DNS_VECHEADERATTR_IGNORE) != 0) ------------------ | Branch (1961:8): [True: 0, False: 0] ------------------ 1962| 0| header_p = p; 1963| 0| header = *p; 1964| 0| break; 1965| 0| } 1966| 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) | | ------------------ ------------------ 1967| 0| } 1968| 0| } 1969| | 1970| 6| if (header != NULL) { ------------------ | Branch (1970:6): [True: 0, False: 6] ------------------ 1971| | /* 1972| | * If 'merge' is true and header isn't empty/nonexistent, 1973| | * we'll try to create a new rdataset that is the union 1974| | * of 'newheader' and 'header'. 1975| | */ 1976| 0| if (merge && header->count != 0) { ------------------ | Branch (1976:7): [True: 0, False: 0] | Branch (1976:16): [True: 0, False: 0] ------------------ 1977| 0| unsigned int flags = 0; 1978| 0| INSIST(version->serial >= header->serial); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1979| 0| merged = NULL; 1980| 0| result = ISC_R_SUCCESS; 1981| | 1982| 0| if ((options & DNS_DBADD_EXACT) != 0) { ------------------ | | 303| 0|#define DNS_DBADD_EXACT 0x04 ------------------ | Branch (1982:8): [True: 0, False: 0] ------------------ 1983| 0| flags |= DNS_RDATAVEC_EXACT; ------------------ | | 57| 0|#define DNS_RDATAVEC_EXACT 0x2 ------------------ 1984| 0| } 1985| 0| if ((options & DNS_DBADD_EXACTTTL) != 0 && ------------------ | | 304| 0|#define DNS_DBADD_EXACTTTL 0x08 ------------------ | Branch (1985:8): [True: 0, False: 0] ------------------ 1986| 0| newheader->ttl != header->ttl) ------------------ | Branch (1986:8): [True: 0, False: 0] ------------------ 1987| 0| { 1988| 0| result = DNS_R_NOTEXACT; 1989| 0| } else if (newheader->ttl != header->ttl) { ------------------ | Branch (1989:15): [True: 0, False: 0] ------------------ 1990| 0| flags |= DNS_RDATAVEC_FORCE; ------------------ | | 56| 0|#define DNS_RDATAVEC_FORCE 0x1 ------------------ 1991| 0| } 1992| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1992:8): [True: 0, False: 0] ------------------ 1993| 0| result = dns_rdatavec_merge( 1994| 0| header, newheader, qpdb->common.mctx, 1995| 0| qpdb->common.rdclass, 1996| 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| }) ------------------ 1997| 0| flags, qpdb->maxrrperset, &merged); 1998| 0| } 1999| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1999:8): [True: 0, False: 0] ------------------ 2000| | /* 2001| | * If 'header' has the same serial number as 2002| | * we do, we could clean it up now if we knew 2003| | * that our caller had no references to it. 2004| | * We don't know this, however, so we leave it 2005| | * alone. It will get cleaned up when 2006| | * clean_zone_node() runs. 2007| | */ 2008| 0| dns_vecheader_unref(newheader); 2009| 0| newheader = merged; 2010| | /* 2011| | * dns_rdatavec_subtract takes the header from 2012| | * the first argument, so it preserves the case 2013| | */ 2014| 0| if (loading && RESIGN(newheader) && ------------------ | | 33| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 0] | | ------------------ | | 34| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ | Branch (2014:9): [True: 0, False: 0] ------------------ 2015| 0| RESIGN(header) && ------------------ | | 33| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 0] | | ------------------ | | 34| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 2016| 0| resign_sooner_values(header->resign, ------------------ | Branch (2016:9): [True: 0, False: 0] ------------------ 2017| 0| header->typepair, 2018| 0| newheader->resign, 2019| 0| newheader->typepair)) 2020| 0| { 2021| 0| newheader->resign = header->resign; 2022| 0| } 2023| 0| } else { 2024| 0| if (result == DNS_R_TOOMANYRECORDS) { ------------------ | Branch (2024:9): [True: 0, False: 0] ------------------ 2025| 0| dns__db_logtoomanyrecords( 2026| 0| (dns_db_t *)qpdb, nodename, 2027| 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| }) ------------------ 2028| 0| header->typepair), 2029| 0| "updating", qpdb->maxrrperset); 2030| 0| } 2031| 0| dns_vecheader_unref(newheader); 2032| 0| return result; 2033| 0| } 2034| 0| } 2035| | 2036| 0| INSIST(version->serial >= header->serial); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2037| 0| INSIST(foundtop->typepair == newheader->typepair); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2038| | 2039| 0| if (loading) { ------------------ | Branch (2039:7): [True: 0, False: 0] ------------------ 2040| 0| if (RESIGN(newheader)) { ------------------ | | 33| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 0] | | ------------------ | | 34| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 2041| 0| LOCK(&qpdb->heap->lock); ------------------ | | 26| 0| { \ | | 27| 0| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 0| __FILE__, __LINE__)); \ | | 29| 0| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 0|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 0| { \ | | | | | | 86| 0| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2042| 0| resign_register(qpdb->heap, node, newheader); 2043| 0| UNLOCK(&qpdb->heap->lock); ------------------ | | 34| 0| { \ | | 35| 0| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 0|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 0| { \ | | | | | | 92| 0| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 0| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2044| | /* resigndelete not needed here */ 2045| 0| } 2046| | 2047| | /* 2048| | * There are no other references to 'header' when 2049| | * loading, so we MAY clean up 'header' now. 2050| | * Since we don't generate changed records when 2051| | * loading, we MUST clean up 'header' now. 2052| | */ 2053| 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) | | ------------------ ------------------ 2054| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2055| 0| next_header); 2056| 0| maybe_update_recordsandsize(false, version, header, 2057| 0| nodename->length); 2058| | 2059| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2060| 0| (void)resign_unregister(qpdb->heap, node, header); 2061| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2062| 0| dns_vecheader_unref(header); 2063| 0| } else { 2064| 0| if (RESIGN(newheader)) { ------------------ | | 33| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 0] | | ------------------ | | 34| 0| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 2065| 0| isc_result_t unregister_result; 2066| | 2067| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2068| 0| resign_register(qpdb->heap, node, newheader); 2069| 0| unregister_result = resign_unregister( 2070| 0| qpdb->heap, node, header); 2071| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2072| 0| if (unregister_result == ISC_R_SUCCESS) { ------------------ | Branch (2072:9): [True: 0, False: 0] ------------------ 2073| 0| resign_rollback( 2074| 0| qpdb, node, version, 2075| 0| header DNS__DB_FLARG_PASS); 2076| 0| } 2077| 0| } 2078| | 2079| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2080| 0| next_header); 2081| | 2082| 0| node->dirty = true; 2083| 0| if (changed != NULL) { ------------------ | Branch (2083:8): [True: 0, False: 0] ------------------ 2084| 0| changed->dirty = true; 2085| 0| } 2086| 0| maybe_update_recordsandsize(false, version, header, 2087| 0| nodename->length); 2088| 0| } 2089| 6| } else { 2090| | /* 2091| | * No non-IGNORED rdatasets of the given type exist at 2092| | * this node. 2093| | * 2094| | * If we're trying to delete the type, don't bother. 2095| | */ 2096| 6| if (newheader->count == 0) { ------------------ | Branch (2096:7): [True: 0, False: 6] ------------------ 2097| 0| dns_vecheader_unref(newheader); 2098| 0| return DNS_R_UNCHANGED; 2099| 0| } 2100| | 2101| 6| if (RESIGN(newheader)) { ------------------ | | 33| 6| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 6|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 6] | | ------------------ | | 34| 6| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 2102| 0| isc_result_t unregister_result; 2103| | 2104| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2105| 0| resign_register(qpdb->heap, node, newheader); 2106| 0| unregister_result = resign_unregister(qpdb->heap, node, 2107| 0| header); 2108| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2109| 0| if (unregister_result == ISC_R_SUCCESS) { ------------------ | Branch (2109:8): [True: 0, False: 0] ------------------ 2110| 0| resign_rollback(qpdb, node, version, 2111| 0| header DNS__DB_FLARG_PASS); 2112| 0| } 2113| 0| } 2114| | 2115| 6| if (foundtop != NULL) { ------------------ | Branch (2115:7): [True: 0, False: 6] ------------------ 2116| | /* 2117| | * We have a list of rdatasets of the given type, 2118| | * but they're all marked IGNORE. We simply insert 2119| | * the new rdataset at the head of the list. 2120| | * 2121| | * Ignored rdatasets cannot occur during loading, so 2122| | * we INSIST on it. 2123| | */ 2124| 0| INSIST(!loading); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2125| | 2126| 0| ISC_SLIST_PREPEND(foundtop->headers, newheader, ------------------ | | 48| 0| ({ \ | | 49| 0| (elt)->link.next = (list).head; \ | | 50| 0| (list).head = (elt); \ | | 51| 0| }) ------------------ 2127| 0| next_header); 2128| | 2129| 0| if (changed != NULL) { ------------------ | Branch (2129:8): [True: 0, False: 0] ------------------ 2130| 0| changed->dirty = true; 2131| 0| } 2132| 0| node->dirty = true; 2133| 6| } else { 2134| | /* 2135| | * No rdatasets of the given type exist at the node. 2136| | */ 2137| | 2138| 6| if (qpdb->maxtypepername > 0 && ------------------ | Branch (2138:8): [True: 0, False: 6] ------------------ 2139| 0| ntypes >= qpdb->maxtypepername) ------------------ | Branch (2139:8): [True: 0, False: 0] ------------------ 2140| 0| { 2141| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2142| 0| (void)resign_unregister(qpdb->heap, node, 2143| 0| newheader); 2144| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 2145| 0| dns_vecheader_unref(newheader); 2146| 0| return DNS_R_TOOMANYRECORDS; 2147| 0| } 2148| | 2149| 6| dns_vectop_t *newtop = 2150| 6| dns_vectop_new(node->mctx, newheader->typepair); 2151| | 2152| 6| ISC_SLIST_PREPEND(newtop->headers, newheader, ------------------ | | 48| 6| ({ \ | | 49| 6| (elt)->link.next = (list).head; \ | | 50| 6| (list).head = (elt); \ | | 51| 6| }) ------------------ 2153| 6| next_header); 2154| | 2155| 6| if (prio_type(newheader->typepair)) { ------------------ | Branch (2155:8): [True: 4, False: 2] ------------------ 2156| | /* This is a priority type, prepend it */ 2157| 4| ISC_SLIST_PREPEND(node->next_type, newtop, ------------------ | | 48| 4| ({ \ | | 49| 4| (elt)->link.next = (list).head; \ | | 50| 4| (list).head = (elt); \ | | 51| 4| }) ------------------ 2158| 4| next_type); 2159| 4| } else if (priotop != NULL) { ------------------ | Branch (2159:15): [True: 0, False: 2] ------------------ 2160| | /* Append after the priority headers */ 2161| 0| ISC_SLIST_INSERTAFTER(priotop, newtop, ------------------ | | 54| 0| ({ \ | | 55| 0| (elt)->link.next = (after)->link.next; \ | | 56| 0| (after)->link.next = (elt); \ | | 57| 0| }) ------------------ 2162| 0| next_type); 2163| 2| } else { 2164| | /* There were no priority headers */ 2165| 2| ISC_SLIST_PREPEND(node->next_type, newtop, ------------------ | | 48| 2| ({ \ | | 49| 2| (elt)->link.next = (list).head; \ | | 50| 2| (list).head = (elt); \ | | 51| 2| }) ------------------ 2166| 2| next_type); 2167| 2| } 2168| 6| } 2169| 6| } 2170| | 2171| 6| maybe_update_recordsandsize(true, version, newheader, nodename->length); 2172| | 2173| | /* 2174| | * Check if the node now contains CNAME and other data. 2175| | */ 2176| 6| if (cname_and_other(node, version->serial)) { ------------------ | Branch (2176:6): [True: 0, False: 6] ------------------ 2177| 0| return DNS_R_CNAMEANDOTHER; 2178| 0| } 2179| | 2180| 6| bindrdataset(qpdb, newheader, addedrdataset DNS__DB_FLARG_PASS); 2181| | 2182| 6| return ISC_R_SUCCESS; 2183| 6|} qpzone.c:maybe_update_recordsandsize: 1895| 6| dns_vecheader_t *header, unsigned int namelen) { 1896| 6| unsigned int count = header->count; 1897| | 1898| 6| if (count == 0) { ------------------ | Branch (1898:6): [True: 0, False: 6] ------------------ 1899| 0| return; 1900| 0| } 1901| | 1902| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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| } ------------------ 1903| 12| if (add) { ------------------ | Branch (1903:6): [True: 6, False: 0] ------------------ 1904| 6| version->records += count; 1905| 6| version->xfrsize += recordsize(header, namelen); 1906| 6| } else { 1907| 0| version->records -= count; 1908| 0| version->xfrsize -= recordsize(header, namelen); 1909| 0| } 1910| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 6| } \ | | | | 293| 6| } | | ------------------ | | 42| 6| } ------------------ 1911| 6|} qpzone.c:recordsize: 1888| 6|recordsize(dns_vecheader_t *header, unsigned int namelen) { 1889| 6| return dns_rdatavec_size(header) + sizeof(dns_ttl_t) + 1890| 6| sizeof(dns_rdatatype_t) + sizeof(dns_rdataclass_t) + namelen; 1891| 6|} qpzone.c:cname_and_other: 1833| 6|cname_and_other(qpznode_t *node, uint32_t serial) { 1834| 6| bool cname = false, other = false; 1835| | 1836| | /* 1837| | * Look for CNAME and "other data" rdatasets active in our version. 1838| | * ("Other data" is any rdataset whose type is not KEY, NSEC, SIG 1839| | * or RRSIG. 1840| | */ 1841| 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] | | | | ------------------ | | ------------------ ------------------ 1842| 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| }) ------------------ 1843| 12| if (rdtype == dns_rdatatype_cname) { ------------------ | | 120| 12|#define dns_rdatatype_cname ((dns_rdatatype_t)dns_rdatatype_cname) ------------------ | Branch (1843:7): [True: 0, False: 12] ------------------ 1844| 0| if (first_existing_header(top, serial) != NULL) { ------------------ | Branch (1844:8): [True: 0, False: 0] ------------------ 1845| 0| cname = true; 1846| 0| } 1847| 12| } else if (rdtype != dns_rdatatype_nsec && ------------------ | | 162| 24|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (1847:14): [True: 12, False: 0] ------------------ 1848| 12| rdtype != dns_rdatatype_rrsig) ------------------ | | 161| 12|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (1848:7): [True: 12, False: 0] ------------------ 1849| 12| { 1850| 12| if (first_existing_header(top, serial) != NULL) { ------------------ | Branch (1850:8): [True: 12, False: 0] ------------------ 1851| 12| if (!prio_type(rdtype)) { ------------------ | Branch (1851:9): [True: 6, False: 6] ------------------ 1852| | /* 1853| | * CNAME is in the priority list, so if 1854| | * we are done with priority types, we 1855| | * know there will not be a CNAME, and 1856| | * are safe to skip the rest. 1857| | */ 1858| 6| return cname; 1859| 6| } 1860| 6| other = true; 1861| 6| } 1862| 12| } 1863| | 1864| 6| if (cname && other) { ------------------ | Branch (1864:7): [True: 0, False: 6] | Branch (1864:16): [True: 0, False: 0] ------------------ 1865| 0| return true; 1866| 0| } 1867| 6| } 1868| | 1869| 0| return false; 1870| 6|} qpzone.c:first_existing_header: 1011| 496|first_existing_header(dns_vectop_t *top, uint32_t serial) { 1012| 496| ISC_SLIST_FOREACH(header, top->headers, next_header) { ------------------ | | 70| 496| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 496| for (typeof(first) elt = first, \ | | | | 64| 496| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 496|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 496, False: 0] | | | | ------------------ | | | | 65| 496| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 496, False: 0] | | | | ------------------ | | | | 66| 496| 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] | | | | ------------------ | | ------------------ ------------------ 1013| 496| if (header->serial <= serial && !IGNORE(header)) { ------------------ | | 27| 496| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 496|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 28| 496| DNS_VECHEADERATTR_IGNORE) != 0) ------------------ | Branch (1013:7): [True: 496, False: 0] | Branch (1013:35): [True: 496, False: 0] ------------------ 1014| 496| if (header->count != 0) { ------------------ | Branch (1014:8): [True: 496, False: 0] ------------------ 1015| 496| return header; 1016| 496| } 1017| 0| break; 1018| 496| } 1019| 496| } 1020| 0| return NULL; 1021| 496|} qpzone.c:bindrdataset: 1182| 127| dns_rdataset_t *rdataset DNS__DB_FLARG) { 1183| 127| if (rdataset == NULL) { ------------------ | Branch (1183:6): [True: 6, False: 121] ------------------ 1184| 6| return; 1185| 6| } 1186| | 1187| 121| INSIST(rdataset->methods == NULL); /* We must be disassociated. */ ------------------ | | 202| 121|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 121| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 121, False: 0] | | | | ------------------ | | | | 54| 121| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1188| | 1189| 121| rdataset->methods = &dns_rdatavec_rdatasetmethods; 1190| 121| rdataset->rdclass = qpdb->common.rdclass; 1191| 121| rdataset->type = DNS_TYPEPAIR_TYPE(header->typepair); ------------------ | | 29| 121| ({ \ | | 30| 121| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 31| 121| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 32| 121| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 121|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 33| 121| __base; \ | | 34| 121| }) ------------------ 1192| 121| rdataset->covers = DNS_TYPEPAIR_COVERS(header->typepair); ------------------ | | 36| 121| ({ \ | | 37| 121| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 38| 121| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 39| 121| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 121|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 40| 121| __covers; \ | | 41| 121| }) ------------------ 1193| 121| rdataset->ttl = header->ttl; 1194| 121| rdataset->trust = atomic_load_acquire(&header->trust); ------------------ | | 50| 121|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 1195| | 1196| 121| if (OPTOUT(header)) { ------------------ | | 30| 121| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 121|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (30:2): [True: 0, False: 121] | | ------------------ | | 31| 121| DNS_VECHEADERATTR_OPTOUT) != 0) ------------------ 1197| 0| rdataset->attributes.optout = true; 1198| 0| } 1199| | 1200| 121| rdataset->vec.header = header; 1201| 121| dns_vecheader_ref(header); 1202| 121| rdataset->vec.iter.iter_pos = NULL; 1203| 121| rdataset->vec.iter.iter_count = 0; 1204| | 1205| | /* 1206| | * Add noqname proof. 1207| | */ 1208| | 1209| | /* 1210| | * Copy out re-signing information. 1211| | */ 1212| 121| if (RESIGN(header)) { ------------------ | | 33| 121| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 121|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (33:2): [True: 0, False: 121] | | ------------------ | | 34| 121| DNS_VECHEADERATTR_RESIGN) != 0) ------------------ 1213| 0| rdataset->attributes.resign = true; 1214| 0| rdataset->resign = header->resign; 1215| 121| } else { 1216| 121| rdataset->resign = 0; 1217| 121| } 1218| 121|} qpzone.c:delegating_type: 1768| 6|delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t typepair) { 1769| 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 (1769:9): [True: 0, False: 6] ------------------ 1770| 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 (1770:10): [True: 2, False: 4] ------------------ 1771| 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 (1771:4): [True: 0, False: 2] ------------------ 1772| 6|} qpzone.c:loading_setup: 2325| 2|loading_setup(void *arg) { 2326| 2| qpz_load_t *loadctx = arg; 2327| 2| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2328| | 2329| 2| dns_qpmulti_write(qpdb->tree, &loadctx->tree); 2330| 2|} qpzone.c:loading_commit: 2333| 2|loading_commit(void *arg) { 2334| 2| qpz_load_t *loadctx = arg; 2335| 2| qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db; 2336| | 2337| 2| if (loadctx->tree != NULL) { ------------------ | Branch (2337:6): [True: 2, False: 0] ------------------ 2338| 2| dns_qp_compact(loadctx->tree, DNS_QPGC_MAYBE); 2339| 2| dns_qpmulti_commit(qpdb->tree, &loadctx->tree); 2340| 2| } 2341| 2|} qpzone.c:endload: 2372| 2|endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) { 2373| 2| qpz_load_t *loadctx = NULL; 2374| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2375| | 2376| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2377| 2| REQUIRE(DNS_CALLBACK_VALID(callbacks)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2378| 2| loadctx = callbacks->add_private; 2379| 2| REQUIRE(loadctx != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2380| 2| REQUIRE(loadctx->db == db); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2381| | 2382| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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| } ------------------ 2383| | 2384| 2| REQUIRE((qpdb->attributes & QPDB_ATTR_LOADING) != 0); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2385| 2| REQUIRE((qpdb->attributes & QPDB_ATTR_LOADED) == 0); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2386| | 2387| 2| qpdb->attributes &= ~QPDB_ATTR_LOADING; ------------------ | | 71| 2|#define QPDB_ATTR_LOADING 0x02 ------------------ 2388| 2| qpdb->attributes |= QPDB_ATTR_LOADED; ------------------ | | 70| 2|#define QPDB_ATTR_LOADED 0x01 ------------------ 2389| | 2390| 2| if (qpdb->origin != NULL) { ------------------ | Branch (2390:6): [True: 2, False: 0] ------------------ 2391| 2| qpz_version_t *version = qpdb->current_version; 2392| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 2393| 2| setsecure(db, version, (dns_dbnode_t *)qpdb->origin); 2394| 2| } else { 2395| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 2396| 0| } 2397| | 2398| 2| callbacks->update = NULL; 2399| 2| callbacks->setup = NULL; 2400| 2| callbacks->commit = NULL; 2401| 2| callbacks->add_private = NULL; 2402| | 2403| 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] | | ------------------ ------------------ 2404| | 2405| 2| return ISC_R_SUCCESS; 2406| 2|} qpzone.c:setsecure: 1308| 2|setsecure(dns_db_t *db, qpz_version_t *version, dns_dbnode_t *origin) { 1309| 2| dns_rdataset_t keyset; 1310| 2| dns_rdataset_t nsecset, signsecset; 1311| 2| bool haszonekey = false; 1312| 2| bool hasnsec = false; 1313| 2| isc_result_t result; 1314| | 1315| 2| version->secure = false; 1316| 2| version->havensec3 = false; 1317| | 1318| 2| dns_rdataset_init(&keyset); 1319| 2| result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 1320| 2| dns_rdatatype_dnskey, 0, 0, &keyset, NULL); 1321| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1321:6): [True: 0, False: 2] ------------------ 1322| 0| haszonekey = dns_dnssec_haszonekey(&keyset); 1323| 0| dns_rdataset_disassociate(&keyset); ------------------ | | 306| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1324| 0| } 1325| 2| if (!haszonekey) { ------------------ | Branch (1325:6): [True: 2, False: 0] ------------------ 1326| 2| return; 1327| 2| } 1328| | 1329| 0| dns_rdataset_init(&nsecset); 1330| 0| dns_rdataset_init(&signsecset); 1331| 0| result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version, ------------------ | | 1125| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 0| sigrdataset DNS__DB_FILELINE) ------------------ 1332| 0| dns_rdatatype_nsec, 0, 0, &nsecset, 1333| 0| &signsecset); 1334| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1334:6): [True: 0, False: 0] ------------------ 1335| 0| if (dns_rdataset_isassociated(&signsecset)) { ------------------ | Branch (1335:7): [True: 0, False: 0] ------------------ 1336| 0| hasnsec = true; 1337| 0| dns_rdataset_disassociate(&signsecset); ------------------ | | 306| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1338| 0| } 1339| 0| dns_rdataset_disassociate(&nsecset); ------------------ | | 306| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 1340| 0| } 1341| | 1342| 0| setnsec3parameters(db, version); 1343| | 1344| | /* 1345| | * If we don't have a valid NSEC/NSEC3 chain, 1346| | * clear the secure flag. 1347| | */ 1348| 0| if (version->havensec3 || hasnsec) { ------------------ | Branch (1348:6): [True: 0, False: 0] | Branch (1348:28): [True: 0, False: 0] ------------------ 1349| | version->secure = true; 1350| 0| } 1351| 0|} qpzone.c:begin_transaction: 2616| 6|begin_transaction(qpzonedb_t *qpdb, dns_qpread_t *qprp, bool create) { 2617| 6| dns_qp_t *qp = NULL; 2618| | 2619| 6| if (create) { ------------------ | Branch (2619:6): [True: 0, False: 6] ------------------ 2620| 0| dns_qpmulti_write(qpdb->tree, &qp); 2621| 6| } else { 2622| 6| dns_qpmulti_query(qpdb->tree, qprp); 2623| 6| qp = (dns_qp_t *)qprp; 2624| 6| } 2625| | 2626| 6| return qp; 2627| 6|} qpzone.c:findnodeintree: 2642| 6| bool create, bool nsec3, dns_dbnode_t **nodep DNS__DB_FLARG) { 2643| 6| isc_result_t result; 2644| 6| qpznode_t *node = NULL; 2645| 6| dns_namespace_t nspace = nsec3 ? DNS_DBNAMESPACE_NSEC3 ------------------ | Branch (2645:27): [True: 0, False: 6] ------------------ 2646| 6| : DNS_DBNAMESPACE_NORMAL; 2647| | /* 2648| | * findnodeintree is a wrapper around dns_qp_getname that does some 2649| | * qpzone-specific bookkeeping before returning the lookup result to the 2650| | * caller. 2651| | * 2652| | * First, we do a lookup ... 2653| | */ 2654| 6| result = dns_qp_getname(qp, name, nspace, (void **)&node, NULL); 2655| 6| if (result == ISC_R_SUCCESS) { ------------------ | Branch (2655:6): [True: 6, False: 0] ------------------ 2656| | /* 2657| | * ... if the lookup is successful, we need to increase both the 2658| | * internal and external reference count before returning to 2659| | * the caller. qpznode_acquire takes care of that. 2660| | */ 2661| 6| qpznode_acquire(node DNS__DB_FLARG_PASS); 2662| | 2663| 6| INSIST(node->nspace == DNS_DBNAMESPACE_NSEC3 || !nsec3); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 0, False: 6] | | | | | Branch (53:11): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2664| 6| } else if (result != ISC_R_SUCCESS && create) { ------------------ | Branch (2664:13): [True: 0, False: 0] | Branch (2664:40): [True: 0, False: 0] ------------------ 2665| 0| if (!dns_name_issubdomain(name, &qpdb->common.origin)) { ------------------ | | 1544| 0| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (2665:7): [True: 0, False: 0] ------------------ 2666| 0| return DNS_R_OUTOFZONE; 2667| 0| } 2668| | 2669| | /* 2670| | * ... if the lookup is unsuccessful, but the caller asked us to 2671| | * create a new node, create one and insert it into the tree. 2672| | */ 2673| 0| node = new_qpznode(qpdb, name, nspace); 2674| 0| result = dns_qp_insert(qp, node, 0); 2675| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2676| | 2677| | /* 2678| | * The new node now has two internal references: 2679| | * - One from new_qpznode, that initializes references at 1. 2680| | * - One from attach_leaf, that increases the reference by 2681| | * one at insertion in the qp-tree. 2682| | * We want the node to have two internal and one external 2683| | * reference: 2684| | * - One internal reference from the qp-tree. 2685| | * - One internal and one external reference from the caller. 2686| | * 2687| | * So we increase the external reference count by one. 2688| | */ 2689| 0| qpznode_erefs_increment(node DNS__DB_FLARG_PASS); 2690| | 2691| 0| if (!nsec3) { ------------------ | Branch (2691:7): [True: 0, False: 0] ------------------ 2692| | /* 2693| | * Add empty non-terminal nodes to help with wildcards. 2694| | */ 2695| 0| addwildcards(qpdb, qp, name, nspace); 2696| 0| if (dns_name_iswildcard(name)) { ------------------ | | 1529| 0|#define dns_name_iswildcard(name) dns_name__iswildcard(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1529:35): [True: 0, False: 0] | | ------------------ ------------------ 2697| 0| wildcardmagic(qpdb, qp, name, nspace); 2698| 0| } 2699| 0| } 2700| | 2701| 0| INSIST(node->nspace == DNS_DBNAMESPACE_NSEC3 || !nsec3); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 0, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2702| 0| } 2703| | /* 2704| | * ... if the lookup is unsuccessful, and the caller didn't ask us 2705| | * to create a new node, there is nothing to do. Return the result 2706| | * of the lookup to the caller, and set *nodep to NULL 2707| | */ 2708| | 2709| 6| *nodep = (dns_dbnode_t *)node; 2710| | 2711| 6| return result; 2712| 6|} qpzone.c:end_transaction: 2630| 6|end_transaction(qpzonedb_t *qpdb, dns_qp_t *qp, bool create) { 2631| 6| if (create) { ------------------ | Branch (2631:6): [True: 0, False: 6] ------------------ 2632| 0| dns_qp_compact(qp, DNS_QPGC_MAYBE); 2633| 0| dns_qpmulti_commit(qpdb->tree, &qp); 2634| 6| } else { 2635| 6| dns_qpread_t *qprp = (dns_qpread_t *)qp; 2636| 6| dns_qpread_destroy(qpdb->tree, qprp); 2637| 6| } 2638| 6|} qpzone.c:currentversion: 1354| 218|currentversion(dns_db_t *db, dns_dbversion_t **versionp) { 1355| 218| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1356| 218| qpz_version_t *version = NULL; 1357| | 1358| 218| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 218|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 436| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 218, False: 0] | | | | | Branch (41:11): [True: 218, False: 0] | | | | ------------------ | | | | 42| 218| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1359| | 1360| 218| RWLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 30| 218| { \ | | 31| 218| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 218| (t), __FILE__, __LINE__)); \ | | 33| 218| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 218| { \ | | | | 253| 218| switch (type) { \ | | | | 254| 218| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 218, False: 0] | | | | ------------------ | | | | 255| 218| isc_rwlock_rdlock(rwl); \ | | | | 256| 218| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 218] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 218] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 218| } \ | | | | 263| 218| } | | ------------------ | | 34| 218| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 218| (lp), (t), __FILE__, __LINE__)); \ | | 36| 218| } ------------------ 1361| 218| version = qpdb->current_version; 1362| 218| isc_refcount_increment(&version->references); ------------------ | | 81| 218| ({ \ | | 82| 218| uint_fast32_t __v; \ | | 83| 218| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 218| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 84| 218| INSIST(__v > 0 && __v < UINT32_MAX); \ | | ------------------ | | | | 202| 218|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 436| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:11): [True: 218, False: 0] | | | | | | | Branch (53:11): [True: 218, False: 0] | | | | | | ------------------ | | | | | | 54| 218| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 218| __v; \ | | 86| 218| }) ------------------ 1363| 218| RWUNLOCK(&qpdb->lock, isc_rwlocktype_read); ------------------ | | 38| 218| { \ | | 39| 218| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 218| (lp), (t), __FILE__, __LINE__)); \ | | 41| 218| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 218| { \ | | | | 283| 218| switch (type) { \ | | | | 284| 218| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 218, False: 0] | | | | ------------------ | | | | 285| 218| isc_rwlock_rdunlock(rwl); \ | | | | 286| 218| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 218] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 218] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 218| } \ | | | | 293| 218| } | | ------------------ | | 42| 218| } ------------------ 1364| | 1365| 218| *versionp = (dns_dbversion_t *)version; 1366| 218|} qpzone.c:closeversion: 1452| 218| bool commit DNS__DB_FLARG) { 1453| 218| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1454| 218| qpz_version_t *version = NULL, *cleanup_version = NULL; 1455| 218| qpz_version_t *least_greater = NULL; 1456| 218| qpznode_t *node = NULL; 1457| 218| bool rollback = false; 1458| 218| qpz_changedlist_t cleanup_list; 1459| 218| qpz_resignedlist_t resigned_list; 1460| 218| uint32_t serial, least_serial; 1461| | 1462| 218| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 218|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 436| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 218, False: 0] | | | | | Branch (41:11): [True: 218, False: 0] | | | | ------------------ | | | | 42| 218| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1463| 218| version = (qpz_version_t *)*versionp; 1464| 218| INSIST(version->qpdb == qpdb); ------------------ | | 202| 218|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 218| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 218, False: 0] | | | | ------------------ | | | | 54| 218| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1465| | 1466| 218| if (isc_refcount_decrement(&version->references) > 1) { ------------------ | | 94| 218| ({ \ | | 95| 218| uint_fast32_t __v; \ | | 96| 218| __v = atomic_fetch_sub_acq_rel(target, 1); \ | | ------------------ | | | | 66| 218| atomic_fetch_sub_explicit((o), (v), memory_order_acq_rel) | | ------------------ | | 97| 218| INSIST(__v > 0); \ | | ------------------ | | | | 202| 218|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 218| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 218, False: 0] | | | | | | ------------------ | | | | | | 54| 218| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 218| __v; \ | | 99| 218| }) ------------------ | Branch (1466:6): [True: 218, False: 0] ------------------ 1467| 218| *versionp = NULL; 1468| 218| return; 1469| 218| } 1470| | 1471| 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] | | ------------------ ------------------ 1472| 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] | | ------------------ ------------------ 1473| | 1474| | /* 1475| | * Update the zone's secure status in version before making 1476| | * it the current version. 1477| | */ 1478| 0| if (version->writer && commit) { ------------------ | Branch (1478:6): [True: 0, False: 0] | Branch (1478:25): [True: 0, False: 0] ------------------ 1479| 0| setsecure(db, version, (dns_dbnode_t *)qpdb->origin); 1480| 0| } 1481| | 1482| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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| } ------------------ 1483| 0| serial = version->serial; 1484| 0| if (version->writer) { ------------------ | Branch (1484:6): [True: 0, False: 0] ------------------ 1485| 0| if (commit) { ------------------ | Branch (1485:7): [True: 0, False: 0] ------------------ 1486| 0| unsigned int cur_ref; 1487| 0| qpz_version_t *cur_version = NULL; 1488| | 1489| 0| INSIST(version == qpdb->future_version); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1490| | /* 1491| | * The current version is going to be replaced. 1492| | * Release the (likely last) reference to it from the 1493| | * DB itself and unlink it from the open list. 1494| | */ 1495| 0| cur_version = qpdb->current_version; 1496| 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) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 98| 0| __v; \ | | 99| 0| }) ------------------ 1497| 0| &cur_version->references); 1498| 0| if (cur_ref == 1) { ------------------ | Branch (1498:8): [True: 0, False: 0] ------------------ 1499| 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) | | ------------------ ------------------ 1500| 0| &cur_version->references); 1501| 0| if (cur_version->serial == qpdb->least_serial) { ------------------ | Branch (1501:9): [True: 0, False: 0] ------------------ 1502| 0| INSIST(ISC_LIST_EMPTY( ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1503| 0| cur_version->changed_list)); 1504| 0| } 1505| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1506| 0| cur_version, link); 1507| 0| } 1508| 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] | | ------------------ ------------------ 1509| | /* 1510| | * We're going to become the least open 1511| | * version. 1512| | */ 1513| 0| make_least_version(qpdb, version, 1514| 0| &cleanup_list); 1515| 0| } else { 1516| | /* 1517| | * Some other open version is the 1518| | * least version. We can't cleanup 1519| | * records that were changed in this 1520| | * version because the older versions 1521| | * may still be in use by an open 1522| | * version. 1523| | * 1524| | * We can, however, discard the 1525| | * changed records for things that 1526| | * we've added that didn't exist in 1527| | * prior versions. 1528| | */ 1529| 0| cleanup_nondirty(version, &cleanup_list); 1530| 0| } 1531| | /* 1532| | * If the (soon to be former) current version 1533| | * isn't being used by anyone, we can clean 1534| | * it up. 1535| | */ 1536| 0| if (cur_ref == 1) { ------------------ | Branch (1536:8): [True: 0, False: 0] ------------------ 1537| 0| cleanup_version = cur_version; 1538| 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] | | ------------------ ------------------ 1539| 0| version->changed_list, 1540| 0| cleanup_version->changed_list, link); 1541| 0| } 1542| | /* 1543| | * Become the current version. 1544| | */ 1545| 0| version->writer = false; 1546| 0| qpdb->current_version = version; 1547| 0| qpdb->current_serial = version->serial; 1548| 0| qpdb->future_version = NULL; 1549| | 1550| | /* 1551| | * Keep the current version in the open list, and 1552| | * gain a reference for the DB itself (see the DB 1553| | * creation function below). This must be the only 1554| | * case where we need to increment the counter from 1555| | * zero and need to use isc_refcount_increment0(). 1556| | */ 1557| 0| INSIST(isc_refcount_increment0(&version->references) == ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1558| 0| 0); 1559| 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] | | ------------------ ------------------ 1560| 0| qpdb->current_version, link); 1561| 0| resigned_list = version->resigned_list; 1562| 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] | | ------------------ ------------------ 1563| 0| } else { 1564| | /* 1565| | * We're rolling back this transaction. 1566| | */ 1567| 0| cleanup_list = version->changed_list; 1568| 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] | | ------------------ ------------------ 1569| 0| resigned_list = version->resigned_list; 1570| 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] | | ------------------ ------------------ 1571| 0| rollback = true; 1572| 0| cleanup_version = version; 1573| 0| qpdb->future_version = NULL; 1574| 0| } 1575| 0| } else { 1576| 0| if (version != qpdb->current_version) { ------------------ | Branch (1576:7): [True: 0, False: 0] ------------------ 1577| | /* 1578| | * There are no external or internal references 1579| | * to this version and it can be cleaned up. 1580| | */ 1581| 0| cleanup_version = version; 1582| | 1583| | /* 1584| | * Find the version with the least serial 1585| | * number greater than ours. 1586| | */ 1587| 0| least_greater = ISC_LIST_PREV(version, link); ------------------ | | 139| 0|#define ISC_LIST_PREV(elt, link) ((elt)->link.prev) ------------------ 1588| 0| if (least_greater == NULL) { ------------------ | Branch (1588:8): [True: 0, False: 0] ------------------ 1589| 0| least_greater = qpdb->current_version; 1590| 0| } 1591| | 1592| 0| INSIST(version->serial < least_greater->serial); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1593| | /* 1594| | * Is this the least open version? 1595| | */ 1596| 0| if (version->serial == qpdb->least_serial) { ------------------ | Branch (1596:8): [True: 0, False: 0] ------------------ 1597| | /* 1598| | * Yes. Install the new least open 1599| | * version. 1600| | */ 1601| 0| make_least_version(qpdb, least_greater, 1602| 0| &cleanup_list); 1603| 0| } else { 1604| | /* 1605| | * Add any unexecuted cleanups to 1606| | * those of the least greater version. 1607| | */ 1608| 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] | | ------------------ ------------------ 1609| 0| version->changed_list, 1610| 0| link); 1611| 0| } 1612| 0| } else if (version->serial == qpdb->least_serial) { ------------------ | Branch (1612:14): [True: 0, False: 0] ------------------ 1613| 0| INSIST(ISC_LIST_EMPTY(version->changed_list)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1614| 0| } 1615| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1616| 0| } 1617| 0| least_serial = qpdb->least_serial; 1618| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 1619| | 1620| 0| if (cleanup_version != NULL) { ------------------ | Branch (1620:6): [True: 0, False: 0] ------------------ 1621| 0| isc_refcount_destroy(&cleanup_version->references); ------------------ | | 60| 0| ISC_REQUIRE(isc_refcount_current(target) == 0) | | ------------------ | | | | 41| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 0, False: 0] | | | | ------------------ | | | | 42| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1622| 0| INSIST(ISC_LIST_EMPTY(cleanup_version->changed_list)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1623| 0| cleanup_gluelists(&cleanup_version->glue_stack); 1624| 0| cds_wfs_destroy(&cleanup_version->glue_stack); 1625| 0| isc_rwlock_destroy(&cleanup_version->rwlock); 1626| 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] | | ------------------ ------------------ 1627| 0| sizeof(*cleanup_version)); 1628| 0| } 1629| | 1630| | /* 1631| | * Commit/rollback re-signed headers. 1632| | */ 1633| 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] | | ------------------ ------------------ 1634| 0| isc_rwlock_t *nlock = NULL; 1635| 0| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1636| 0| dns_vecheader_t *header = resigned->header; 1637| 0| qpznode_t *resigned_node = resigned->node; 1638| | 1639| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 1640| | 1641| 0| nlock = qpzone_get_lock(resigned_node); 1642| 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() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 1643| 0| if (rollback && !IGNORE(header)) { ------------------ | | 27| 0| ((atomic_load_acquire(&(header)->attributes) & \ | | ------------------ | | | | 50| 0|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | 28| 0| DNS_VECHEADERATTR_IGNORE) != 0) ------------------ | Branch (1643:7): [True: 0, False: 0] | Branch (1643:19): [True: 0, False: 0] ------------------ 1644| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 1645| 0| resign_register(qpdb->heap, resigned_node, header); 1646| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 1647| 0| } 1648| 0| qpz_resigned_destroy(db->mctx, &resigned); 1649| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 1650| 0| } 1651| | 1652| 0| if (ISC_LIST_EMPTY(cleanup_list)) { ------------------ | | 64| 0|#define ISC_LIST_EMPTY(list) ((list).head == NULL) | | ------------------ | | | Branch (64:30): [True: 0, False: 0] | | ------------------ ------------------ 1653| 0| *versionp = NULL; 1654| 0| return; 1655| 0| } 1656| | 1657| 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] | | ------------------ ------------------ 1658| 0| isc_rwlock_t *nlock = NULL; 1659| 0| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1660| | 1661| 0| node = changed->node; 1662| 0| nlock = qpzone_get_lock(node); 1663| | 1664| 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() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 1665| 0| if (rollback) { ------------------ | Branch (1665:7): [True: 0, False: 0] ------------------ 1666| 0| rollback_node(node, serial); 1667| 0| } 1668| 0| bool has_erefs = qpznode_release(node DNS__DB_FILELINE); 1669| 0| if (!has_erefs) { ------------------ | Branch (1669:7): [True: 0, False: 0] ------------------ 1670| 0| clean_zone_node(qpdb->heap, node, least_serial); 1671| 0| } 1672| | 1673| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 1674| | 1675| | /* 1676| | * The node reference is released separately above, so 1677| | * we just free the changed structure here. 1678| | */ 1679| 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] | | ------------------ ------------------ 1680| 0| } 1681| | 1682| 0| *versionp = NULL; 1683| 0|} qpzone.c:qpzone_findrdataset: 1690| 14| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 1691| 14| qpzonedb_t *qpdb = (qpzonedb_t *)db; 1692| 14| qpznode_t *node = (qpznode_t *)dbnode; 1693| 14| dns_vecheader_t *found = NULL, *foundsig = NULL; 1694| 14| uint32_t serial; 1695| 14| qpz_version_t *version = (qpz_version_t *)dbversion; 1696| 14| bool close_version = false; 1697| 14| dns_typepair_t typepair, sigpair; 1698| 14| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 1699| 14| isc_rwlock_t *nlock = NULL; 1700| | 1701| 14| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1702| 14| REQUIRE(type != dns_rdatatype_any); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1703| 14| INSIST(version == NULL || version->qpdb == qpdb); ------------------ | | 202| 14|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 4, False: 10] | | | | | Branch (53:11): [True: 10, False: 0] | | | | ------------------ | | | | 54| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1704| | 1705| 14| if (type == dns_rdatatype_none && covers == dns_rdatatype_none) { ------------------ | | 115| 28|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ if (type == dns_rdatatype_none && covers == dns_rdatatype_none) { ------------------ | | 115| 0|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1705:6): [True: 0, False: 14] | Branch (1705:36): [True: 0, False: 0] ------------------ 1706| 0| return ISC_R_NOTFOUND; 1707| 0| } 1708| | 1709| 14| if (version == NULL) { ------------------ | Branch (1709:6): [True: 4, False: 10] ------------------ 1710| 4| currentversion(db, (dns_dbversion_t **)&version); 1711| 4| close_version = true; 1712| 4| } 1713| 14| serial = version->serial; 1714| | 1715| 14| nlock = qpzone_get_lock(node); 1716| 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() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 1717| | 1718| 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| }) ------------------ 1719| 14| if (covers == dns_rdatatype_none) { ------------------ | | 115| 14|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (1719:6): [True: 14, False: 0] ------------------ 1720| 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)) | | ------------------ ------------------ 1721| 14| } else { 1722| 0| sigpair = dns_typepair_none; 1723| 0| } 1724| | 1725| 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] | | | | ------------------ | | ------------------ ------------------ 1726| 42| dns_vecheader_t *header = first_existing_header(top, serial); 1727| 42| if (header != NULL) { ------------------ | Branch (1727:7): [True: 42, False: 0] ------------------ 1728| | /* 1729| | * We have an active, extant rdataset. If it's a 1730| | * type we're looking for, remember it. 1731| | */ 1732| 42| if (top->typepair == typepair) { ------------------ | Branch (1732:8): [True: 4, False: 38] ------------------ 1733| 4| found = header; 1734| 4| if (foundsig != NULL) { ------------------ | Branch (1734:9): [True: 0, False: 4] ------------------ 1735| 0| break; 1736| 0| } 1737| 38| } else if (top->typepair == sigpair) { ------------------ | Branch (1737:15): [True: 0, False: 38] ------------------ 1738| 0| foundsig = header; 1739| 0| if (found != NULL) { ------------------ | Branch (1739:9): [True: 0, False: 0] ------------------ 1740| 0| break; 1741| 0| } 1742| 0| } 1743| 42| } 1744| 42| } 1745| 14| if (found != NULL) { ------------------ | Branch (1745:6): [True: 4, False: 10] ------------------ 1746| 4| bindrdataset(qpdb, found, rdataset DNS__DB_FLARG_PASS); 1747| 4| if (foundsig != NULL) { ------------------ | Branch (1747:7): [True: 0, False: 4] ------------------ 1748| 0| bindrdataset(qpdb, foundsig, 1749| 0| sigrdataset DNS__DB_FLARG_PASS); 1750| 0| } 1751| 4| } 1752| | 1753| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 14| } \ | | | | | | 293| 14| } | | | | ------------------ | | | | 42| 14| } | | ------------------ | | 40| 14| *tp = isc_rwlocktype_none; \ | | 41| 14| } ------------------ 1754| | 1755| 14| if (close_version) { ------------------ | Branch (1755:6): [True: 4, False: 10] ------------------ 1756| 4| closeversion(db, (dns_dbversion_t **)&version, 1757| 4| false DNS__DB_FLARG_PASS); 1758| 4| } 1759| | 1760| 14| if (found == NULL) { ------------------ | Branch (1760:6): [True: 10, False: 4] ------------------ 1761| 10| return ISC_R_NOTFOUND; 1762| 10| } 1763| | 1764| 4| return ISC_R_SUCCESS; 1765| 14|} qpzone.c:issecure: 2409| 2|issecure(dns_db_t *db) { 2410| 2| qpzonedb_t *qpdb = NULL; 2411| 2| bool secure; 2412| | 2413| 2| qpdb = (qpzonedb_t *)db; 2414| | 2415| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2416| | 2417| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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| } ------------------ 2418| 2| secure = qpdb->current_version->secure; 2419| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 2420| | 2421| 2| return secure; 2422| 2|} qpzone.c:nodecount: 4138| 2|nodecount(dns_db_t *db) { 4139| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 4140| 2| dns_qp_memusage_t mu; 4141| | 4142| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4143| | 4144| 2| mu = dns_qpmulti_memusage(qpdb->tree); 4145| | 4146| 2| return mu.leaves; 4147| 2|} qpzone.c:getoriginnode: 4150| 2|getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) { 4151| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 4152| | 4153| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4154| 2| REQUIRE(nodep != NULL && *nodep == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4155| | 4156| | /* Note that the access to the origin node doesn't require a DB lock */ 4157| 2| INSIST(qpdb->origin != NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4158| 2| qpznode_acquire(qpdb->origin DNS__DB_FLARG_PASS); 4159| 2| *nodep = (dns_dbnode_t *)qpdb->origin; 4160| | 4161| 2| return ISC_R_SUCCESS; 4162| 2|} qpzone.c:qpzone_findnode: 2718| 6| dns_dbnode_t **nodep DNS__DB_FLARG) { 2719| 6| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2720| | 2721| 6| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2722| | 2723| 6| dns_qpread_t qpr = { 0 }; 2724| 6| dns_qp_t *qp = begin_transaction(qpdb, &qpr, create); 2725| | 2726| 6| isc_result_t result = findnodeintree(qpdb, qp, name, create, false, 2727| 6| nodep DNS__DB_FLARG_PASS); 2728| | 2729| 6| end_transaction(qpdb, qp, create); 2730| | 2731| 6| return result; 2732| 6|} qpzone.c:qpzone_find: 3576| 208| dns_rdataset_t *sigrdataset DNS__DB_FLARG) { 3577| 208| isc_result_t result; 3578| 208| qpzonedb_t *qpdb = (qpzonedb_t *)db; 3579| 208| qpznode_t *node = NULL; 3580| 208| bool cname_ok = true, close_version = false; 3581| 208| bool maybe_zonecut = false; 3582| 208| bool wild = false, empty_node = false; 3583| 208| bool nsec3 = false; 3584| 208| dns_vecheader_t *found = NULL, *nsecheader = NULL; 3585| 208| dns_vecheader_t *foundsig = NULL, *cnamesig = NULL, *nsecsig = NULL; 3586| 208| dns_typepair_t sigpair; 3587| 208| bool active; 3588| 208| isc_rwlock_t *nlock = NULL; 3589| 208| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 3590| | 3591| 208| REQUIRE(VALID_QPZONE((qpzonedb_t *)db)); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 3592| 208| INSIST(version == NULL || ------------------ | | 202| 208|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 208| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 208, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 3593| 208| ((qpz_version_t *)version)->qpdb == (qpzonedb_t *)db); 3594| | 3595| | /* 3596| | * If the caller didn't supply a version, attach to the current 3597| | * version. 3598| | */ 3599| 208| if (version == NULL) { ------------------ | Branch (3599:6): [True: 208, False: 0] ------------------ 3600| 208| currentversion(db, &version); 3601| 208| close_version = true; 3602| 208| } 3603| | 3604| 208| dns_namespace_t nspace; 3605| 208| qpz_search_t search; 3606| 208| qpz_search_init(&search, (qpzonedb_t *)db, (qpz_version_t *)version, 3607| 208| options); 3608| | 3609| 208| if ((options & DNS_DBFIND_FORCENSEC3) != 0) { ------------------ | Branch (3609:6): [True: 0, False: 208] ------------------ 3610| 0| nsec3 = true; 3611| 0| nspace = DNS_DBNAMESPACE_NSEC3; 3612| 208| } else { 3613| 208| nspace = DNS_DBNAMESPACE_NORMAL; 3614| 208| } 3615| 208| dns_qpmulti_query(qpdb->tree, &search.qpr); 3616| | 3617| | /* 3618| | * Search down from the root of the tree. 3619| | */ 3620| 208| result = dns_qp_lookup(&search.qpr, name, nspace, &search.iter, 3621| 208| &search.chain, (void **)&node, NULL); 3622| 208| if (!qpz_search_setbase(&search, ------------------ | Branch (3622:6): [True: 0, False: 208] ------------------ 3623| 208| nsec3 ? qpdb->nsec3_origin : qpdb->origin)) ------------------ | Branch (3623:5): [True: 0, False: 208] ------------------ 3624| 0| { 3625| | /* The name is not in the zone. */ 3626| 0| result = ISC_R_NOTFOUND; 3627| 0| goto tree_exit; 3628| 0| } 3629| 208| dns_name_copy(&node->name, foundname); ------------------ | | 1525| 208| dns_name__copy(DNS_NAME__RO_ARG(source), dest) | | ------------------ | | | | 1507| 208| _Generic((arg), \ | | | | 1508| 208| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 208| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 208| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 208| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 208| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 208| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 3630| | 3631| | /* 3632| | * Check the QP chain to see if there's a node above us with a 3633| | * active DNAME or NS rdatasets. 3634| | * 3635| | * We're only interested in nodes above QNAME, so if the result 3636| | * was success, then we skip the last item in the chain. 3637| | */ 3638| 208| unsigned int clen = dns_qpchain_length(&search.chain); 3639| 208| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3639:6): [True: 117, False: 91] ------------------ 3640| 117| clen--; 3641| 117| } 3642| 208| for (unsigned int i = search.chain_base; 3643| 299| i < clen && search.zonecut == NULL; i++) ------------------ | Branch (3643:7): [True: 91, False: 208] | Branch (3643:19): [True: 91, False: 0] ------------------ 3644| 91| { 3645| 91| qpznode_t *n = NULL; 3646| 91| isc_result_t tresult; 3647| | 3648| 91| dns_qpchain_node(&search.chain, i, (void **)&n, NULL); 3649| 91| tresult = qpzone_check_zonecut(n, &search DNS__DB_FLARG_PASS); 3650| 91| if (tresult != DNS_R_CONTINUE) { ------------------ | Branch (3650:7): [True: 0, False: 91] ------------------ 3651| 0| result = tresult; 3652| 0| dns_name_copy(&n->name, foundname); ------------------ | | 1525| 0| dns_name__copy(DNS_NAME__RO_ARG(source), dest) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 3653| 0| node = n; 3654| 0| } 3655| 91| } 3656| | 3657| 208| if (result == DNS_R_PARTIALMATCH) { ------------------ | Branch (3657:6): [True: 91, False: 117] ------------------ 3658| 91| partial_match: 3659| 91| if (search.zonecut != NULL) { ------------------ | Branch (3659:7): [True: 0, False: 91] ------------------ 3660| 0| result = qpzone_setup_delegation( 3661| 0| &search, foundname, rdataset, 3662| 0| sigrdataset DNS__DB_FLARG_PASS); 3663| 0| goto tree_exit; 3664| 0| } 3665| | 3666| 91| if (search.wild) { ------------------ | Branch (3666:7): [True: 0, False: 91] ------------------ 3667| | /* 3668| | * At least one of the levels in the search chain 3669| | * potentially has a wildcard. For each such level, 3670| | * we must see if there's a matching wildcard active 3671| | * in the current version. 3672| | */ 3673| 0| result = find_wildcard(&search, &node, name, nspace); 3674| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3674:8): [True: 0, False: 0] ------------------ 3675| 0| dns_name_copy(&node->name, foundname); ------------------ | | 1525| 0| dns_name__copy(DNS_NAME__RO_ARG(source), dest) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 3676| 0| wild = true; 3677| 0| goto found; 3678| 0| } else if (result != ISC_R_NOTFOUND) { ------------------ | Branch (3678:15): [True: 0, False: 0] ------------------ 3679| 0| goto tree_exit; 3680| 0| } 3681| 0| } 3682| | 3683| 91| active = false; 3684| 91| if (!nsec3) { ------------------ | Branch (3684:7): [True: 91, False: 0] ------------------ 3685| | /* 3686| | * The NSEC3 tree won't have empty nodes, 3687| | * so it isn't necessary to check for them. 3688| | */ 3689| 91| dns_qpiter_t iter = search.iter; 3690| 91| active = activeempty(&search, &iter, name); 3691| 91| } 3692| | 3693| | /* 3694| | * If we're here, then the name does not exist, is not 3695| | * beneath a zonecut, and there's no matching wildcard. 3696| | */ 3697| 91| if ((search.version->secure && !search.version->havensec3) || ------------------ | Branch (3697:8): [True: 0, False: 91] | Branch (3697:34): [True: 0, False: 0] ------------------ 3698| 91| nsec3) ------------------ | Branch (3698:7): [True: 0, False: 91] ------------------ 3699| 0| { 3700| 0| result = find_closest_nsec( 3701| 0| &search, foundname, rdataset, sigrdataset, 3702| 0| nsec3, 3703| 0| search.version->secure DNS__DB_FLARG_PASS); 3704| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3704:8): [True: 0, False: 0] ------------------ 3705| 0| result = active ? DNS_R_EMPTYNAME ------------------ | Branch (3705:14): [True: 0, False: 0] ------------------ 3706| 0| : DNS_R_NXDOMAIN; 3707| 0| } 3708| 91| } else { 3709| 91| result = active ? DNS_R_EMPTYNAME : DNS_R_NXDOMAIN; ------------------ | Branch (3709:13): [True: 0, False: 91] ------------------ 3710| 91| } 3711| 91| goto tree_exit; 3712| 117| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (3712:13): [True: 0, False: 117] ------------------ 3713| 0| goto tree_exit; 3714| 0| } 3715| | 3716| 117|found: 3717| | /* 3718| | * We have found a node whose name is the desired name, or we 3719| | * have matched a wildcard. 3720| | */ 3721| | 3722| 117| nlock = qpzone_get_lock(node); 3723| 117| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 117|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 117| { \ | | | | 32| 117| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 117| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 117| { \ | | | | | | 31| 117| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 117| (t), __FILE__, __LINE__)); \ | | | | | | 33| 117| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 117| { \ | | | | | | | | 253| 117| switch (type) { \ | | | | | | | | 254| 117| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 117, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 117| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 117| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 117] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 117] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 117| } \ | | | | | | | | 263| 117| } | | | | | | ------------------ | | | | | | 34| 117| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 117| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 117| } | | | | ------------------ | | | | 34| 117| *tp = t; \ | | | | 35| 117| } | | ------------------ ------------------ 3724| | 3725| 117| if (search.zonecut != NULL) { ------------------ | Branch (3725:6): [True: 0, False: 117] ------------------ 3726| | /* 3727| | * If we're beneath a zone cut, we don't want to look for 3728| | * CNAMEs because they're not legitimate zone glue. 3729| | */ 3730| 0| cname_ok = false; 3731| 117| } else { 3732| | /* 3733| | * The node may be a zone cut itself. If it might be one, 3734| | * make sure we check for it later. 3735| | * 3736| | * DS records live above the zone cut in ordinary zone so 3737| | * we want to ignore any referral. 3738| | * 3739| | * Stub zones don't have anything "above" the delegation so 3740| | * we always return a referral. 3741| | */ 3742| 117| if (node->delegating && ((node != search.qpdb->origin && ------------------ | Branch (3742:7): [True: 0, False: 117] | Branch (3742:29): [True: 0, False: 0] ------------------ 3743| 0| !dns_rdatatype_atparent(type)) || ------------------ | Branch (3743:8): [True: 0, False: 0] ------------------ 3744| 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] | | ------------------ ------------------ 3745| 0| { 3746| 0| maybe_zonecut = true; 3747| 0| } 3748| 117| } 3749| | 3750| | /* 3751| | * Certain DNSSEC types are not subject to CNAME matching 3752| | * (RFC4035, section 2.5). 3753| | * 3754| | * We don't check for RRSIG, because we don't store RRSIG records 3755| | * directly. 3756| | */ 3757| 117| if (type == dns_rdatatype_nsec) { ------------------ | | 162| 117|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (3757:6): [True: 0, False: 117] ------------------ 3758| 0| cname_ok = false; 3759| 0| } 3760| | 3761| | /* 3762| | * We now go looking for rdata... 3763| | */ 3764| | 3765| 117| sigpair = DNS_SIGTYPEPAIR(type); ------------------ | | 52| 117|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 117| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 117| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3766| 117| empty_node = true; 3767| 351| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 117| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 117| for (typeof(first) elt = first, \ | | | | 64| 117| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 117|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 117, False: 0] | | | | ------------------ | | | | 65| 468| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 351, False: 117] | | | | ------------------ | | | | 66| 351| elt = elt##_next, \ | | | | 67| 351| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 234|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 234, False: 117] | | | | ------------------ | | ------------------ ------------------ 3768| | /* 3769| | * Look for an active, extant rdataset. 3770| | */ 3771| 351| dns_vecheader_t *header = first_existing_header(top, 3772| 351| search.serial); 3773| 351| if (header != NULL) { ------------------ | Branch (3773:7): [True: 351, False: 0] ------------------ 3774| | /* 3775| | * We now know that there is at least one active 3776| | * rdataset at this node. 3777| | */ 3778| 351| empty_node = false; 3779| | 3780| | /* 3781| | * Do special zone cut handling, if requested. 3782| | */ 3783| 351| if (maybe_zonecut && ------------------ | Branch (3783:8): [True: 0, False: 351] ------------------ 3784| 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 (3784:8): [True: 0, False: 0] ------------------ 3785| 0| { 3786| | /* 3787| | * We increment the reference count on node to 3788| | * ensure that search->zonecut_header will 3789| | * still be valid later. 3790| | */ 3791| 0| qpznode_acquire(node DNS__DB_FLARG_PASS); 3792| 0| search.zonecut = node; 3793| 0| search.zonecut_header = header; 3794| 0| search.zonecut_sigheader = NULL; 3795| 0| maybe_zonecut = false; 3796| | 3797| 0| if ((search.options & DNS_DBFIND_GLUEOK) == 0 && ------------------ | Branch (3797:9): [True: 0, False: 0] ------------------ 3798| 0| type != dns_rdatatype_nsec) ------------------ | | 162| 0|#define dns_rdatatype_nsec ((dns_rdatatype_t)dns_rdatatype_nsec) ------------------ | Branch (3798:9): [True: 0, False: 0] ------------------ 3799| 0| { 3800| | /* 3801| | * Glue is not OK, but any answer we 3802| | * could return would be glue. Return 3803| | * the delegation. 3804| | */ 3805| 0| found = NULL; 3806| 0| break; 3807| 0| } 3808| 0| if (found != NULL && foundsig != NULL) { ------------------ | Branch (3808:9): [True: 0, False: 0] | Branch (3808:26): [True: 0, False: 0] ------------------ 3809| 0| break; 3810| 0| } 3811| 0| } 3812| | 3813| | /* 3814| | * If the NSEC3 record doesn't match the chain 3815| | * we are using behave as if it isn't here. 3816| | */ 3817| 351| if (top->typepair == ------------------ | Branch (3817:8): [True: 0, False: 351] ------------------ 3818| 351| DNS_TYPEPAIR(dns_rdatatype_nsec3) && ------------------ | | 51| 351|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 702| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 702| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3819| 0| !matchparams(header, &search)) ------------------ | Branch (3819:8): [True: 0, False: 0] ------------------ 3820| 0| { 3821| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3822| 0| goto partial_match; 3823| 0| } 3824| | /* 3825| | * If we found a type we were looking for, 3826| | * remember it. 3827| | */ 3828| 351| if (top->typepair == type || ------------------ | Branch (3828:8): [True: 117, False: 234] ------------------ 3829| 234| type == dns_rdatatype_any || ------------------ | | 206| 585|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3829:8): [True: 0, False: 234] ------------------ 3830| 234| (top->typepair == ------------------ | Branch (3830:9): [True: 0, False: 234] ------------------ 3831| 234| DNS_TYPEPAIR(dns_rdatatype_cname) && ------------------ | | 51| 234|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 468| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 468| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3832| 0| cname_ok)) ------------------ | Branch (3832:9): [True: 0, False: 0] ------------------ 3833| 117| { 3834| | /* 3835| | * We've found the answer! 3836| | */ 3837| 117| found = header; 3838| 117| if (top->typepair == ------------------ | Branch (3838:9): [True: 0, False: 117] ------------------ 3839| 117| DNS_TYPEPAIR(dns_rdatatype_cname) && ------------------ | | 51| 117|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 234| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 234| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3840| 0| cname_ok) ------------------ | Branch (3840:9): [True: 0, False: 0] ------------------ 3841| 0| { 3842| | /* 3843| | * We may be finding a CNAME instead 3844| | * of the desired type. 3845| | * 3846| | * If we've already got the CNAME RRSIG, 3847| | * use it, otherwise change sigtype 3848| | * so that we find it. 3849| | */ 3850| 0| if (cnamesig != NULL) { ------------------ | Branch (3850:10): [True: 0, False: 0] ------------------ 3851| 0| foundsig = cnamesig; 3852| 0| } else { 3853| 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)) | | ------------------ ------------------ 3854| 0| dns_rdatatype_cname); 3855| 0| } 3856| 0| } 3857| | /* 3858| | * If we've got all we need, end the search. 3859| | */ 3860| 117| if (!maybe_zonecut && foundsig != NULL) { ------------------ | Branch (3860:9): [True: 117, False: 0] | Branch (3860:27): [True: 0, False: 117] ------------------ 3861| 0| break; 3862| 0| } 3863| 234| } else if (top->typepair == sigpair) { ------------------ | Branch (3863:15): [True: 0, False: 234] ------------------ 3864| | /* 3865| | * We've found the RRSIG rdataset for our 3866| | * target type. Remember it. 3867| | */ 3868| 0| foundsig = header; 3869| | /* 3870| | * If we've got all we need, end the search. 3871| | */ 3872| 0| if (!maybe_zonecut && found != NULL) { ------------------ | Branch (3872:9): [True: 0, False: 0] | Branch (3872:27): [True: 0, False: 0] ------------------ 3873| 0| break; 3874| 0| } 3875| 234| } else if (top->typepair == ------------------ | Branch (3875:15): [True: 0, False: 234] ------------------ 3876| 234| DNS_TYPEPAIR(dns_rdatatype_nsec) && ------------------ | | 51| 234|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 468| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 468| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3877| 0| !search.version->havensec3) ------------------ | Branch (3877:8): [True: 0, False: 0] ------------------ 3878| 0| { 3879| | /* 3880| | * Remember a NSEC rdataset even if we're 3881| | * not specifically looking for it, because 3882| | * we might need it later. 3883| | */ 3884| 0| nsecheader = header; 3885| 234| } else if (top->typepair == ------------------ | Branch (3885:15): [True: 0, False: 234] ------------------ 3886| 234| DNS_SIGTYPEPAIR( ------------------ | | 52| 234|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 468| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 468| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3887| 0| dns_rdatatype_nsec) && 3888| 0| !search.version->havensec3) ------------------ | Branch (3888:8): [True: 0, False: 0] ------------------ 3889| 0| { 3890| | /* 3891| | * If we need the NSEC rdataset, we'll also 3892| | * need its signature. 3893| | */ 3894| 0| nsecsig = header; 3895| 234| } else if (cname_ok && ------------------ | Branch (3895:15): [True: 234, False: 0] ------------------ 3896| 234| top->typepair == ------------------ | Branch (3896:8): [True: 0, False: 234] ------------------ 3897| 234| DNS_SIGTYPEPAIR(dns_rdatatype_cname)) ------------------ | | 52| 234|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 234| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 234| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3898| 0| { 3899| | /* 3900| | * If we get a CNAME match, we'll also need 3901| | * its signature. 3902| | */ 3903| 0| cnamesig = header; 3904| 0| } 3905| 351| } 3906| 351| } 3907| | 3908| 117| if (empty_node) { ------------------ | Branch (3908:6): [True: 0, False: 117] ------------------ 3909| | /* 3910| | * We have an exact match for the name, but there are no 3911| | * active rdatasets in the desired version. That means that 3912| | * this node doesn't exist in the desired version. 3913| | * If there's a node above this one, reassign the 3914| | * foundname to the parent and treat this as a partial 3915| | * match. 3916| | */ 3917| 0| if (!wild) { ------------------ | Branch (3917:7): [True: 0, False: 0] ------------------ 3918| 0| unsigned int len = search.chain.len - 1; 3919| 0| if (len > search.chain_base) { ------------------ | Branch (3919:8): [True: 0, False: 0] ------------------ 3920| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3921| 0| dns_qpchain_node(&search.chain, len - 1, 3922| 0| (void **)&node, NULL); 3923| 0| dns_name_copy(&node->name, foundname); ------------------ | | 1525| 0| dns_name__copy(DNS_NAME__RO_ARG(source), dest) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 3924| 0| goto partial_match; 3925| 0| } 3926| 0| } 3927| 0| } 3928| | 3929| | /* 3930| | * If we didn't find what we were looking for... 3931| | */ 3932| 117| if (found == NULL) { ------------------ | Branch (3932:6): [True: 0, False: 117] ------------------ 3933| 0| if (search.zonecut != NULL) { ------------------ | Branch (3933:7): [True: 0, False: 0] ------------------ 3934| | /* 3935| | * We were trying to find glue at a node beneath a 3936| | * zone cut, but didn't. 3937| | * 3938| | * Return the delegation. 3939| | */ 3940| 0| if (wild) { ------------------ | Branch (3940:8): [True: 0, False: 0] ------------------ 3941| 0| foundname->attributes.wildcard = true; 3942| 0| } 3943| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3944| 0| result = qpzone_setup_delegation( 3945| 0| &search, foundname, rdataset, 3946| 0| sigrdataset DNS__DB_FLARG_PASS); 3947| 0| goto tree_exit; 3948| 0| } 3949| | /* 3950| | * The desired type doesn't exist. 3951| | */ 3952| 0| result = DNS_R_NXRRSET; 3953| 0| if (search.version->secure && !search.version->havensec3 && ------------------ | Branch (3953:7): [True: 0, False: 0] | Branch (3953:33): [True: 0, False: 0] ------------------ 3954| 0| (nsecheader == NULL || nsecsig == NULL)) ------------------ | Branch (3954:8): [True: 0, False: 0] | Branch (3954:30): [True: 0, False: 0] ------------------ 3955| 0| { 3956| | /* 3957| | * The zone is secure but there's no NSEC, 3958| | * or the NSEC has no signature! 3959| | */ 3960| 0| if (!wild) { ------------------ | Branch (3960:8): [True: 0, False: 0] ------------------ 3961| 0| result = DNS_R_BADDB; 3962| 0| goto node_exit; 3963| 0| } 3964| | 3965| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 3966| 0| result = find_closest_nsec( 3967| 0| &search, foundname, rdataset, sigrdataset, 3968| 0| false, 3969| 0| search.version->secure DNS__DB_FLARG_PASS); 3970| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3970:8): [True: 0, False: 0] ------------------ 3971| 0| result = DNS_R_EMPTYWILD; 3972| 0| } 3973| 0| goto tree_exit; 3974| 0| } 3975| 0| if (search.version->secure && !search.version->havensec3) { ------------------ | Branch (3975:7): [True: 0, False: 0] | Branch (3975:33): [True: 0, False: 0] ------------------ 3976| 0| bindrdataset(search.qpdb, nsecheader, 3977| 0| rdataset DNS__DB_FLARG_PASS); 3978| 0| if (nsecsig != NULL) { ------------------ | Branch (3978:8): [True: 0, False: 0] ------------------ 3979| 0| bindrdataset(search.qpdb, nsecsig, 3980| 0| sigrdataset DNS__DB_FLARG_PASS); 3981| 0| } 3982| 0| } 3983| 0| if (wild) { ------------------ | Branch (3983:7): [True: 0, False: 0] ------------------ 3984| 0| foundname->attributes.wildcard = true; 3985| 0| } 3986| 0| goto node_exit; 3987| 0| } 3988| | 3989| | /* 3990| | * We found what we were looking for, or we found a CNAME. 3991| | */ 3992| 117| if (type != found->typepair && type != dns_rdatatype_any && ------------------ | | 206| 117|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (3992:6): [True: 0, False: 117] | Branch (3992:33): [True: 0, False: 0] ------------------ 3993| 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 (3993:6): [True: 0, False: 0] ------------------ 3994| 0| { 3995| | /* 3996| | * We weren't doing an ANY query and we found a CNAME instead 3997| | * of the type we were looking for, so we need to indicate 3998| | * that result to the caller. 3999| | */ 4000| 0| result = DNS_R_CNAME; 4001| 117| } else if (search.zonecut != NULL) { ------------------ | Branch (4001:13): [True: 0, False: 117] ------------------ 4002| | /* 4003| | * If we're beneath a zone cut, we must indicate that the 4004| | * result is glue, unless we're actually at the zone cut 4005| | * and the type is NSEC. 4006| | */ 4007| 0| if (search.zonecut == node) { ------------------ | Branch (4007:7): [True: 0, False: 0] ------------------ 4008| 0| if (dns_rdatatype_isnsec(type)) { ------------------ | Branch (4008:8): [True: 0, False: 0] ------------------ 4009| 0| result = ISC_R_SUCCESS; 4010| 0| } else if (type == dns_rdatatype_any) { ------------------ | | 206| 0|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (4010:15): [True: 0, False: 0] ------------------ 4011| 0| result = DNS_R_ZONECUT; 4012| 0| } else { 4013| 0| result = DNS_R_GLUE; 4014| 0| } 4015| 0| } else { 4016| 0| result = DNS_R_GLUE; 4017| 0| } 4018| 117| } else { 4019| | /* 4020| | * An ordinary successful query! 4021| | */ 4022| 117| result = ISC_R_SUCCESS; 4023| 117| } 4024| | 4025| 117| if (type != dns_rdatatype_any) { ------------------ | | 206| 117|#define dns_rdatatype_any ((dns_rdatatype_t)dns_rdatatype_any) ------------------ | Branch (4025:6): [True: 117, False: 0] ------------------ 4026| 117| bindrdataset(search.qpdb, found, rdataset DNS__DB_FLARG_PASS); 4027| 117| if (foundsig != NULL) { ------------------ | Branch (4027:7): [True: 0, False: 117] ------------------ 4028| 0| bindrdataset(search.qpdb, foundsig, 4029| 0| sigrdataset DNS__DB_FLARG_PASS); 4030| 0| } 4031| 117| } 4032| | 4033| 117| if (wild) { ------------------ | Branch (4033:6): [True: 0, False: 117] ------------------ 4034| 0| foundname->attributes.wildcard = true; 4035| 0| } 4036| | 4037| 117|node_exit: 4038| 117| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 117| { \ | | 38| 117| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 117| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 117| { \ | | | | 39| 117| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 117| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 117| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 117| { \ | | | | | | 283| 117| switch (type) { \ | | | | | | 284| 117| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 117, False: 0] | | | | | | ------------------ | | | | | | 285| 117| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 117| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 117] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 117] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 117| } \ | | | | | | 293| 117| } | | | | ------------------ | | | | 42| 117| } | | ------------------ | | 40| 117| *tp = isc_rwlocktype_none; \ | | 41| 117| } ------------------ 4039| | 4040| 208|tree_exit: 4041| 208| dns_qpread_destroy(qpdb->tree, &search.qpr); 4042| | 4043| | /* 4044| | * If we found a zonecut but aren't going to use it, we have to 4045| | * let go of it. 4046| | */ 4047| 208| if (search.zonecut != NULL) { ------------------ | Branch (4047:6): [True: 0, False: 208] ------------------ 4048| 0| node = search.zonecut; 4049| 0| INSIST(node != NULL); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4050| 0| nlock = qpzone_get_lock(node); 4051| | 4052| 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() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 4053| 0| (void)qpznode_release(node DNS__DB_FLARG_PASS); 4054| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ | | 40| 0| *tp = isc_rwlocktype_none; \ | | 41| 0| } ------------------ 4055| 0| } 4056| | 4057| 208| if (close_version) { ------------------ | Branch (4057:6): [True: 208, False: 0] ------------------ 4058| 208| closeversion(db, &version, false DNS__DB_FLARG_PASS); 4059| 208| } 4060| | 4061| 208| return result; 4062| 208|} qpzone.c:qpz_search_init: 3513| 208| unsigned int options) { 3514| | /* 3515| | * qpz_search_t contains two structures with large buffers (dns_qpiter_t 3516| | * and dns_qpchain_t). Those two structures will be initialized later by 3517| | * dns_qp_lookup anyway. 3518| | * To avoid the overhead of zero initialization, we avoid designated 3519| | * initializers and initialize all "small" fields manually. 3520| | */ 3521| 208| search->qpdb = db; 3522| 208| search->version = version; 3523| 208| search->qpr = (dns_qpread_t){}; 3524| 208| search->serial = version->serial; 3525| 208| search->options = options; 3526| | /* 3527| | * qpch->in -- init in dns_qp_lookup 3528| | * qpiter -- init in dns_qp_lookup 3529| | */ 3530| 208| search->chain_base = 0; 3531| 208| search->copy_name = false; 3532| 208| search->wild = false; 3533| 208| search->zonecut = NULL; 3534| 208| search->zonecut_header = NULL; 3535| | search->zonecut_sigheader = NULL; 3536| 208| dns_fixedname_init(&search->zonecut_name); 3537| 208|} qpzone.c:qpz_search_setbase: 3553| 208|qpz_search_setbase(qpz_search_t *search, qpznode_t *origin) { 3554| 208| unsigned int len = dns_qpchain_length(&search->chain); 3555| | 3556| 208| for (unsigned int i = 0; i < len; i++) { ------------------ | Branch (3556:27): [True: 208, False: 0] ------------------ 3557| 208| qpznode_t *node = NULL; 3558| | 3559| 208| dns_qpchain_node(&search->chain, i, (void **)&node, NULL); 3560| 208| if (node == origin) { ------------------ | Branch (3560:7): [True: 208, False: 0] ------------------ 3561| 208| search->chain_base = i; 3562| 208| return true; 3563| 208| } 3564| 208| } 3565| | 3566| 0| return false; 3567| 208|} qpzone.c:qpzone_check_zonecut: 3397| 91|qpzone_check_zonecut(qpznode_t *node, void *arg DNS__DB_FLARG) { 3398| 91| qpz_search_t *search = arg; 3399| 91| dns_vecheader_t *dname_header = NULL, *sigdname_header = NULL; 3400| 91| dns_vecheader_t *ns_header = NULL; 3401| 91| dns_vecheader_t *found = NULL; 3402| 91| isc_result_t result = DNS_R_CONTINUE; 3403| 91| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 3404| 91| isc_rwlock_t *nlock = qpzone_get_lock(node); 3405| | 3406| 91| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 91|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 91| { \ | | | | 32| 91| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 91| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 91| { \ | | | | | | 31| 91| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 91| (t), __FILE__, __LINE__)); \ | | | | | | 33| 91| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 91| { \ | | | | | | | | 253| 91| switch (type) { \ | | | | | | | | 254| 91| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 91, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 91| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 91| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 91] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 91] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 91| } \ | | | | | | | | 263| 91| } | | | | | | ------------------ | | | | | | 34| 91| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 91| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 91| } | | | | ------------------ | | | | 34| 91| *tp = t; \ | | | | 35| 91| } | | ------------------ ------------------ 3407| | 3408| | /* 3409| | * Look for an NS or DNAME rdataset active in our version. 3410| | */ 3411| 273| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 91| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 91| for (typeof(first) elt = first, \ | | | | 64| 91| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL; \ | | | | ------------------ | | | | | | 59| 91|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (64:20): [True: 91, False: 0] | | | | ------------------ | | | | 65| 364| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 273, False: 91] | | | | ------------------ | | | | 66| 273| elt = elt##_next, \ | | | | 67| 273| elt##_next = (elt != NULL) ? ISC_SLIST_NEXT(elt, link) : NULL) | | | | ------------------ | | | | | | 59| 182|#define ISC_SLIST_NEXT(elt, link) ((elt)->link.next) | | | | ------------------ | | | | | Branch (67:21): [True: 182, False: 91] | | | | ------------------ | | ------------------ ------------------ 3412| 273| if (top->typepair == DNS_TYPEPAIR(dns_rdatatype_ns) || ------------------ | | 51| 273|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 546| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 546| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3412:7): [True: 91, False: 182] ------------------ 3413| 273| top->typepair == DNS_TYPEPAIR(dns_rdatatype_dname) || ------------------ | | 51| 182|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 455| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 455| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3413:7): [True: 0, False: 182] ------------------ 3414| 182| top->typepair == DNS_SIGTYPEPAIR(dns_rdatatype_dname)) ------------------ | | 52| 182|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 182| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 182| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ | Branch (3414:7): [True: 0, False: 182] ------------------ 3415| 91| { 3416| 91| dns_vecheader_t *header = 3417| 91| first_existing_header(top, search->serial); 3418| 91| if (header != NULL) { ------------------ | Branch (3418:8): [True: 91, False: 0] ------------------ 3419| 91| if (top->typepair == ------------------ | Branch (3419:9): [True: 0, False: 91] ------------------ 3420| 91| DNS_TYPEPAIR(dns_rdatatype_dname)) ------------------ | | 51| 91|#define DNS_TYPEPAIR(type) DNS__TYPEPAIR_VALUE(type, dns_rdatatype_none) | | ------------------ | | | | 43| 91| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 91| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3421| 0| { 3422| 0| dname_header = header; 3423| 91| } else if (top->typepair == ------------------ | Branch (3423:16): [True: 0, False: 91] ------------------ 3424| 91| DNS_SIGTYPEPAIR(dns_rdatatype_dname)) ------------------ | | 52| 91|#define DNS_SIGTYPEPAIR(type) DNS__TYPEPAIR_VALUE(dns_rdatatype_rrsig, type) | | ------------------ | | | | 43| 91| ((dns_typepair_t)(((uint32_t)covers) << 16) | \ | | | | 44| 91| (((uint32_t)base) & 0xffff)) | | ------------------ ------------------ 3425| 0| { 3426| 0| sigdname_header = header; 3427| 91| } else if (node != search->qpdb->origin || ------------------ | Branch (3427:16): [True: 0, False: 91] ------------------ 3428| 91| IS_STUB(search->qpdb)) ------------------ | | 84| 91|#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0) | | ------------------ | | | Branch (84:22): [True: 0, False: 91] | | ------------------ ------------------ 3429| 0| { 3430| | /* 3431| | * We've found an NS rdataset that 3432| | * isn't at the origin node. 3433| | */ 3434| 0| ns_header = header; 3435| 0| } 3436| 91| } 3437| 91| } 3438| 273| } 3439| | 3440| | /* 3441| | * Did we find anything? 3442| | */ 3443| 91| if (!IS_STUB(search->qpdb) && ns_header != NULL) { ------------------ | | 84| 182|#define IS_STUB(db) (((db)->common.attributes & DNS_DBATTR_STUB) != 0) ------------------ | Branch (3443:6): [True: 91, False: 0] | Branch (3443:32): [True: 0, False: 91] ------------------ 3444| | /* 3445| | * Note that NS has precedence over DNAME if both exist 3446| | * in a zone. Otherwise DNAME take precedence over NS. 3447| | */ 3448| 0| found = ns_header; 3449| 0| search->zonecut_sigheader = NULL; 3450| 91| } else if (dname_header != NULL) { ------------------ | Branch (3450:13): [True: 0, False: 91] ------------------ 3451| 0| found = dname_header; 3452| 0| search->zonecut_sigheader = sigdname_header; 3453| 91| } else if (ns_header != NULL) { ------------------ | Branch (3453:13): [True: 0, False: 91] ------------------ 3454| 0| found = ns_header; 3455| 0| search->zonecut_sigheader = NULL; 3456| 0| } 3457| | 3458| 91| if (found != NULL) { ------------------ | Branch (3458:6): [True: 0, False: 91] ------------------ 3459| | /* 3460| | * We increment the reference count on node to ensure that 3461| | * search->zonecut_header will still be valid later. 3462| | */ 3463| 0| qpznode_acquire(node DNS__DB_FLARG_PASS); 3464| 0| search->zonecut = node; 3465| 0| search->zonecut_header = found; 3466| | /* 3467| | * Since we've found a zonecut, anything beneath it is 3468| | * glue and is not subject to wildcard matching, so we 3469| | * may clear search->wild. 3470| | */ 3471| 0| search->wild = false; 3472| 0| if ((search->options & DNS_DBFIND_GLUEOK) == 0) { ------------------ | Branch (3472:7): [True: 0, False: 0] ------------------ 3473| | /* 3474| | * If the caller does not want to find glue, then 3475| | * this is the best answer and the search should 3476| | * stop now. 3477| | */ 3478| 0| result = DNS_R_PARTIALMATCH; 3479| 0| } else { 3480| 0| dns_name_t *zcname = NULL; 3481| | 3482| | /* 3483| | * The search will continue beneath the zone cut. 3484| | * This may or may not be the best match. In case it 3485| | * is, we need to remember the node name. 3486| | */ 3487| 0| zcname = dns_name(&search->zonecut_name); ------------------ | | 1515| 0|#define dns_name(source) DNS_NAME__RO_ARG(source) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 3488| 0| dns_name_copy(&node->name, zcname); ------------------ | | 1525| 0| dns_name__copy(DNS_NAME__RO_ARG(source), dest) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 3489| 0| search->copy_name = true; 3490| 0| } 3491| 91| } else { 3492| | /* 3493| | * There is no zonecut at this node which is active in this 3494| | * version. 3495| | * 3496| | * If this is a "wild" node and the caller hasn't disabled 3497| | * wildcard matching, remember that we've seen a wild node 3498| | * in case we need to go searching for wildcard matches 3499| | * later on. 3500| | */ 3501| 91| if (node->wild && (search->options & DNS_DBFIND_NOWILD) == 0) { ------------------ | Branch (3501:7): [True: 0, False: 91] | Branch (3501:21): [True: 0, False: 0] ------------------ 3502| 0| search->wild = true; 3503| 0| } 3504| 91| } 3505| | 3506| 91| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 91| { \ | | 38| 91| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 91| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 91| { \ | | | | 39| 91| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 91| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 91| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 91| { \ | | | | | | 283| 91| switch (type) { \ | | | | | | 284| 91| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 91, False: 0] | | | | | | ------------------ | | | | | | 285| 91| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 91| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 91] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 91] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 91| } \ | | | | | | 293| 91| } | | | | ------------------ | | | | 42| 91| } | | ------------------ | | 40| 91| *tp = isc_rwlocktype_none; \ | | 41| 91| } ------------------ 3507| | 3508| 91| return result; 3509| 91|} qpzone.c:step: 2839| 91| qpznode_t **node_p) { 2840| 91| REQUIRE(node_p != NULL && *node_p == NULL); ------------------ | | 198| 91|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 182| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 91, False: 0] | | | | | Branch (41:11): [True: 91, False: 0] | | | | ------------------ | | | | 42| 91| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2841| | 2842| 91| qpznode_t *node = NULL, *previous_node = NULL; 2843| 91| isc_result_t result = ISC_R_SUCCESS; 2844| | 2845| 91| result = dns_qpiter_current(it, (void **)&node, NULL); 2846| 273| while (result == ISC_R_SUCCESS) { ------------------ | Branch (2846:9): [True: 182, False: 91] ------------------ 2847| 182| previous_node = node; 2848| | 2849| 182| isc_rwlock_t *nlock = qpzone_get_lock(node); 2850| 182| isc_rwlocktype_t nlocktype = isc_rwlocktype_none; 2851| 182| dns_vecheader_t *found = NULL; 2852| | 2853| 182| NODE_RDLOCK(nlock, &nlocktype); ------------------ | | 42| 182|#define NODE_RDLOCK(l, tp) NODE_LOCK(l, isc_rwlocktype_read, tp); | | ------------------ | | | | 31| 182| { \ | | | | 32| 182| STRONG_RWLOCK_CHECK(*tp == isc_rwlocktype_none); \ | | | | 33| 182| RWLOCK((l), (t)); \ | | | | ------------------ | | | | | | 30| 182| { \ | | | | | | 31| 182| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | | | 32| 182| (t), __FILE__, __LINE__)); \ | | | | | | 33| 182| isc_rwlock_lock((lp), (t)); \ | | | | | | ------------------ | | | | | | | | 252| 182| { \ | | | | | | | | 253| 182| switch (type) { \ | | | | | | | | 254| 182| case isc_rwlocktype_read: \ | | | | | | | | ------------------ | | | | | | | | | Branch (254:3): [True: 182, False: 0] | | | | | | | | ------------------ | | | | | | | | 255| 182| isc_rwlock_rdlock(rwl); \ | | | | | | | | 256| 182| break; \ | | | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | | | ------------------ | | | | | | | | | Branch (257:3): [True: 0, False: 182] | | | | | | | | ------------------ | | | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | | | 259| 0| break; \ | | | | | | | | 260| 0| default: \ | | | | | | | | ------------------ | | | | | | | | | Branch (260:3): [True: 0, False: 182] | | | | | | | | ------------------ | | | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | | | ------------------ | | | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | | | ------------------ | | | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 262| 182| } \ | | | | | | | | 263| 182| } | | | | | | ------------------ | | | | | | 34| 182| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | | | 35| 182| (lp), (t), __FILE__, __LINE__)); \ | | | | | | 36| 182| } | | | | ------------------ | | | | 34| 182| *tp = t; \ | | | | 35| 182| } | | ------------------ ------------------ 2854| 182| ISC_SLIST_FOREACH(top, node->next_type, next_type) { ------------------ | | 70| 182| ISC_SLIST_FOREACH_FROM(elt, list, link, ISC_SLIST_HEAD(list)) | | ------------------ | | | | 63| 182| for (typeof(first) elt = first, \ | | | | 64| 182| 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: 182] | | | | ------------------ | | | | 65| 182| elt != NULL; \ | | | | ------------------ | | | | | Branch (65:7): [True: 0, False: 182] | | | | ------------------ | | | | 66| 182| 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] | | | | ------------------ | | ------------------ ------------------ 2855| 0| found = first_existing_header(top, search->serial); 2856| 0| } 2857| 182| NODE_UNLOCK(nlock, &nlocktype); ------------------ | | 37| 182| { \ | | 38| 182| STRONG_RWLOCK_CHECK(*tp != isc_rwlocktype_none); \ | | 39| 182| RWUNLOCK(l, *tp); \ | | ------------------ | | | | 38| 182| { \ | | | | 39| 182| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 182| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 182| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 182| { \ | | | | | | 283| 182| switch (type) { \ | | | | | | 284| 182| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 182, False: 0] | | | | | | ------------------ | | | | | | 285| 182| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 182| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 182] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 182] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 182| } \ | | | | | | 293| 182| } | | | | ------------------ | | | | 42| 182| } | | ------------------ | | 40| 182| *tp = isc_rwlocktype_none; \ | | 41| 182| } ------------------ 2858| 182| if (found != NULL) { ------------------ | Branch (2858:7): [True: 0, False: 182] ------------------ 2859| 0| break; 2860| 0| } 2861| | 2862| 182| if (direction == FORWARD) { ------------------ | Branch (2862:7): [True: 182, False: 0] ------------------ 2863| 182| result = dns_qpiter_next(it, (void **)&node, NULL); 2864| 182| } else { 2865| 0| result = dns_qpiter_prev(it, (void **)&node, NULL); 2866| 0| } 2867| 182| }; 2868| | 2869| 91| if (result == ISC_R_SUCCESS) { ------------------ | Branch (2869:6): [True: 0, False: 91] ------------------ 2870| 0| if (previous_node != NULL) { ------------------ | Branch (2870:7): [True: 0, False: 0] ------------------ 2871| 0| *node_p = previous_node; 2872| 0| } 2873| 0| return true; 2874| 0| } 2875| | 2876| 91| return false; 2877| 91|} qpzone.c:activeempty: 2880| 91|activeempty(qpz_search_t *search, dns_qpiter_t *it, const dns_name_t *current) { 2881| 91| qpznode_t *next_node = NULL; 2882| | 2883| | /* 2884| | * The iterator is currently pointed at the predecessor 2885| | * of the name we were searching for. Step the iterator 2886| | * forward, then step() will continue forward until it 2887| | * finds a node with active data. If that node is a 2888| | * subdomain of the one we were looking for, then we're 2889| | * at an active empty nonterminal node. 2890| | */ 2891| 91| isc_result_t result = dns_qpiter_next(it, NULL, NULL); 2892| 91| if (result != ISC_R_SUCCESS) { ------------------ | Branch (2892:6): [True: 0, False: 91] ------------------ 2893| | /* An ENT at the end of the zone is impossible */ 2894| 0| return false; 2895| 0| } 2896| 91| return step(search, it, FORWARD, &next_node) && ------------------ | Branch (2896:9): [True: 0, False: 91] ------------------ 2897| 0| dns_name_issubdomain(&next_node->name, current); ------------------ | | 1544| 91| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1544:2): [True: 0, False: 0] | | ------------------ ------------------ 2898| 91|} qpzone.c:setgluecachestats: 2604| 2|setgluecachestats(dns_db_t *db, isc_stats_t *stats) { 2605| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 2606| | 2607| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2608| 2| REQUIRE(!IS_STUB(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2609| 2| REQUIRE(stats != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2610| | 2611| 2| isc_stats_attach(stats, &qpdb->gluecachestats); 2612| 2| return ISC_R_SUCCESS; 2613| 2|} qpzone.c:setmaxrrperset: 5591| 2|setmaxrrperset(dns_db_t *db, uint32_t value) { 5592| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 5593| | 5594| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 5595| | 5596| 2| qpdb->maxrrperset = value; 5597| 2|} qpzone.c:setmaxtypepername: 5600| 2|setmaxtypepername(dns_db_t *db, uint32_t value) { 5601| 2| qpzonedb_t *qpdb = (qpzonedb_t *)db; 5602| | 5603| 2| REQUIRE(VALID_QPZONE(qpdb)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 5604| | 5605| 2| qpdb->maxtypepername = value; 5606| 2|} dns_secalg_fromtext: 355| 2|dns_secalg_fromtext(dns_secalg_t *secalgp, isc_textregion_t *source) { 356| 2| unsigned int value; 357| 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| } ------------------ 358| 2| *secalgp = value; 359| 2| return ISC_R_SUCCESS; 360| 2|} dns_secproto_fromtext: 382| 2|dns_secproto_fromtext(dns_secproto_t *secprotop, isc_textregion_t *source) { 383| 2| unsigned int value; 384| 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| } ------------------ 385| 2| *secprotop = value; 386| 2| return ISC_R_SUCCESS; 387| 2|} dns_keyflags_fromtext: 403| 2|dns_keyflags_fromtext(dns_keyflags_t *flagsp, isc_textregion_t *source) { 404| 2| isc_result_t result; 405| 2| char *text, *end; 406| 2| unsigned int value = 0; 407| |#ifdef notyet 408| | unsigned int mask = 0; 409| |#endif /* ifdef notyet */ 410| | 411| 2| result = maybe_numeric(&value, source, 0xffff, true); 412| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (412:6): [True: 2, False: 0] ------------------ 413| 2| *flagsp = value; 414| 2| return ISC_R_SUCCESS; 415| 2| } 416| 0| if (result != ISC_R_BADNUMBER) { ------------------ | Branch (416:6): [True: 0, False: 0] ------------------ 417| 0| return result; 418| 0| } 419| | 420| 0| text = source->base; 421| 0| end = source->base + source->length; 422| | 423| 0| while (text < end) { ------------------ | Branch (423:9): [True: 0, False: 0] ------------------ 424| 0| struct keyflag *p; 425| 0| unsigned int len; 426| 0| char *delim = memchr(text, '|', end - text); 427| 0| if (delim != NULL) { ------------------ | Branch (427:7): [True: 0, False: 0] ------------------ 428| 0| len = (unsigned int)(delim - text); 429| 0| } else { 430| 0| len = (unsigned int)(end - text); 431| 0| } 432| 0| for (p = keyflags; p->name != NULL; p++) { ------------------ | Branch (432:22): [True: 0, False: 0] ------------------ 433| 0| if (strncasecmp(p->name, text, len) == 0) { ------------------ | Branch (433:8): [True: 0, False: 0] ------------------ 434| 0| break; 435| 0| } 436| 0| } 437| 0| if (p->name == NULL) { ------------------ | Branch (437:7): [True: 0, False: 0] ------------------ 438| 0| return DNS_R_UNKNOWNFLAG; 439| 0| } 440| 0| value |= p->value; 441| |#ifdef notyet 442| | if ((mask & p->mask) != 0) { 443| | warn("overlapping key flags"); 444| | } 445| | mask |= p->mask; 446| |#endif /* ifdef notyet */ 447| 0| text += len; 448| 0| if (delim != NULL) { ------------------ | Branch (448:7): [True: 0, False: 0] ------------------ 449| 0| text++; /* Skip "|" */ 450| 0| } 451| 0| } 452| 0| *flagsp = value; 453| 0| return ISC_R_SUCCESS; 454| 0|} dns_rdataclass_fromtext: 525| 12|dns_rdataclass_fromtext(dns_rdataclass_t *classp, isc_textregion_t *source) { 526| 12|#define COMPARE(string, rdclass) \ 527| 12| if (((sizeof(string) - 1) == source->length) && \ 528| 12| (strncasecmp(source->base, string, source->length) == 0)) \ 529| 12| { \ 530| 12| *classp = rdclass; \ 531| 12| return (ISC_R_SUCCESS); \ 532| 12| } 533| | 534| 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] | | ------------------ ------------------ 535| 0| case 'a': ------------------ | Branch (535:2): [True: 0, False: 12] ------------------ 536| 0| COMPARE("any", dns_rdataclass_any); ------------------ | | 527| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 0, False: 0] | | ------------------ | | 528| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 0, False: 0] | | ------------------ | | 529| 0| { \ | | 530| 0| *classp = rdclass; \ | | 531| 0| return (ISC_R_SUCCESS); \ | | 532| 0| } ------------------ 537| 0| break; 538| 0| case 'c': ------------------ | Branch (538:2): [True: 0, False: 12] ------------------ 539| | /* 540| | * RFC1035 says the mnemonic for the CHAOS class is CH, 541| | * but historical BIND practice is to call it CHAOS. 542| | * We will accept both forms, but only generate CH. 543| | */ 544| 0| COMPARE("ch", dns_rdataclass_chaos); ------------------ | | 527| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 0, False: 0] | | ------------------ | | 528| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 0, False: 0] | | ------------------ | | 529| 0| { \ | | 530| 0| *classp = rdclass; \ | | 531| 0| return (ISC_R_SUCCESS); \ | | 532| 0| } ------------------ 545| 0| COMPARE("chaos", dns_rdataclass_chaos); ------------------ | | 527| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 0, False: 0] | | ------------------ | | 528| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 0, False: 0] | | ------------------ | | 529| 0| { \ | | 530| 0| *classp = rdclass; \ | | 531| 0| return (ISC_R_SUCCESS); \ | | 532| 0| } ------------------ 546| | 547| 0| if (source->length > 5 && ------------------ | Branch (547:7): [True: 0, False: 0] ------------------ 548| 0| source->length < (5 + sizeof("65000")) && ------------------ | Branch (548:7): [True: 0, False: 0] ------------------ 549| 0| strncasecmp("class", source->base, 5) == 0) ------------------ | Branch (549:7): [True: 0, False: 0] ------------------ 550| 0| { 551| 0| char buf[sizeof("65000")]; 552| 0| char *endp; 553| 0| unsigned int val; 554| | 555| | /* 556| | * source->base is not required to be NUL terminated. 557| | * Copy up to remaining bytes and NUL terminate. 558| | */ 559| 0| snprintf(buf, sizeof(buf), "%.*s", 560| 0| (int)(source->length - 5), source->base + 5); 561| 0| val = strtoul(buf, &endp, 10); 562| 0| if (*endp == '\0' && val <= 0xffff) { ------------------ | Branch (562:8): [True: 0, False: 0] | Branch (562:25): [True: 0, False: 0] ------------------ 563| 0| *classp = (dns_rdataclass_t)val; 564| 0| return ISC_R_SUCCESS; 565| 0| } 566| 0| } 567| 0| break; 568| 0| case 'h': ------------------ | Branch (568:2): [True: 0, False: 12] ------------------ 569| 0| COMPARE("hs", dns_rdataclass_hs); ------------------ | | 527| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 0, False: 0] | | ------------------ | | 528| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 0, False: 0] | | ------------------ | | 529| 0| { \ | | 530| 0| *classp = rdclass; \ | | 531| 0| return (ISC_R_SUCCESS); \ | | 532| 0| } ------------------ 570| 0| COMPARE("hesiod", dns_rdataclass_hs); ------------------ | | 527| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 0, False: 0] | | ------------------ | | 528| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 0, False: 0] | | ------------------ | | 529| 0| { \ | | 530| 0| *classp = rdclass; \ | | 531| 0| return (ISC_R_SUCCESS); \ | | 532| 0| } ------------------ 571| 0| break; 572| 6| case 'i': ------------------ | Branch (572:2): [True: 6, False: 6] ------------------ 573| 6| COMPARE("in", dns_rdataclass_in); ------------------ | | 527| 6| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 6, False: 0] | | ------------------ | | 528| 6| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 6, False: 0] | | ------------------ | | 529| 6| { \ | | 530| 6| *classp = rdclass; \ | | 531| 6| return (ISC_R_SUCCESS); \ | | 532| 6| } ------------------ 574| 0| break; 575| 0| case 'n': ------------------ | Branch (575:2): [True: 0, False: 12] ------------------ 576| 0| COMPARE("none", dns_rdataclass_none); ------------------ | | 527| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 0, False: 0] | | ------------------ | | 528| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 0, False: 0] | | ------------------ | | 529| 0| { \ | | 530| 0| *classp = rdclass; \ | | 531| 0| return (ISC_R_SUCCESS); \ | | 532| 0| } ------------------ 577| 0| break; 578| 0| case 'r': ------------------ | Branch (578:2): [True: 0, False: 12] ------------------ 579| 0| COMPARE("reserved0", dns_rdataclass_reserved0); ------------------ | | 527| 0| if (((sizeof(string) - 1) == source->length) && \ | | ------------------ | | | Branch (527:6): [True: 0, False: 0] | | ------------------ | | 528| 0| (strncasecmp(source->base, string, source->length) == 0)) \ | | ------------------ | | | Branch (528:6): [True: 0, False: 0] | | ------------------ | | 529| 0| { \ | | 530| 0| *classp = rdclass; \ | | 531| 0| return (ISC_R_SUCCESS); \ | | 532| 0| } ------------------ 580| 0| break; 581| 12| } 582| | 583| 6|#undef COMPARE 584| | 585| 6| return DNS_R_UNKNOWN; 586| 12|} dns_rdataclass_totext: 589| 2|dns_rdataclass_totext(dns_rdataclass_t rdclass, isc_buffer_t *target) { 590| 2| switch (rdclass) { 591| 0| case dns_rdataclass_any: ------------------ | | 34| 0|#define dns_rdataclass_any ((dns_rdataclass_t)dns_rdataclass_any) ------------------ | Branch (591:2): [True: 0, False: 2] ------------------ 592| 0| return str_totext("ANY", target); 593| 0| case dns_rdataclass_chaos: ------------------ | | 26| 0|#define dns_rdataclass_chaos ((dns_rdataclass_t)dns_rdataclass_chaos) ------------------ | Branch (593:2): [True: 0, False: 2] ------------------ 594| 0| return str_totext("CH", target); 595| 0| case dns_rdataclass_hs: ------------------ | | 30| 0|#define dns_rdataclass_hs ((dns_rdataclass_t)dns_rdataclass_hs) ------------------ | Branch (595:2): [True: 0, False: 2] ------------------ 596| 0| return str_totext("HS", target); 597| 2| case dns_rdataclass_in: ------------------ | | 24| 2|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (597:2): [True: 2, False: 0] ------------------ 598| 2| return str_totext("IN", target); 599| 0| case dns_rdataclass_none: ------------------ | | 32| 0|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ | Branch (599:2): [True: 0, False: 2] ------------------ 600| 0| return str_totext("NONE", target); 601| 0| case dns_rdataclass_reserved0: ------------------ | | 22| 0| ((dns_rdataclass_t)dns_rdataclass_reserved0) ------------------ | Branch (601:2): [True: 0, False: 2] ------------------ 602| 0| return str_totext("RESERVED0", target); 603| 0| default: ------------------ | Branch (603:2): [True: 0, False: 2] ------------------ 604| 0| return dns_rdataclass_tounknowntext(rdclass, target); 605| 2| } 606| 2|} rcode.c:dns_mnemonic_fromtext: 278| 4| struct tbl *table, unsigned int max) { 279| 4| isc_result_t result; 280| 4| int i; 281| | 282| 4| result = maybe_numeric(valuep, source, max, false); 283| 4| if (result != ISC_R_BADNUMBER) { ------------------ | Branch (283:6): [True: 4, False: 0] ------------------ 284| 4| return result; 285| 4| } 286| | 287| 0| for (i = 0; table[i].name != NULL; i++) { ------------------ | Branch (287:14): [True: 0, False: 0] ------------------ 288| 0| unsigned int n; 289| 0| n = strlen(table[i].name); 290| 0| if (n == source->length && (table[i].flags & TOTEXTONLY) == 0 && ------------------ | | 44| 0|#define TOTEXTONLY 0x01 ------------------ | Branch (290:7): [True: 0, False: 0] | Branch (290:30): [True: 0, False: 0] ------------------ 291| 0| strncasecmp(source->base, table[i].name, n) == 0) ------------------ | Branch (291:7): [True: 0, False: 0] ------------------ 292| 0| { 293| 0| *valuep = table[i].value; 294| 0| return ISC_R_SUCCESS; 295| 0| } 296| 0| } 297| 0| return DNS_R_UNKNOWN; 298| 0|} rcode.c:maybe_numeric: 238| 6| bool hex_allowed) { 239| 6| isc_result_t result; 240| 6| uint32_t n; 241| 6| char buffer[NUMBERSIZE]; 242| 6| int v; 243| | 244| 6| if (!isdigit((unsigned char)source->base[0]) || ------------------ | Branch (244:6): [True: 0, False: 6] ------------------ 245| 6| source->length > NUMBERSIZE - 1) ------------------ | | 42| 6|#define NUMBERSIZE sizeof("037777777777") /* 2^32-1 octal + NUL */ ------------------ | Branch (245:6): [True: 0, False: 6] ------------------ 246| 0| { 247| 0| return ISC_R_BADNUMBER; 248| 0| } 249| | 250| | /* 251| | * We have a potential number. Try to parse it with 252| | * isc_parse_uint32(). isc_parse_uint32() requires 253| | * null termination, so we must make a copy. 254| | */ 255| 6| v = snprintf(buffer, sizeof(buffer), "%.*s", (int)source->length, 256| 6| source->base); 257| 6| if (v < 0 || (unsigned int)v != source->length) { ------------------ | Branch (257:6): [True: 0, False: 6] | Branch (257:15): [True: 0, False: 6] ------------------ 258| 0| return ISC_R_BADNUMBER; 259| 0| } 260| 6| INSIST(buffer[source->length] == '\0'); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 261| | 262| 6| result = isc_parse_uint32(&n, buffer, 10); 263| 6| if (result == ISC_R_BADNUMBER && hex_allowed) { ------------------ | Branch (263:6): [True: 0, False: 6] | Branch (263:35): [True: 0, False: 0] ------------------ 264| 0| result = isc_parse_uint32(&n, buffer, 16); 265| 0| } 266| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (266:6): [True: 0, False: 6] ------------------ 267| 0| return result; 268| 0| } 269| 6| if (n > max) { ------------------ | Branch (269:6): [True: 0, False: 6] ------------------ 270| 0| return ISC_R_RANGE; 271| 0| } 272| 6| *valuep = n; 273| 6| return ISC_R_SUCCESS; 274| 6|} rcode.c:str_totext: 220| 2|str_totext(const char *source, isc_buffer_t *target) { 221| 2| unsigned int l; 222| 2| isc_region_t region; 223| | 224| 2| isc_buffer_availableregion(target, ®ion); 225| 2| l = strlen(source); 226| | 227| 2| if (l > region.length) { ------------------ | Branch (227:6): [True: 0, False: 2] ------------------ 228| 0| return ISC_R_NOSPACE; 229| 0| } 230| | 231| 2| memmove(region.base, source, l); 232| 2| isc_buffer_add(target, l); 233| 2| return ISC_R_SUCCESS; 234| 2|} dns_rdata_init: 764| 1.81k|dns_rdata_init(dns_rdata_t *rdata) { 765| 1.81k| REQUIRE(rdata != NULL); ------------------ | | 198| 1.81k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.81k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.81k, False: 0] | | | | ------------------ | | | | 42| 1.81k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 766| | 767| 1.81k| rdata->data = NULL; 768| 1.81k| rdata->length = 0; 769| 1.81k| rdata->rdclass = 0; 770| 1.81k| rdata->type = dns_rdatatype_none; ------------------ | | 115| 1.81k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 771| 1.81k| rdata->flags = 0; 772| 1.81k| ISC_LINK_INIT(rdata, link); ------------------ | | 57| 1.81k|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 1.81k| do { \ | | | | 54| 1.81k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 1.81k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 1.81k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 1.81k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 1.81k| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 1.81k] | | | | ------------------ | | ------------------ ------------------ 773| | /* ISC_LIST_INIT(rdata->list); */ 774| 1.81k|} dns_rdata_reset: 777| 556|dns_rdata_reset(dns_rdata_t *rdata) { 778| 556| REQUIRE(rdata != NULL); ------------------ | | 198| 556|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 556| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 556, False: 0] | | | | ------------------ | | | | 42| 556| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 779| | 780| 556| REQUIRE(!ISC_LINK_LINKED(rdata, link)); ------------------ | | 198| 556|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 556| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 556, False: 0] | | | | ------------------ | | | | 42| 556| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 781| 556| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 556|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 556| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 556, False: 0] | | | | ------------------ | | | | 42| 556| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 782| | 783| 556| rdata->data = NULL; 784| 556| rdata->length = 0; 785| 556| rdata->rdclass = 0; 786| 556| rdata->type = dns_rdatatype_none; ------------------ | | 115| 556|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ 787| 556| rdata->flags = 0; 788| 556|} dns_rdata_clone: 795| 1.25k|dns_rdata_clone(const dns_rdata_t *src, dns_rdata_t *target) { 796| 1.25k| REQUIRE(src != NULL); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 797| 1.25k| REQUIRE(target != NULL); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 798| | 799| 1.25k| REQUIRE(DNS_RDATA_INITIALIZED(target)); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | | Branch (41:11): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 800| | 801| 1.25k| REQUIRE(DNS_RDATA_VALIDFLAGS(src)); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 802| 1.25k| REQUIRE(DNS_RDATA_VALIDFLAGS(target)); ------------------ | | 198| 1.25k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.25k, False: 0] | | | | ------------------ | | | | 42| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 803| | 804| 1.25k| target->data = src->data; 805| 1.25k| target->length = src->length; 806| 1.25k| target->rdclass = src->rdclass; 807| 1.25k| target->type = src->type; 808| 1.25k| target->flags = src->flags; 809| 1.25k|} dns_rdata_fromregion: 887| 1.44k| dns_rdatatype_t type, isc_region_t *r) { 888| 1.44k| REQUIRE(rdata != NULL); ------------------ | | 198| 1.44k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.44k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.44k, False: 0] | | | | ------------------ | | | | 42| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 889| 1.44k| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 198| 1.44k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 14.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | | Branch (41:11): [True: 1.44k, False: 0] | | | | ------------------ | | | | 42| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 890| 1.44k| REQUIRE(r != NULL); ------------------ | | 198| 1.44k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.44k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.44k, False: 0] | | | | ------------------ | | | | 42| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 891| | 892| 1.44k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 1.44k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.44k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.44k, False: 0] | | | | ------------------ | | | | 42| 1.44k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 893| | 894| 1.44k| rdata->data = r->base; 895| 1.44k| rdata->length = r->length; 896| 1.44k| rdata->rdclass = rdclass; 897| 1.44k| rdata->type = type; 898| 1.44k| rdata->flags = 0; 899| 1.44k|} dns_rdata_toregion: 902| 2.07k|dns_rdata_toregion(const dns_rdata_t *rdata, isc_region_t *r) { 903| 2.07k| REQUIRE(rdata != NULL); ------------------ | | 198| 2.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.07k, False: 0] | | | | ------------------ | | | | 42| 2.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 904| 2.07k| REQUIRE(r != NULL); ------------------ | | 198| 2.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.07k, False: 0] | | | | ------------------ | | | | 42| 2.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 905| 2.07k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 2.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.07k, False: 0] | | | | ------------------ | | | | 42| 2.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 906| | 907| 2.07k| r->base = rdata->data; 908| 2.07k| r->length = rdata->length; 909| 2.07k|} dns_rdata_fromwire: 914| 1.92k| dns_decompress_t dctx, isc_buffer_t *target) { 915| 1.92k| isc_result_t result = ISC_R_NOTIMPLEMENTED; 916| 1.92k| isc_region_t region; 917| 1.92k| isc_buffer_t ss; 918| 1.92k| isc_buffer_t st; 919| 1.92k| bool use_default = false; 920| 1.92k| uint32_t activelength; 921| 1.92k| unsigned int length; 922| | 923| 1.92k| if (rdata != NULL) { ------------------ | Branch (923:6): [True: 1.92k, False: 0] ------------------ 924| 1.92k| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 198| 1.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 19.2k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.92k, False: 0] | | | | | Branch (41:11): [True: 1.92k, False: 0] | | | | | Branch (41:11): [True: 1.92k, False: 0] | | | | | Branch (41:11): [True: 1.92k, False: 0] | | | | | Branch (41:11): [True: 1.92k, False: 0] | | | | | Branch (41:11): [True: 1.92k, False: 0] | | | | ------------------ | | | | 42| 1.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 925| 1.92k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 1.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.92k, False: 0] | | | | ------------------ | | | | 42| 1.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 926| 1.92k| } 927| 1.92k| REQUIRE(source != NULL); ------------------ | | 198| 1.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.92k, False: 0] | | | | ------------------ | | | | 42| 1.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 928| 1.92k| REQUIRE(target != NULL); ------------------ | | 198| 1.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.92k, False: 0] | | | | ------------------ | | | | 42| 1.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 929| | 930| 1.92k| if (type == dns_rdatatype_none) { ------------------ | | 115| 1.92k|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (930:6): [True: 0, False: 1.92k] ------------------ 931| 0| return DNS_R_FORMERR; 932| 0| } 933| | 934| 1.92k| ss = *source; 935| 1.92k| st = *target; 936| | 937| 1.92k| activelength = isc_buffer_activelength(source); ------------------ | | 161| 1.92k|#define isc_buffer_activelength(b) ((b)->active - (b)->current) /* c-b */ ------------------ 938| 1.92k| INSIST(activelength < 65536); ------------------ | | 202| 1.92k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 1.92k, False: 0] | | | | ------------------ | | | | 54| 1.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 939| | 940| 1.92k| FROMWIRESWITCH ------------------ | | 440| 1.92k| switch (type) { \ | | 441| 0| case 1: switch (rdclass) { \ | | ------------------ | | | Branch (441:2): [True: 0, False: 1.92k] | | ------------------ | | 442| 0| case 1: result = fromwire_in_a(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (442:3): [True: 0, False: 0] | | ------------------ | | 443| 0| case 3: result = fromwire_ch_a(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (443:3): [True: 0, False: 0] | | ------------------ | | 444| 0| case 4: result = fromwire_hs_a(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (444:3): [True: 0, False: 0] | | ------------------ | | 445| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (445:3): [True: 0, False: 0] | | ------------------ | | 446| 0| } \ | | 447| 0| break; \ | | 448| 0| case 2: result = fromwire_ns(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (448:2): [True: 0, False: 1.92k] | | ------------------ | | 449| 0| case 3: result = fromwire_md(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (449:2): [True: 0, False: 1.92k] | | ------------------ | | 450| 0| case 4: result = fromwire_mf(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (450:2): [True: 0, False: 1.92k] | | ------------------ | | 451| 0| case 5: result = fromwire_cname(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (451:2): [True: 0, False: 1.92k] | | ------------------ | | 452| 0| case 6: result = fromwire_soa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (452:2): [True: 0, False: 1.92k] | | ------------------ | | 453| 0| case 7: result = fromwire_mb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (453:2): [True: 0, False: 1.92k] | | ------------------ | | 454| 0| case 8: result = fromwire_mg(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (454:2): [True: 0, False: 1.92k] | | ------------------ | | 455| 0| case 9: result = fromwire_mr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (455:2): [True: 0, False: 1.92k] | | ------------------ | | 456| 0| case 10: result = fromwire_null(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (456:2): [True: 0, False: 1.92k] | | ------------------ | | 457| 0| case 11: switch (rdclass) { \ | | ------------------ | | | Branch (457:2): [True: 0, False: 1.92k] | | ------------------ | | 458| 0| case 1: result = fromwire_in_wks(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (458:3): [True: 0, False: 0] | | ------------------ | | 459| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (459:3): [True: 0, False: 0] | | ------------------ | | 460| 0| } \ | | 461| 0| break; \ | | 462| 0| case 12: result = fromwire_ptr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (462:2): [True: 0, False: 1.92k] | | ------------------ | | 463| 0| case 13: result = fromwire_hinfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (463:2): [True: 0, False: 1.92k] | | ------------------ | | 464| 0| case 14: result = fromwire_minfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (464:2): [True: 0, False: 1.92k] | | ------------------ | | 465| 0| case 15: result = fromwire_mx(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (465:2): [True: 0, False: 1.92k] | | ------------------ | | 466| 0| case 16: result = fromwire_txt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (466:2): [True: 0, False: 1.92k] | | ------------------ | | 467| 0| case 17: result = fromwire_rp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (467:2): [True: 0, False: 1.92k] | | ------------------ | | 468| 0| case 18: result = fromwire_afsdb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (468:2): [True: 0, False: 1.92k] | | ------------------ | | 469| 0| case 19: result = fromwire_x25(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (469:2): [True: 0, False: 1.92k] | | ------------------ | | 470| 0| case 20: result = fromwire_isdn(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (470:2): [True: 0, False: 1.92k] | | ------------------ | | 471| 0| case 21: result = fromwire_rt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (471:2): [True: 0, False: 1.92k] | | ------------------ | | 472| 0| case 22: switch (rdclass) { \ | | ------------------ | | | Branch (472:2): [True: 0, False: 1.92k] | | ------------------ | | 473| 0| case 1: result = fromwire_in_nsap(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (473:3): [True: 0, False: 0] | | ------------------ | | 474| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (474:3): [True: 0, False: 0] | | ------------------ | | 475| 0| } \ | | 476| 0| break; \ | | 477| 0| case 23: switch (rdclass) { \ | | ------------------ | | | Branch (477:2): [True: 0, False: 1.92k] | | ------------------ | | 478| 0| case 1: result = fromwire_in_nsap_ptr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (478:3): [True: 0, False: 0] | | ------------------ | | 479| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (479:3): [True: 0, False: 0] | | ------------------ | | 480| 0| } \ | | 481| 0| break; \ | | 482| 798| case 24: result = fromwire_sig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (482:2): [True: 798, False: 1.12k] | | ------------------ | | 483| 0| case 25: result = fromwire_key(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (483:2): [True: 0, False: 1.92k] | | ------------------ | | 484| 0| case 26: switch (rdclass) { \ | | ------------------ | | | Branch (484:2): [True: 0, False: 1.92k] | | ------------------ | | 485| 0| case 1: result = fromwire_in_px(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (485:3): [True: 0, False: 0] | | ------------------ | | 486| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (486:3): [True: 0, False: 0] | | ------------------ | | 487| 0| } \ | | 488| 0| break; \ | | 489| 0| case 27: result = fromwire_gpos(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (489:2): [True: 0, False: 1.92k] | | ------------------ | | 490| 0| case 28: switch (rdclass) { \ | | ------------------ | | | Branch (490:2): [True: 0, False: 1.92k] | | ------------------ | | 491| 0| case 1: result = fromwire_in_aaaa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (491:3): [True: 0, False: 0] | | ------------------ | | 492| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (492:3): [True: 0, False: 0] | | ------------------ | | 493| 0| } \ | | 494| 0| break; \ | | 495| 0| case 29: result = fromwire_loc(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (495:2): [True: 0, False: 1.92k] | | ------------------ | | 496| 0| case 30: result = fromwire_nxt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (496:2): [True: 0, False: 1.92k] | | ------------------ | | 497| 0| case 31: switch (rdclass) { \ | | ------------------ | | | Branch (497:2): [True: 0, False: 1.92k] | | ------------------ | | 498| 0| case 1: result = fromwire_in_eid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (498:3): [True: 0, False: 0] | | ------------------ | | 499| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (499:3): [True: 0, False: 0] | | ------------------ | | 500| 0| } \ | | 501| 0| break; \ | | 502| 0| case 32: switch (rdclass) { \ | | ------------------ | | | Branch (502:2): [True: 0, False: 1.92k] | | ------------------ | | 503| 0| case 1: result = fromwire_in_nimloc(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (503:3): [True: 0, False: 0] | | ------------------ | | 504| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (504:3): [True: 0, False: 0] | | ------------------ | | 505| 0| } \ | | 506| 0| break; \ | | 507| 0| case 33: switch (rdclass) { \ | | ------------------ | | | Branch (507:2): [True: 0, False: 1.92k] | | ------------------ | | 508| 0| case 1: result = fromwire_in_srv(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (508:3): [True: 0, False: 0] | | ------------------ | | 509| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (509:3): [True: 0, False: 0] | | ------------------ | | 510| 0| } \ | | 511| 0| break; \ | | 512| 0| case 34: switch (rdclass) { \ | | ------------------ | | | Branch (512:2): [True: 0, False: 1.92k] | | ------------------ | | 513| 0| case 1: result = fromwire_in_atma(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (513:3): [True: 0, False: 0] | | ------------------ | | 514| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (514:3): [True: 0, False: 0] | | ------------------ | | 515| 0| } \ | | 516| 0| break; \ | | 517| 0| case 35: result = fromwire_naptr(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (517:2): [True: 0, False: 1.92k] | | ------------------ | | 518| 0| case 36: switch (rdclass) { \ | | ------------------ | | | Branch (518:2): [True: 0, False: 1.92k] | | ------------------ | | 519| 0| case 1: result = fromwire_in_kx(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (519:3): [True: 0, False: 0] | | ------------------ | | 520| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (520:3): [True: 0, False: 0] | | ------------------ | | 521| 0| } \ | | 522| 0| break; \ | | 523| 0| case 37: result = fromwire_cert(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (523:2): [True: 0, False: 1.92k] | | ------------------ | | 524| 0| case 38: switch (rdclass) { \ | | ------------------ | | | Branch (524:2): [True: 0, False: 1.92k] | | ------------------ | | 525| 0| case 1: result = fromwire_in_a6(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (525:3): [True: 0, False: 0] | | ------------------ | | 526| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (526:3): [True: 0, False: 0] | | ------------------ | | 527| 0| } \ | | 528| 0| break; \ | | 529| 0| case 39: result = fromwire_dname(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (529:2): [True: 0, False: 1.92k] | | ------------------ | | 530| 0| case 40: result = fromwire_sink(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (530:2): [True: 0, False: 1.92k] | | ------------------ | | 531| 0| case 41: result = fromwire_opt(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (531:2): [True: 0, False: 1.92k] | | ------------------ | | 532| 0| case 42: switch (rdclass) { \ | | ------------------ | | | Branch (532:2): [True: 0, False: 1.92k] | | ------------------ | | 533| 0| case 1: result = fromwire_in_apl(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (533:3): [True: 0, False: 0] | | ------------------ | | 534| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (534:3): [True: 0, False: 0] | | ------------------ | | 535| 0| } \ | | 536| 0| break; \ | | 537| 0| case 43: result = fromwire_ds(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (537:2): [True: 0, False: 1.92k] | | ------------------ | | 538| 0| case 44: result = fromwire_sshfp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (538:2): [True: 0, False: 1.92k] | | ------------------ | | 539| 0| case 45: result = fromwire_ipseckey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (539:2): [True: 0, False: 1.92k] | | ------------------ | | 540| 0| case 46: result = fromwire_rrsig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (540:2): [True: 0, False: 1.92k] | | ------------------ | | 541| 0| case 47: result = fromwire_nsec(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (541:2): [True: 0, False: 1.92k] | | ------------------ | | 542| 0| case 48: result = fromwire_dnskey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (542:2): [True: 0, False: 1.92k] | | ------------------ | | 543| 0| case 49: switch (rdclass) { \ | | ------------------ | | | Branch (543:2): [True: 0, False: 1.92k] | | ------------------ | | 544| 0| case 1: result = fromwire_in_dhcid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (544:3): [True: 0, False: 0] | | ------------------ | | 545| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (545:3): [True: 0, False: 0] | | ------------------ | | 546| 0| } \ | | 547| 0| break; \ | | 548| 0| case 50: result = fromwire_nsec3(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (548:2): [True: 0, False: 1.92k] | | ------------------ | | 549| 0| case 51: result = fromwire_nsec3param(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (549:2): [True: 0, False: 1.92k] | | ------------------ | | 550| 0| case 52: result = fromwire_tlsa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (550:2): [True: 0, False: 1.92k] | | ------------------ | | 551| 0| case 53: result = fromwire_smimea(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (551:2): [True: 0, False: 1.92k] | | ------------------ | | 552| 0| case 55: result = fromwire_hip(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (552:2): [True: 0, False: 1.92k] | | ------------------ | | 553| 0| case 56: result = fromwire_ninfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (553:2): [True: 0, False: 1.92k] | | ------------------ | | 554| 0| case 57: result = fromwire_rkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (554:2): [True: 0, False: 1.92k] | | ------------------ | | 555| 0| case 58: result = fromwire_talink(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (555:2): [True: 0, False: 1.92k] | | ------------------ | | 556| 0| case 59: result = fromwire_cds(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (556:2): [True: 0, False: 1.92k] | | ------------------ | | 557| 0| case 60: result = fromwire_cdnskey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (557:2): [True: 0, False: 1.92k] | | ------------------ | | 558| 0| case 61: result = fromwire_openpgpkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (558:2): [True: 0, False: 1.92k] | | ------------------ | | 559| 0| case 62: result = fromwire_csync(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (559:2): [True: 0, False: 1.92k] | | ------------------ | | 560| 0| case 63: result = fromwire_zonemd(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (560:2): [True: 0, False: 1.92k] | | ------------------ | | 561| 0| case 64: switch (rdclass) { \ | | ------------------ | | | Branch (561:2): [True: 0, False: 1.92k] | | ------------------ | | 562| 0| case 1: result = fromwire_in_svcb(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (562:3): [True: 0, False: 0] | | ------------------ | | 563| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (563:3): [True: 0, False: 0] | | ------------------ | | 564| 0| } \ | | 565| 0| break; \ | | 566| 0| case 65: switch (rdclass) { \ | | ------------------ | | | Branch (566:2): [True: 0, False: 1.92k] | | ------------------ | | 567| 0| case 1: result = fromwire_in_https(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (567:3): [True: 0, False: 0] | | ------------------ | | 568| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (568:3): [True: 0, False: 0] | | ------------------ | | 569| 0| } \ | | 570| 0| break; \ | | 571| 0| case 66: result = fromwire_dsync(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (571:2): [True: 0, False: 1.92k] | | ------------------ | | 572| 0| case 67: result = fromwire_hhit(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (572:2): [True: 0, False: 1.92k] | | ------------------ | | 573| 0| case 68: result = fromwire_brid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (573:2): [True: 0, False: 1.92k] | | ------------------ | | 574| 0| case 99: result = fromwire_spf(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (574:2): [True: 0, False: 1.92k] | | ------------------ | | 575| 0| case 104: result = fromwire_nid(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (575:2): [True: 0, False: 1.92k] | | ------------------ | | 576| 0| case 105: result = fromwire_l32(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (576:2): [True: 0, False: 1.92k] | | ------------------ | | 577| 0| case 106: result = fromwire_l64(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (577:2): [True: 0, False: 1.92k] | | ------------------ | | 578| 0| case 107: result = fromwire_lp(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (578:2): [True: 0, False: 1.92k] | | ------------------ | | 579| 0| case 108: result = fromwire_eui48(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (579:2): [True: 0, False: 1.92k] | | ------------------ | | 580| 0| case 109: result = fromwire_eui64(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (580:2): [True: 0, False: 1.92k] | | ------------------ | | 581| 0| case 249: result = fromwire_tkey(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (581:2): [True: 0, False: 1.92k] | | ------------------ | | 582| 1.12k| case 250: switch (rdclass) { \ | | ------------------ | | | Branch (582:2): [True: 1.12k, False: 798] | | ------------------ | | 583| 1.12k| case 255: result = fromwire_any_tsig(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (583:3): [True: 1.12k, False: 0] | | ------------------ | | 584| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (584:3): [True: 0, False: 1.12k] | | ------------------ | | 585| 1.12k| } \ | | 586| 1.12k| break; \ | | 587| 1.12k| case 256: result = fromwire_uri(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (587:2): [True: 0, False: 1.92k] | | ------------------ | | 588| 1.12k| case 257: result = fromwire_caa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (588:2): [True: 0, False: 1.92k] | | ------------------ | | 589| 1.12k| case 258: result = fromwire_avc(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (589:2): [True: 0, False: 1.92k] | | ------------------ | | 590| 1.12k| case 259: result = fromwire_doa(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (590:2): [True: 0, False: 1.92k] | | ------------------ | | 591| 1.12k| case 260: result = fromwire_amtrelay(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (591:2): [True: 0, False: 1.92k] | | ------------------ | | 592| 1.12k| case 261: result = fromwire_resinfo(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (592:2): [True: 0, False: 1.92k] | | ------------------ | | 593| 1.12k| case 262: result = fromwire_wallet(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (593:2): [True: 0, False: 1.92k] | | ------------------ | | 594| 1.12k| case 32768: result = fromwire_ta(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (594:2): [True: 0, False: 1.92k] | | ------------------ | | 595| 1.12k| case 32769: result = fromwire_dlv(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (595:2): [True: 0, False: 1.92k] | | ------------------ | | 596| 1.12k| case 65533: result = fromwire_keydata(rdclass, type, source, dctx, target); break; \ | | ------------------ | | | Branch (596:2): [True: 0, False: 1.92k] | | ------------------ | | 597| 1.12k| default: use_default = true; break; \ | | ------------------ | | | Branch (597:2): [True: 0, False: 1.92k] | | ------------------ | | 598| 1.92k| } ------------------ 941| | 942| 1.92k| if (use_default) { ------------------ | Branch (942:6): [True: 0, False: 1.92k] ------------------ 943| 0| if (activelength > isc_buffer_availablelength(target)) { ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (943:7): [True: 0, False: 0] ------------------ 944| 0| result = ISC_R_NOSPACE; 945| 0| } else { 946| 0| isc_buffer_putmem(target, isc_buffer_current(source), ------------------ | | 146| 0| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 947| 0| activelength); 948| 0| isc_buffer_forward(source, activelength); 949| 0| result = ISC_R_SUCCESS; 950| 0| } 951| 0| } 952| | 953| | /* 954| | * Reject any rdata that expands out to more than DNS_RDATA_MAXLENGTH 955| | * as we cannot transmit it. 956| | */ 957| 1.92k| length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 158| 1.92k|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 158| 1.92k|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 958| 1.92k| if (result == ISC_R_SUCCESS && length > DNS_RDATA_MAXLENGTH) { ------------------ | | 183| 1.17k|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (958:6): [True: 1.17k, False: 748] | Branch (958:33): [True: 8, False: 1.16k] ------------------ 959| 8| result = DNS_R_FORMERR; 960| 8| } 961| | 962| | /* 963| | * We should have consumed all of our buffer. 964| | */ 965| 1.92k| if (result == ISC_R_SUCCESS && !buffer_empty(source)) { ------------------ | Branch (965:6): [True: 1.16k, False: 756] | Branch (965:33): [True: 92, False: 1.07k] ------------------ 966| 92| result = DNS_R_EXTRADATA; 967| 92| } 968| | 969| 1.92k| if (rdata != NULL && result == ISC_R_SUCCESS) { ------------------ | Branch (969:6): [True: 1.92k, False: 0] | Branch (969:23): [True: 1.07k, False: 848] ------------------ 970| 1.07k| region.base = isc_buffer_used(&st); ------------------ | | 150| 1.07k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 971| 1.07k| region.length = length; 972| 1.07k| dns_rdata_fromregion(rdata, rdclass, type, ®ion); 973| 1.07k| } 974| | 975| 1.92k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (975:6): [True: 848, False: 1.07k] ------------------ 976| 848| *source = ss; 977| 848| *target = st; 978| 848| } 979| 1.92k| return result; 980| 1.92k|} dns_rdata_fromtext: 1086| 6| dns_rdatacallbacks_t *callbacks) { 1087| 6| isc_result_t result = ISC_R_NOTIMPLEMENTED; 1088| 6| isc_region_t region; 1089| 6| isc_buffer_t st; 1090| 6| isc_token_t token; 1091| 6| unsigned int lexoptions = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 63| 6|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ unsigned int lexoptions = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 64| 6|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ 1092| 6| ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 78| 6|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 82| 6|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 1093| 6| char *name; 1094| 6| unsigned long line; 1095| 6| void (*callback)(dns_rdatacallbacks_t *, const char *, ...); 1096| 6| isc_result_t tresult; 1097| 6| unsigned int length; 1098| 6| bool unknown; 1099| | 1100| 6| REQUIRE(origin == NULL || dns_name_isabsolute(origin)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 6] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1101| 6| if (rdata != NULL) { ------------------ | Branch (1101:6): [True: 6, False: 0] ------------------ 1102| 6| REQUIRE(DNS_RDATA_INITIALIZED(rdata)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 60| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1103| 6| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1104| 6| } 1105| 6| if (callbacks != NULL) { ------------------ | Branch (1105:6): [True: 6, False: 0] ------------------ 1106| 6| REQUIRE(callbacks->warn != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1107| 6| REQUIRE(callbacks->error != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1108| 6| } 1109| | 1110| 6| st = *target; 1111| | 1112| 6| if (callbacks != NULL) { ------------------ | Branch (1112:6): [True: 6, False: 0] ------------------ 1113| 6| callback = callbacks->error; 1114| 6| } else { 1115| 0| callback = default_fromtext_callback; 1116| 0| } 1117| | 1118| 6| result = isc_lex_getmastertoken(lexer, &token, isc_tokentype_qstring, 1119| 6| true); 1120| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1120:6): [True: 0, False: 6] ------------------ 1121| 0| name = isc_lex_getsourcename(lexer); 1122| 0| line = isc_lex_getsourceline(lexer); 1123| 0| fromtext_error(callback, callbacks, name, line, NULL, result); 1124| 0| return result; 1125| 0| } 1126| | 1127| 6| unknown = false; 1128| 6| if (token.type == isc_tokentype_string && ------------------ | Branch (1128:6): [True: 6, False: 0] ------------------ 1129| 6| strcmp(DNS_AS_STR(token), "\\#") == 0) ------------------ | | 73| 6|#define DNS_AS_STR(t) ((t).value.as_textregion.base) ------------------ | Branch (1129:6): [True: 0, False: 6] ------------------ 1130| 0| { 1131| | /* 1132| | * If this is a TXT record '\#' could be a escaped '#'. 1133| | * Look to see if the next token is a number and if so 1134| | * treat it as a unknown record format. 1135| | */ 1136| 0| if (type == dns_rdatatype_txt) { ------------------ | | 131| 0|#define dns_rdatatype_txt ((dns_rdatatype_t)dns_rdatatype_txt) ------------------ | Branch (1136:7): [True: 0, False: 0] ------------------ 1137| 0| result = isc_lex_getmastertoken( 1138| 0| lexer, &token, isc_tokentype_number, false); 1139| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1139:8): [True: 0, False: 0] ------------------ 1140| 0| isc_lex_ungettoken(lexer, &token); 1141| 0| } 1142| 0| } 1143| | 1144| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1144:7): [True: 0, False: 0] ------------------ 1145| 0| unknown = true; 1146| 0| result = unknown_fromtext(rdclass, type, lexer, mctx, 1147| 0| target); 1148| 0| } else { 1149| 0| options |= DNS_RDATA_UNKNOWNESCAPE; ------------------ | | 217| 0|#define DNS_RDATA_UNKNOWNESCAPE 0x80000000 ------------------ 1150| 0| } 1151| 6| } else { 1152| 6| isc_lex_ungettoken(lexer, &token); 1153| 6| } 1154| | 1155| 6| if (!unknown) { ------------------ | Branch (1155:6): [True: 6, False: 0] ------------------ 1156| 6| FROMTEXTSWITCH ------------------ | | 118| 6| switch (type) { \ | | 119| 0| case 1: switch (rdclass) { \ | | ------------------ | | | Branch (119:2): [True: 0, False: 6] | | ------------------ | | 120| 0| case 1: result = fromtext_in_a(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (120:3): [True: 0, False: 0] | | ------------------ | | 121| 0| case 3: result = fromtext_ch_a(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (121:3): [True: 0, False: 0] | | ------------------ | | 122| 0| case 4: result = fromtext_hs_a(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (122:3): [True: 0, False: 0] | | ------------------ | | 123| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (123:3): [True: 0, False: 0] | | ------------------ | | 124| 0| } \ | | 125| 0| break; \ | | 126| 2| case 2: result = fromtext_ns(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (126:2): [True: 2, False: 4] | | ------------------ | | 127| 0| case 3: result = fromtext_md(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (127:2): [True: 0, False: 6] | | ------------------ | | 128| 0| case 4: result = fromtext_mf(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (128:2): [True: 0, False: 6] | | ------------------ | | 129| 0| case 5: result = fromtext_cname(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (129:2): [True: 0, False: 6] | | ------------------ | | 130| 2| case 6: result = fromtext_soa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (130:2): [True: 2, False: 4] | | ------------------ | | 131| 0| case 7: result = fromtext_mb(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (131:2): [True: 0, False: 6] | | ------------------ | | 132| 0| case 8: result = fromtext_mg(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (132:2): [True: 0, False: 6] | | ------------------ | | 133| 0| case 9: result = fromtext_mr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (133:2): [True: 0, False: 6] | | ------------------ | | 134| 0| case 10: result = fromtext_null(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (134:2): [True: 0, False: 6] | | ------------------ | | 135| 0| case 11: switch (rdclass) { \ | | ------------------ | | | Branch (135:2): [True: 0, False: 6] | | ------------------ | | 136| 0| case 1: result = fromtext_in_wks(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (136:3): [True: 0, False: 0] | | ------------------ | | 137| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (137:3): [True: 0, False: 0] | | ------------------ | | 138| 0| } \ | | 139| 0| break; \ | | 140| 0| case 12: result = fromtext_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (140:2): [True: 0, False: 6] | | ------------------ | | 141| 0| case 13: result = fromtext_hinfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (141:2): [True: 0, False: 6] | | ------------------ | | 142| 0| case 14: result = fromtext_minfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (142:2): [True: 0, False: 6] | | ------------------ | | 143| 0| case 15: result = fromtext_mx(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (143:2): [True: 0, False: 6] | | ------------------ | | 144| 0| case 16: result = fromtext_txt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (144:2): [True: 0, False: 6] | | ------------------ | | 145| 0| case 17: result = fromtext_rp(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (145:2): [True: 0, False: 6] | | ------------------ | | 146| 0| case 18: result = fromtext_afsdb(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (146:2): [True: 0, False: 6] | | ------------------ | | 147| 0| case 19: result = fromtext_x25(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (147:2): [True: 0, False: 6] | | ------------------ | | 148| 0| case 20: result = fromtext_isdn(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (148:2): [True: 0, False: 6] | | ------------------ | | 149| 0| case 21: result = fromtext_rt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (149:2): [True: 0, False: 6] | | ------------------ | | 150| 0| case 22: switch (rdclass) { \ | | ------------------ | | | Branch (150:2): [True: 0, False: 6] | | ------------------ | | 151| 0| case 1: result = fromtext_in_nsap(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (151:3): [True: 0, False: 0] | | ------------------ | | 152| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (152:3): [True: 0, False: 0] | | ------------------ | | 153| 0| } \ | | 154| 0| break; \ | | 155| 0| case 23: switch (rdclass) { \ | | ------------------ | | | Branch (155:2): [True: 0, False: 6] | | ------------------ | | 156| 0| case 1: result = fromtext_in_nsap_ptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (156:3): [True: 0, False: 0] | | ------------------ | | 157| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (157:3): [True: 0, False: 0] | | ------------------ | | 158| 0| } \ | | 159| 0| break; \ | | 160| 0| case 24: result = fromtext_sig(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (160:2): [True: 0, False: 6] | | ------------------ | | 161| 2| case 25: result = fromtext_key(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (161:2): [True: 2, False: 4] | | ------------------ | | 162| 0| case 26: switch (rdclass) { \ | | ------------------ | | | Branch (162:2): [True: 0, False: 6] | | ------------------ | | 163| 0| case 1: result = fromtext_in_px(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (163:3): [True: 0, False: 0] | | ------------------ | | 164| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (164:3): [True: 0, False: 0] | | ------------------ | | 165| 0| } \ | | 166| 0| break; \ | | 167| 0| case 27: result = fromtext_gpos(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (167:2): [True: 0, False: 6] | | ------------------ | | 168| 0| case 28: switch (rdclass) { \ | | ------------------ | | | Branch (168:2): [True: 0, False: 6] | | ------------------ | | 169| 0| case 1: result = fromtext_in_aaaa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (169:3): [True: 0, False: 0] | | ------------------ | | 170| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (170:3): [True: 0, False: 0] | | ------------------ | | 171| 0| } \ | | 172| 0| break; \ | | 173| 0| case 29: result = fromtext_loc(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (173:2): [True: 0, False: 6] | | ------------------ | | 174| 0| case 30: result = fromtext_nxt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (174:2): [True: 0, False: 6] | | ------------------ | | 175| 0| case 31: switch (rdclass) { \ | | ------------------ | | | Branch (175:2): [True: 0, False: 6] | | ------------------ | | 176| 0| case 1: result = fromtext_in_eid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (176:3): [True: 0, False: 0] | | ------------------ | | 177| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (177:3): [True: 0, False: 0] | | ------------------ | | 178| 0| } \ | | 179| 0| break; \ | | 180| 0| case 32: switch (rdclass) { \ | | ------------------ | | | Branch (180:2): [True: 0, False: 6] | | ------------------ | | 181| 0| case 1: result = fromtext_in_nimloc(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (181:3): [True: 0, False: 0] | | ------------------ | | 182| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (182:3): [True: 0, False: 0] | | ------------------ | | 183| 0| } \ | | 184| 0| break; \ | | 185| 0| case 33: switch (rdclass) { \ | | ------------------ | | | Branch (185:2): [True: 0, False: 6] | | ------------------ | | 186| 0| case 1: result = fromtext_in_srv(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (186:3): [True: 0, False: 0] | | ------------------ | | 187| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (187:3): [True: 0, False: 0] | | ------------------ | | 188| 0| } \ | | 189| 0| break; \ | | 190| 0| case 34: switch (rdclass) { \ | | ------------------ | | | Branch (190:2): [True: 0, False: 6] | | ------------------ | | 191| 0| case 1: result = fromtext_in_atma(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (191:3): [True: 0, False: 0] | | ------------------ | | 192| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (192:3): [True: 0, False: 0] | | ------------------ | | 193| 0| } \ | | 194| 0| break; \ | | 195| 0| case 35: result = fromtext_naptr(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (195:2): [True: 0, False: 6] | | ------------------ | | 196| 0| case 36: switch (rdclass) { \ | | ------------------ | | | Branch (196:2): [True: 0, False: 6] | | ------------------ | | 197| 0| case 1: result = fromtext_in_kx(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (197:3): [True: 0, False: 0] | | ------------------ | | 198| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (198:3): [True: 0, False: 0] | | ------------------ | | 199| 0| } \ | | 200| 0| break; \ | | 201| 0| case 37: result = fromtext_cert(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (201:2): [True: 0, False: 6] | | ------------------ | | 202| 0| case 38: switch (rdclass) { \ | | ------------------ | | | Branch (202:2): [True: 0, False: 6] | | ------------------ | | 203| 0| case 1: result = fromtext_in_a6(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (203:3): [True: 0, False: 0] | | ------------------ | | 204| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (204:3): [True: 0, False: 0] | | ------------------ | | 205| 0| } \ | | 206| 0| break; \ | | 207| 0| case 39: result = fromtext_dname(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (207:2): [True: 0, False: 6] | | ------------------ | | 208| 0| case 40: result = fromtext_sink(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (208:2): [True: 0, False: 6] | | ------------------ | | 209| 0| case 41: result = fromtext_opt(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (209:2): [True: 0, False: 6] | | ------------------ | | 210| 0| case 42: switch (rdclass) { \ | | ------------------ | | | Branch (210:2): [True: 0, False: 6] | | ------------------ | | 211| 0| case 1: result = fromtext_in_apl(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (211:3): [True: 0, False: 0] | | ------------------ | | 212| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (212:3): [True: 0, False: 0] | | ------------------ | | 213| 0| } \ | | 214| 0| break; \ | | 215| 0| case 43: result = fromtext_ds(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (215:2): [True: 0, False: 6] | | ------------------ | | 216| 0| case 44: result = fromtext_sshfp(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (216:2): [True: 0, False: 6] | | ------------------ | | 217| 0| case 45: result = fromtext_ipseckey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (217:2): [True: 0, False: 6] | | ------------------ | | 218| 0| case 46: result = fromtext_rrsig(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (218:2): [True: 0, False: 6] | | ------------------ | | 219| 0| case 47: result = fromtext_nsec(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (219:2): [True: 0, False: 6] | | ------------------ | | 220| 0| case 48: result = fromtext_dnskey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (220:2): [True: 0, False: 6] | | ------------------ | | 221| 0| case 49: switch (rdclass) { \ | | ------------------ | | | Branch (221:2): [True: 0, False: 6] | | ------------------ | | 222| 0| case 1: result = fromtext_in_dhcid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (222:3): [True: 0, False: 0] | | ------------------ | | 223| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (223:3): [True: 0, False: 0] | | ------------------ | | 224| 0| } \ | | 225| 0| break; \ | | 226| 0| case 50: result = fromtext_nsec3(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (226:2): [True: 0, False: 6] | | ------------------ | | 227| 0| case 51: result = fromtext_nsec3param(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (227:2): [True: 0, False: 6] | | ------------------ | | 228| 0| case 52: result = fromtext_tlsa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (228:2): [True: 0, False: 6] | | ------------------ | | 229| 0| case 53: result = fromtext_smimea(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (229:2): [True: 0, False: 6] | | ------------------ | | 230| 0| case 55: result = fromtext_hip(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (230:2): [True: 0, False: 6] | | ------------------ | | 231| 0| case 56: result = fromtext_ninfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (231:2): [True: 0, False: 6] | | ------------------ | | 232| 0| case 57: result = fromtext_rkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (232:2): [True: 0, False: 6] | | ------------------ | | 233| 0| case 58: result = fromtext_talink(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (233:2): [True: 0, False: 6] | | ------------------ | | 234| 0| case 59: result = fromtext_cds(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (234:2): [True: 0, False: 6] | | ------------------ | | 235| 0| case 60: result = fromtext_cdnskey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (235:2): [True: 0, False: 6] | | ------------------ | | 236| 0| case 61: result = fromtext_openpgpkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (236:2): [True: 0, False: 6] | | ------------------ | | 237| 0| case 62: result = fromtext_csync(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (237:2): [True: 0, False: 6] | | ------------------ | | 238| 0| case 63: result = fromtext_zonemd(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (238:2): [True: 0, False: 6] | | ------------------ | | 239| 0| case 64: switch (rdclass) { \ | | ------------------ | | | Branch (239:2): [True: 0, False: 6] | | ------------------ | | 240| 0| case 1: result = fromtext_in_svcb(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (240:3): [True: 0, False: 0] | | ------------------ | | 241| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (241:3): [True: 0, False: 0] | | ------------------ | | 242| 0| } \ | | 243| 0| break; \ | | 244| 0| case 65: switch (rdclass) { \ | | ------------------ | | | Branch (244:2): [True: 0, False: 6] | | ------------------ | | 245| 0| case 1: result = fromtext_in_https(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (245:3): [True: 0, False: 0] | | ------------------ | | 246| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (246:3): [True: 0, False: 0] | | ------------------ | | 247| 0| } \ | | 248| 0| break; \ | | 249| 0| case 66: result = fromtext_dsync(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (249:2): [True: 0, False: 6] | | ------------------ | | 250| 0| case 67: result = fromtext_hhit(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (250:2): [True: 0, False: 6] | | ------------------ | | 251| 0| case 68: result = fromtext_brid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (251:2): [True: 0, False: 6] | | ------------------ | | 252| 0| case 99: result = fromtext_spf(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (252:2): [True: 0, False: 6] | | ------------------ | | 253| 0| case 104: result = fromtext_nid(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (253:2): [True: 0, False: 6] | | ------------------ | | 254| 0| case 105: result = fromtext_l32(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (254:2): [True: 0, False: 6] | | ------------------ | | 255| 0| case 106: result = fromtext_l64(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (255:2): [True: 0, False: 6] | | ------------------ | | 256| 0| case 107: result = fromtext_lp(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (256:2): [True: 0, False: 6] | | ------------------ | | 257| 0| case 108: result = fromtext_eui48(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (257:2): [True: 0, False: 6] | | ------------------ | | 258| 0| case 109: result = fromtext_eui64(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (258:2): [True: 0, False: 6] | | ------------------ | | 259| 0| case 249: result = fromtext_tkey(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (259:2): [True: 0, False: 6] | | ------------------ | | 260| 0| case 250: switch (rdclass) { \ | | ------------------ | | | Branch (260:2): [True: 0, False: 6] | | ------------------ | | 261| 0| case 255: result = fromtext_any_tsig(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (261:3): [True: 0, False: 0] | | ------------------ | | 262| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (262:3): [True: 0, False: 0] | | ------------------ | | 263| 0| } \ | | 264| 0| break; \ | | 265| 0| case 256: result = fromtext_uri(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (265:2): [True: 0, False: 6] | | ------------------ | | 266| 0| case 257: result = fromtext_caa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (266:2): [True: 0, False: 6] | | ------------------ | | 267| 0| case 258: result = fromtext_avc(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (267:2): [True: 0, False: 6] | | ------------------ | | 268| 0| case 259: result = fromtext_doa(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (268:2): [True: 0, False: 6] | | ------------------ | | 269| 0| case 260: result = fromtext_amtrelay(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (269:2): [True: 0, False: 6] | | ------------------ | | 270| 0| case 261: result = fromtext_resinfo(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (270:2): [True: 0, False: 6] | | ------------------ | | 271| 0| case 262: result = fromtext_wallet(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (271:2): [True: 0, False: 6] | | ------------------ | | 272| 0| case 32768: result = fromtext_ta(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (272:2): [True: 0, False: 6] | | ------------------ | | 273| 0| case 32769: result = fromtext_dlv(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (273:2): [True: 0, False: 6] | | ------------------ | | 274| 0| case 65533: result = fromtext_keydata(rdclass, type, lexer, origin, options, target, callbacks); break; \ | | ------------------ | | | Branch (274:2): [True: 0, False: 6] | | ------------------ | | 275| 0| default: result = DNS_R_UNKNOWN; break; \ | | ------------------ | | | Branch (275:2): [True: 0, False: 6] | | ------------------ | | 276| 6| } ------------------ 1157| | 1158| | /* 1159| | * Consume to end of line / file. 1160| | * If not at end of line initially set error code. 1161| | * Call callback via fromtext_error once if there was an error. 1162| | */ 1163| 6| } 1164| 6| do { 1165| 6| name = isc_lex_getsourcename(lexer); 1166| 6| line = isc_lex_getsourceline(lexer); 1167| 6| tresult = isc_lex_gettoken(lexer, lexoptions, &token); 1168| 6| if (tresult != ISC_R_SUCCESS) { ------------------ | Branch (1168:7): [True: 0, False: 6] ------------------ 1169| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1169:8): [True: 0, False: 0] ------------------ 1170| 0| result = tresult; 1171| 0| } 1172| 0| if (callback != NULL) { ------------------ | Branch (1172:8): [True: 0, False: 0] ------------------ 1173| 0| fromtext_error(callback, callbacks, name, line, 1174| 0| NULL, result); 1175| 0| } 1176| 0| break; 1177| 6| } else if (token.type != isc_tokentype_eol && ------------------ | Branch (1177:14): [True: 0, False: 6] ------------------ 1178| 0| token.type != isc_tokentype_eof) ------------------ | Branch (1178:7): [True: 0, False: 0] ------------------ 1179| 0| { 1180| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1180:8): [True: 0, False: 0] ------------------ 1181| 0| result = DNS_R_EXTRATOKEN; 1182| 0| } 1183| 0| if (callback != NULL) { ------------------ | Branch (1183:8): [True: 0, False: 0] ------------------ 1184| 0| fromtext_error(callback, callbacks, name, line, 1185| 0| &token, result); 1186| 0| callback = NULL; 1187| 0| } 1188| 6| } else if (result != ISC_R_SUCCESS && callback != NULL) { ------------------ | Branch (1188:14): [True: 0, False: 6] | Branch (1188:41): [True: 0, False: 0] ------------------ 1189| 0| fromtext_error(callback, callbacks, name, line, &token, 1190| 0| result); 1191| 0| break; 1192| 6| } else { 1193| 6| if (token.type == isc_tokentype_eof) { ------------------ | Branch (1193:8): [True: 0, False: 6] ------------------ 1194| 0| fromtext_warneof(lexer, callbacks); 1195| 0| } 1196| 6| break; 1197| 6| } 1198| 6| } while (1); ------------------ | Branch (1198:11): [True: 0, Folded] ------------------ 1199| | 1200| 6| length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 158| 6|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ length = isc_buffer_usedlength(target) - isc_buffer_usedlength(&st); ------------------ | | 158| 6|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 1201| 6| if (result == ISC_R_SUCCESS && length > DNS_RDATA_MAXLENGTH) { ------------------ | | 183| 6|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (1201:6): [True: 6, False: 0] | Branch (1201:33): [True: 0, False: 6] ------------------ 1202| 0| result = ISC_R_NOSPACE; 1203| 0| } 1204| | 1205| 6| if (rdata != NULL && result == ISC_R_SUCCESS) { ------------------ | Branch (1205:6): [True: 6, False: 0] | Branch (1205:23): [True: 6, False: 0] ------------------ 1206| 6| region.base = isc_buffer_used(&st); ------------------ | | 150| 6| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1207| 6| region.length = length; 1208| 6| dns_rdata_fromregion(rdata, rdclass, type, ®ion); 1209| 6| } 1210| 6| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1210:6): [True: 0, False: 6] ------------------ 1211| 0| *target = st; 1212| 0| } 1213| 6| return result; 1214| 6|} dns_rdata_tostruct: 1378| 1.36k|dns_rdata_tostruct(const dns_rdata_t *rdata, void *target) { 1379| 1.36k| isc_result_t result = ISC_R_NOTIMPLEMENTED; 1380| 1.36k| bool use_default = false; 1381| | 1382| 1.36k| REQUIRE(rdata != NULL); ------------------ | | 198| 1.36k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.36k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.36k, False: 0] | | | | ------------------ | | | | 42| 1.36k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1383| 1.36k| REQUIRE(DNS_RDATA_VALIDFLAGS(rdata)); ------------------ | | 198| 1.36k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.36k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.36k, False: 0] | | | | ------------------ | | | | 42| 1.36k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1384| 1.36k| REQUIRE((rdata->flags & DNS_RDATA_UPDATE) == 0); ------------------ | | 198| 1.36k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.36k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.36k, False: 0] | | | | ------------------ | | | | 42| 1.36k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1385| | 1386| 1.36k| TOSTRUCTSWITCH ------------------ | | 1245| 1.36k| switch (rdata->type) { \ | | 1246| 0| case 1: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1246:2): [True: 0, False: 1.36k] | | ------------------ | | 1247| 0| case 1: result = tostruct_in_a(rdata, target); break; \ | | ------------------ | | | Branch (1247:3): [True: 0, False: 0] | | ------------------ | | 1248| 0| case 3: result = tostruct_ch_a(rdata, target); break; \ | | ------------------ | | | Branch (1248:3): [True: 0, False: 0] | | ------------------ | | 1249| 0| case 4: result = tostruct_hs_a(rdata, target); break; \ | | ------------------ | | | Branch (1249:3): [True: 0, False: 0] | | ------------------ | | 1250| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1250:3): [True: 0, False: 0] | | ------------------ | | 1251| 0| } \ | | 1252| 0| break; \ | | 1253| 2| case 2: result = tostruct_ns(rdata, target); break; \ | | ------------------ | | | Branch (1253:2): [True: 2, False: 1.36k] | | ------------------ | | 1254| 0| case 3: result = tostruct_md(rdata, target); break; \ | | ------------------ | | | Branch (1254:2): [True: 0, False: 1.36k] | | ------------------ | | 1255| 0| case 4: result = tostruct_mf(rdata, target); break; \ | | ------------------ | | | Branch (1255:2): [True: 0, False: 1.36k] | | ------------------ | | 1256| 0| case 5: result = tostruct_cname(rdata, target); break; \ | | ------------------ | | | Branch (1256:2): [True: 0, False: 1.36k] | | ------------------ | | 1257| 2| case 6: result = tostruct_soa(rdata, target); break; \ | | ------------------ | | | Branch (1257:2): [True: 2, False: 1.36k] | | ------------------ | | 1258| 0| case 7: result = tostruct_mb(rdata, target); break; \ | | ------------------ | | | Branch (1258:2): [True: 0, False: 1.36k] | | ------------------ | | 1259| 0| case 8: result = tostruct_mg(rdata, target); break; \ | | ------------------ | | | Branch (1259:2): [True: 0, False: 1.36k] | | ------------------ | | 1260| 0| case 9: result = tostruct_mr(rdata, target); break; \ | | ------------------ | | | Branch (1260:2): [True: 0, False: 1.36k] | | ------------------ | | 1261| 0| case 10: result = tostruct_null(rdata, target); break; \ | | ------------------ | | | Branch (1261:2): [True: 0, False: 1.36k] | | ------------------ | | 1262| 0| case 11: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1262:2): [True: 0, False: 1.36k] | | ------------------ | | 1263| 0| case 1: result = tostruct_in_wks(rdata, target); break; \ | | ------------------ | | | Branch (1263:3): [True: 0, False: 0] | | ------------------ | | 1264| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1264:3): [True: 0, False: 0] | | ------------------ | | 1265| 0| } \ | | 1266| 0| break; \ | | 1267| 0| case 12: result = tostruct_ptr(rdata, target); break; \ | | ------------------ | | | Branch (1267:2): [True: 0, False: 1.36k] | | ------------------ | | 1268| 0| case 13: result = tostruct_hinfo(rdata, target); break; \ | | ------------------ | | | Branch (1268:2): [True: 0, False: 1.36k] | | ------------------ | | 1269| 0| case 14: result = tostruct_minfo(rdata, target); break; \ | | ------------------ | | | Branch (1269:2): [True: 0, False: 1.36k] | | ------------------ | | 1270| 0| case 15: result = tostruct_mx(rdata, target); break; \ | | ------------------ | | | Branch (1270:2): [True: 0, False: 1.36k] | | ------------------ | | 1271| 0| case 16: result = tostruct_txt(rdata, target); break; \ | | ------------------ | | | Branch (1271:2): [True: 0, False: 1.36k] | | ------------------ | | 1272| 0| case 17: result = tostruct_rp(rdata, target); break; \ | | ------------------ | | | Branch (1272:2): [True: 0, False: 1.36k] | | ------------------ | | 1273| 0| case 18: result = tostruct_afsdb(rdata, target); break; \ | | ------------------ | | | Branch (1273:2): [True: 0, False: 1.36k] | | ------------------ | | 1274| 0| case 19: result = tostruct_x25(rdata, target); break; \ | | ------------------ | | | Branch (1274:2): [True: 0, False: 1.36k] | | ------------------ | | 1275| 0| case 20: result = tostruct_isdn(rdata, target); break; \ | | ------------------ | | | Branch (1275:2): [True: 0, False: 1.36k] | | ------------------ | | 1276| 0| case 21: result = tostruct_rt(rdata, target); break; \ | | ------------------ | | | Branch (1276:2): [True: 0, False: 1.36k] | | ------------------ | | 1277| 0| case 22: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1277:2): [True: 0, False: 1.36k] | | ------------------ | | 1278| 0| case 1: result = tostruct_in_nsap(rdata, target); break; \ | | ------------------ | | | Branch (1278:3): [True: 0, False: 0] | | ------------------ | | 1279| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1279:3): [True: 0, False: 0] | | ------------------ | | 1280| 0| } \ | | 1281| 0| break; \ | | 1282| 0| case 23: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1282:2): [True: 0, False: 1.36k] | | ------------------ | | 1283| 0| case 1: result = tostruct_in_nsap_ptr(rdata, target); break; \ | | ------------------ | | | Branch (1283:3): [True: 0, False: 0] | | ------------------ | | 1284| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1284:3): [True: 0, False: 0] | | ------------------ | | 1285| 0| } \ | | 1286| 0| break; \ | | 1287| 498| case 24: result = tostruct_sig(rdata, target); break; \ | | ------------------ | | | Branch (1287:2): [True: 498, False: 869] | | ------------------ | | 1288| 117| case 25: result = tostruct_key(rdata, target); break; \ | | ------------------ | | | Branch (1288:2): [True: 117, False: 1.25k] | | ------------------ | | 1289| 0| case 26: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1289:2): [True: 0, False: 1.36k] | | ------------------ | | 1290| 0| case 1: result = tostruct_in_px(rdata, target); break; \ | | ------------------ | | | Branch (1290:3): [True: 0, False: 0] | | ------------------ | | 1291| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1291:3): [True: 0, False: 0] | | ------------------ | | 1292| 0| } \ | | 1293| 0| break; \ | | 1294| 0| case 27: result = tostruct_gpos(rdata, target); break; \ | | ------------------ | | | Branch (1294:2): [True: 0, False: 1.36k] | | ------------------ | | 1295| 0| case 28: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1295:2): [True: 0, False: 1.36k] | | ------------------ | | 1296| 0| case 1: result = tostruct_in_aaaa(rdata, target); break; \ | | ------------------ | | | Branch (1296:3): [True: 0, False: 0] | | ------------------ | | 1297| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1297:3): [True: 0, False: 0] | | ------------------ | | 1298| 0| } \ | | 1299| 0| break; \ | | 1300| 0| case 29: result = tostruct_loc(rdata, target); break; \ | | ------------------ | | | Branch (1300:2): [True: 0, False: 1.36k] | | ------------------ | | 1301| 0| case 30: result = tostruct_nxt(rdata, target); break; \ | | ------------------ | | | Branch (1301:2): [True: 0, False: 1.36k] | | ------------------ | | 1302| 0| case 31: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1302:2): [True: 0, False: 1.36k] | | ------------------ | | 1303| 0| case 1: result = tostruct_in_eid(rdata, target); break; \ | | ------------------ | | | Branch (1303:3): [True: 0, False: 0] | | ------------------ | | 1304| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1304:3): [True: 0, False: 0] | | ------------------ | | 1305| 0| } \ | | 1306| 0| break; \ | | 1307| 0| case 32: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1307:2): [True: 0, False: 1.36k] | | ------------------ | | 1308| 0| case 1: result = tostruct_in_nimloc(rdata, target); break; \ | | ------------------ | | | Branch (1308:3): [True: 0, False: 0] | | ------------------ | | 1309| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1309:3): [True: 0, False: 0] | | ------------------ | | 1310| 0| } \ | | 1311| 0| break; \ | | 1312| 0| case 33: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1312:2): [True: 0, False: 1.36k] | | ------------------ | | 1313| 0| case 1: result = tostruct_in_srv(rdata, target); break; \ | | ------------------ | | | Branch (1313:3): [True: 0, False: 0] | | ------------------ | | 1314| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1314:3): [True: 0, False: 0] | | ------------------ | | 1315| 0| } \ | | 1316| 0| break; \ | | 1317| 0| case 34: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1317:2): [True: 0, False: 1.36k] | | ------------------ | | 1318| 0| case 1: result = tostruct_in_atma(rdata, target); break; \ | | ------------------ | | | Branch (1318:3): [True: 0, False: 0] | | ------------------ | | 1319| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1319:3): [True: 0, False: 0] | | ------------------ | | 1320| 0| } \ | | 1321| 0| break; \ | | 1322| 0| case 35: result = tostruct_naptr(rdata, target); break; \ | | ------------------ | | | Branch (1322:2): [True: 0, False: 1.36k] | | ------------------ | | 1323| 0| case 36: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1323:2): [True: 0, False: 1.36k] | | ------------------ | | 1324| 0| case 1: result = tostruct_in_kx(rdata, target); break; \ | | ------------------ | | | Branch (1324:3): [True: 0, False: 0] | | ------------------ | | 1325| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1325:3): [True: 0, False: 0] | | ------------------ | | 1326| 0| } \ | | 1327| 0| break; \ | | 1328| 0| case 37: result = tostruct_cert(rdata, target); break; \ | | ------------------ | | | Branch (1328:2): [True: 0, False: 1.36k] | | ------------------ | | 1329| 0| case 38: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1329:2): [True: 0, False: 1.36k] | | ------------------ | | 1330| 0| case 1: result = tostruct_in_a6(rdata, target); break; \ | | ------------------ | | | Branch (1330:3): [True: 0, False: 0] | | ------------------ | | 1331| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1331:3): [True: 0, False: 0] | | ------------------ | | 1332| 0| } \ | | 1333| 0| break; \ | | 1334| 0| case 39: result = tostruct_dname(rdata, target); break; \ | | ------------------ | | | Branch (1334:2): [True: 0, False: 1.36k] | | ------------------ | | 1335| 0| case 40: result = tostruct_sink(rdata, target); break; \ | | ------------------ | | | Branch (1335:2): [True: 0, False: 1.36k] | | ------------------ | | 1336| 0| case 41: result = tostruct_opt(rdata, target); break; \ | | ------------------ | | | Branch (1336:2): [True: 0, False: 1.36k] | | ------------------ | | 1337| 0| case 42: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1337:2): [True: 0, False: 1.36k] | | ------------------ | | 1338| 0| case 1: result = tostruct_in_apl(rdata, target); break; \ | | ------------------ | | | Branch (1338:3): [True: 0, False: 0] | | ------------------ | | 1339| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1339:3): [True: 0, False: 0] | | ------------------ | | 1340| 0| } \ | | 1341| 0| break; \ | | 1342| 0| case 43: result = tostruct_ds(rdata, target); break; \ | | ------------------ | | | Branch (1342:2): [True: 0, False: 1.36k] | | ------------------ | | 1343| 0| case 44: result = tostruct_sshfp(rdata, target); break; \ | | ------------------ | | | Branch (1343:2): [True: 0, False: 1.36k] | | ------------------ | | 1344| 0| case 45: result = tostruct_ipseckey(rdata, target); break; \ | | ------------------ | | | Branch (1344:2): [True: 0, False: 1.36k] | | ------------------ | | 1345| 0| case 46: result = tostruct_rrsig(rdata, target); break; \ | | ------------------ | | | Branch (1345:2): [True: 0, False: 1.36k] | | ------------------ | | 1346| 0| case 47: result = tostruct_nsec(rdata, target); break; \ | | ------------------ | | | Branch (1346:2): [True: 0, False: 1.36k] | | ------------------ | | 1347| 0| case 48: result = tostruct_dnskey(rdata, target); break; \ | | ------------------ | | | Branch (1347:2): [True: 0, False: 1.36k] | | ------------------ | | 1348| 0| case 49: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1348:2): [True: 0, False: 1.36k] | | ------------------ | | 1349| 0| case 1: result = tostruct_in_dhcid(rdata, target); break; \ | | ------------------ | | | Branch (1349:3): [True: 0, False: 0] | | ------------------ | | 1350| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1350:3): [True: 0, False: 0] | | ------------------ | | 1351| 0| } \ | | 1352| 0| break; \ | | 1353| 0| case 50: result = tostruct_nsec3(rdata, target); break; \ | | ------------------ | | | Branch (1353:2): [True: 0, False: 1.36k] | | ------------------ | | 1354| 0| case 51: result = tostruct_nsec3param(rdata, target); break; \ | | ------------------ | | | Branch (1354:2): [True: 0, False: 1.36k] | | ------------------ | | 1355| 0| case 52: result = tostruct_tlsa(rdata, target); break; \ | | ------------------ | | | Branch (1355:2): [True: 0, False: 1.36k] | | ------------------ | | 1356| 0| case 53: result = tostruct_smimea(rdata, target); break; \ | | ------------------ | | | Branch (1356:2): [True: 0, False: 1.36k] | | ------------------ | | 1357| 0| case 55: result = tostruct_hip(rdata, target); break; \ | | ------------------ | | | Branch (1357:2): [True: 0, False: 1.36k] | | ------------------ | | 1358| 0| case 56: result = tostruct_ninfo(rdata, target); break; \ | | ------------------ | | | Branch (1358:2): [True: 0, False: 1.36k] | | ------------------ | | 1359| 0| case 57: result = tostruct_rkey(rdata, target); break; \ | | ------------------ | | | Branch (1359:2): [True: 0, False: 1.36k] | | ------------------ | | 1360| 0| case 58: result = tostruct_talink(rdata, target); break; \ | | ------------------ | | | Branch (1360:2): [True: 0, False: 1.36k] | | ------------------ | | 1361| 0| case 59: result = tostruct_cds(rdata, target); break; \ | | ------------------ | | | Branch (1361:2): [True: 0, False: 1.36k] | | ------------------ | | 1362| 0| case 60: result = tostruct_cdnskey(rdata, target); break; \ | | ------------------ | | | Branch (1362:2): [True: 0, False: 1.36k] | | ------------------ | | 1363| 0| case 61: result = tostruct_openpgpkey(rdata, target); break; \ | | ------------------ | | | Branch (1363:2): [True: 0, False: 1.36k] | | ------------------ | | 1364| 0| case 62: result = tostruct_csync(rdata, target); break; \ | | ------------------ | | | Branch (1364:2): [True: 0, False: 1.36k] | | ------------------ | | 1365| 0| case 63: result = tostruct_zonemd(rdata, target); break; \ | | ------------------ | | | Branch (1365:2): [True: 0, False: 1.36k] | | ------------------ | | 1366| 0| case 64: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1366:2): [True: 0, False: 1.36k] | | ------------------ | | 1367| 0| case 1: result = tostruct_in_svcb(rdata, target); break; \ | | ------------------ | | | Branch (1367:3): [True: 0, False: 0] | | ------------------ | | 1368| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1368:3): [True: 0, False: 0] | | ------------------ | | 1369| 0| } \ | | 1370| 0| break; \ | | 1371| 0| case 65: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1371:2): [True: 0, False: 1.36k] | | ------------------ | | 1372| 0| case 1: result = tostruct_in_https(rdata, target); break; \ | | ------------------ | | | Branch (1372:3): [True: 0, False: 0] | | ------------------ | | 1373| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1373:3): [True: 0, False: 0] | | ------------------ | | 1374| 0| } \ | | 1375| 0| break; \ | | 1376| 0| case 66: result = tostruct_dsync(rdata, target); break; \ | | ------------------ | | | Branch (1376:2): [True: 0, False: 1.36k] | | ------------------ | | 1377| 0| case 67: result = tostruct_hhit(rdata, target); break; \ | | ------------------ | | | Branch (1377:2): [True: 0, False: 1.36k] | | ------------------ | | 1378| 0| case 68: result = tostruct_brid(rdata, target); break; \ | | ------------------ | | | Branch (1378:2): [True: 0, False: 1.36k] | | ------------------ | | 1379| 0| case 99: result = tostruct_spf(rdata, target); break; \ | | ------------------ | | | Branch (1379:2): [True: 0, False: 1.36k] | | ------------------ | | 1380| 0| case 104: result = tostruct_nid(rdata, target); break; \ | | ------------------ | | | Branch (1380:2): [True: 0, False: 1.36k] | | ------------------ | | 1381| 0| case 105: result = tostruct_l32(rdata, target); break; \ | | ------------------ | | | Branch (1381:2): [True: 0, False: 1.36k] | | ------------------ | | 1382| 0| case 106: result = tostruct_l64(rdata, target); break; \ | | ------------------ | | | Branch (1382:2): [True: 0, False: 1.36k] | | ------------------ | | 1383| 0| case 107: result = tostruct_lp(rdata, target); break; \ | | ------------------ | | | Branch (1383:2): [True: 0, False: 1.36k] | | ------------------ | | 1384| 0| case 108: result = tostruct_eui48(rdata, target); break; \ | | ------------------ | | | Branch (1384:2): [True: 0, False: 1.36k] | | ------------------ | | 1385| 0| case 109: result = tostruct_eui64(rdata, target); break; \ | | ------------------ | | | Branch (1385:2): [True: 0, False: 1.36k] | | ------------------ | | 1386| 0| case 249: result = tostruct_tkey(rdata, target); break; \ | | ------------------ | | | Branch (1386:2): [True: 0, False: 1.36k] | | ------------------ | | 1387| 748| case 250: switch (rdata->rdclass) { \ | | ------------------ | | | Branch (1387:2): [True: 748, False: 619] | | ------------------ | | 1388| 748| case 255: result = tostruct_any_tsig(rdata, target); break; \ | | ------------------ | | | Branch (1388:3): [True: 748, False: 0] | | ------------------ | | 1389| 0| default: use_default = true; break; \ | | ------------------ | | | Branch (1389:3): [True: 0, False: 748] | | ------------------ | | 1390| 748| } \ | | 1391| 748| break; \ | | 1392| 748| case 256: result = tostruct_uri(rdata, target); break; \ | | ------------------ | | | Branch (1392:2): [True: 0, False: 1.36k] | | ------------------ | | 1393| 748| case 257: result = tostruct_caa(rdata, target); break; \ | | ------------------ | | | Branch (1393:2): [True: 0, False: 1.36k] | | ------------------ | | 1394| 748| case 258: result = tostruct_avc(rdata, target); break; \ | | ------------------ | | | Branch (1394:2): [True: 0, False: 1.36k] | | ------------------ | | 1395| 748| case 259: result = tostruct_doa(rdata, target); break; \ | | ------------------ | | | Branch (1395:2): [True: 0, False: 1.36k] | | ------------------ | | 1396| 748| case 260: result = tostruct_amtrelay(rdata, target); break; \ | | ------------------ | | | Branch (1396:2): [True: 0, False: 1.36k] | | ------------------ | | 1397| 748| case 261: result = tostruct_resinfo(rdata, target); break; \ | | ------------------ | | | Branch (1397:2): [True: 0, False: 1.36k] | | ------------------ | | 1398| 748| case 262: result = tostruct_wallet(rdata, target); break; \ | | ------------------ | | | Branch (1398:2): [True: 0, False: 1.36k] | | ------------------ | | 1399| 748| case 32768: result = tostruct_ta(rdata, target); break; \ | | ------------------ | | | Branch (1399:2): [True: 0, False: 1.36k] | | ------------------ | | 1400| 748| case 32769: result = tostruct_dlv(rdata, target); break; \ | | ------------------ | | | Branch (1400:2): [True: 0, False: 1.36k] | | ------------------ | | 1401| 748| case 65533: result = tostruct_keydata(rdata, target); break; \ | | ------------------ | | | Branch (1401:2): [True: 0, False: 1.36k] | | ------------------ | | 1402| 748| default: use_default = true; break; \ | | ------------------ | | | Branch (1402:2): [True: 0, False: 1.36k] | | ------------------ | | 1403| 1.36k| } ------------------ 1387| | 1388| 1.36k| if (use_default) { ------------------ | Branch (1388:6): [True: 0, False: 1.36k] ------------------ 1389| 0| (void)NULL; 1390| 0| } 1391| | 1392| 1.36k| return result; 1393| 1.36k|} dns_rdatatype_attributes: 1463| 105|dns_rdatatype_attributes(dns_rdatatype_t type) { 1464| 105| RDATATYPE_ATTRIBUTE_SW ------------------ | | 2311| 105| switch (type) { \ | | ------------------ | | | Branch (2311:10): [True: 105, False: 0] | | ------------------ | | 2312| 0| case 1: return (RRTYPE_A_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_A_ATTRIBUTES (0) | | ------------------ | | | Branch (2312:2): [True: 0, False: 105] | | ------------------ | | 2313| 6| case 2: return (RRTYPE_NS_ATTRIBUTES); \ | | ------------------ | | | | 17| 6|#define RRTYPE_NS_ATTRIBUTES (DNS_RDATATYPEATTR_ZONECUTAUTH) | | ------------------ | | | Branch (2313:2): [True: 6, False: 99] | | ------------------ | | 2314| 0| case 3: return (RRTYPE_MD_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MD_ATTRIBUTES (0) | | ------------------ | | | Branch (2314:2): [True: 0, False: 105] | | ------------------ | | 2315| 0| case 4: return (RRTYPE_MF_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MF_ATTRIBUTES (0) | | ------------------ | | | Branch (2315:2): [True: 0, False: 105] | | ------------------ | | 2316| 0| case 5: return (RRTYPE_CNAME_ATTRIBUTES); \ | | ------------------ | | | | 18| 0| (DNS_RDATATYPEATTR_EXCLUSIVE | DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2316:2): [True: 0, False: 105] | | ------------------ | | 2317| 6| case 6: return (RRTYPE_SOA_ATTRIBUTES); \ | | ------------------ | | | | 17| 6|#define RRTYPE_SOA_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2317:2): [True: 6, False: 99] | | ------------------ | | 2318| 0| case 7: return (RRTYPE_MB_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MB_ATTRIBUTES (0) | | ------------------ | | | Branch (2318:2): [True: 0, False: 105] | | ------------------ | | 2319| 0| case 8: return (RRTYPE_MG_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MG_ATTRIBUTES (0) | | ------------------ | | | Branch (2319:2): [True: 0, False: 105] | | ------------------ | | 2320| 0| case 9: return (RRTYPE_MR_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MR_ATTRIBUTES (0) | | ------------------ | | | Branch (2320:2): [True: 0, False: 105] | | ------------------ | | 2321| 0| case 10: return (RRTYPE_NULL_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_NULL_ATTRIBUTES (0) | | ------------------ | | | Branch (2321:2): [True: 0, False: 105] | | ------------------ | | 2322| 0| case 11: return (RRTYPE_WKS_ATTRIBUTES); \ | | ------------------ | | | | 25| 0|#define RRTYPE_WKS_ATTRIBUTES (0) | | ------------------ | | | Branch (2322:2): [True: 0, False: 105] | | ------------------ | | 2323| 0| case 12: return (RRTYPE_PTR_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_PTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2323:2): [True: 0, False: 105] | | ------------------ | | 2324| 0| case 13: return (RRTYPE_HINFO_ATTRIBUTES); \ | | ------------------ | | | | 16| 0|#define RRTYPE_HINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2324:2): [True: 0, False: 105] | | ------------------ | | 2325| 0| case 14: return (RRTYPE_MINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_MINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2325:2): [True: 0, False: 105] | | ------------------ | | 2326| 0| case 15: return (RRTYPE_MX_ATTRIBUTES); \ | | ------------------ | | | | 23| 0|#define RRTYPE_MX_ATTRIBUTES (0) | | ------------------ | | | Branch (2326:2): [True: 0, False: 105] | | ------------------ | | 2327| 0| case 16: return (RRTYPE_TXT_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_TXT_ATTRIBUTES (0) | | ------------------ | | | Branch (2327:2): [True: 0, False: 105] | | ------------------ | | 2328| 0| case 17: return (RRTYPE_RP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_RP_ATTRIBUTES (0) | | ------------------ | | | Branch (2328:2): [True: 0, False: 105] | | ------------------ | | 2329| 0| case 18: return (RRTYPE_AFSDB_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_AFSDB_ATTRIBUTES (0) | | ------------------ | | | Branch (2329:2): [True: 0, False: 105] | | ------------------ | | 2330| 0| case 19: return (RRTYPE_X25_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_X25_ATTRIBUTES (0) | | ------------------ | | | Branch (2330:2): [True: 0, False: 105] | | ------------------ | | 2331| 0| case 20: return (RRTYPE_ISDN_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ISDN_ATTRIBUTES (0) | | ------------------ | | | Branch (2331:2): [True: 0, False: 105] | | ------------------ | | 2332| 0| case 21: return (RRTYPE_RT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_RT_ATTRIBUTES (0) | | ------------------ | | | Branch (2332:2): [True: 0, False: 105] | | ------------------ | | 2333| 0| case 22: return (RRTYPE_NSAP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NSAP_ATTRIBUTES (0) | | ------------------ | | | Branch (2333:2): [True: 0, False: 105] | | ------------------ | | 2334| 0| case 23: return (RRTYPE_NSAP_PTR_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NSAP_PTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2334:2): [True: 0, False: 105] | | ------------------ | | 2335| 87| case 24: return (RRTYPE_SIG_ATTRIBUTES); \ | | ------------------ | | | | 19| 87|#define RRTYPE_SIG_ATTRIBUTES (0) | | ------------------ | | | Branch (2335:2): [True: 87, False: 18] | | ------------------ | | 2336| 6| case 25: return (RRTYPE_KEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 6|#define RRTYPE_KEY_ATTRIBUTES (0) | | ------------------ | | | Branch (2336:2): [True: 6, False: 99] | | ------------------ | | 2337| 0| case 26: return (RRTYPE_PX_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_PX_ATTRIBUTES (0) | | ------------------ | | | Branch (2337:2): [True: 0, False: 105] | | ------------------ | | 2338| 0| case 27: return (RRTYPE_GPOS_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_GPOS_ATTRIBUTES (0) | | ------------------ | | | Branch (2338:2): [True: 0, False: 105] | | ------------------ | | 2339| 0| case 28: return (RRTYPE_AAAA_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_AAAA_ATTRIBUTES (0) | | ------------------ | | | Branch (2339:2): [True: 0, False: 105] | | ------------------ | | 2340| 0| case 29: return (RRTYPE_LOC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_LOC_ATTRIBUTES (0) | | ------------------ | | | Branch (2340:2): [True: 0, False: 105] | | ------------------ | | 2341| 0| case 30: return (RRTYPE_NXT_ATTRIBUTES); \ | | ------------------ | | | | 23| 0|#define RRTYPE_NXT_ATTRIBUTES (0) | | ------------------ | | | Branch (2341:2): [True: 0, False: 105] | | ------------------ | | 2342| 0| case 31: return (RRTYPE_EID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EID_ATTRIBUTES (0) | | ------------------ | | | Branch (2342:2): [True: 0, False: 105] | | ------------------ | | 2343| 0| case 32: return (RRTYPE_NIMLOC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NIMLOC_ATTRIBUTES (0) | | ------------------ | | | Branch (2343:2): [True: 0, False: 105] | | ------------------ | | 2344| 0| case 33: return (RRTYPE_SRV_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SRV_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2344:2): [True: 0, False: 105] | | ------------------ | | 2345| 0| case 34: return (RRTYPE_ATMA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ATMA_ATTRIBUTES (0) | | ------------------ | | | Branch (2345:2): [True: 0, False: 105] | | ------------------ | | 2346| 0| case 35: return (RRTYPE_NAPTR_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_NAPTR_ATTRIBUTES (0) | | ------------------ | | | Branch (2346:2): [True: 0, False: 105] | | ------------------ | | 2347| 0| case 36: return (RRTYPE_KX_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_KX_ATTRIBUTES (0) | | ------------------ | | | Branch (2347:2): [True: 0, False: 105] | | ------------------ | | 2348| 0| case 37: return (RRTYPE_CERT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CERT_ATTRIBUTES (0) | | ------------------ | | | Branch (2348:2): [True: 0, False: 105] | | ------------------ | | 2349| 0| case 38: return (RRTYPE_A6_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_A6_ATTRIBUTES (0) | | ------------------ | | | Branch (2349:2): [True: 0, False: 105] | | ------------------ | | 2350| 0| case 39: return (RRTYPE_DNAME_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DNAME_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2350:2): [True: 0, False: 105] | | ------------------ | | 2351| 0| case 40: return (RRTYPE_SINK_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SINK_ATTRIBUTES (0) | | ------------------ | | | Branch (2351:2): [True: 0, False: 105] | | ------------------ | | 2352| 0| case 41: return (RRTYPE_OPT_ATTRIBUTES); \ | | ------------------ | | | | 20| 0| (DNS_RDATATYPEATTR_SINGLETON | DNS_RDATATYPEATTR_META | \ | | | | 21| 0| DNS_RDATATYPEATTR_NOTQUESTION) | | ------------------ | | | Branch (2352:2): [True: 0, False: 105] | | ------------------ | | 2353| 0| case 42: return (RRTYPE_APL_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_APL_ATTRIBUTES (0) | | ------------------ | | | Branch (2353:2): [True: 0, False: 105] | | ------------------ | | 2354| 0| case 43: return (RRTYPE_DS_ATTRIBUTES); \ | | ------------------ | | | | 20| 0| (DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \ | | | | 21| 0| DNS_RDATATYPEATTR_ATPARENT) | | ------------------ | | | Branch (2354:2): [True: 0, False: 105] | | ------------------ | | 2355| 0| case 44: return (RRTYPE_SSHFP_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SSHFP_ATTRIBUTES (0) | | ------------------ | | | Branch (2355:2): [True: 0, False: 105] | | ------------------ | | 2356| 0| case 45: return (RRTYPE_IPSECKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_IPSECKEY_ATTRIBUTES (0) | | ------------------ | | | Branch (2356:2): [True: 0, False: 105] | | ------------------ | | 2357| 0| case 46: return (RRTYPE_RRSIG_ATTRIBUTES); \ | | ------------------ | | | | 20| 0| (DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \ | | | | 21| 0| DNS_RDATATYPEATTR_ATCNAME) | | ------------------ | | | Branch (2357:2): [True: 0, False: 105] | | ------------------ | | 2358| 0| case 47: return (RRTYPE_NSEC_ATTRIBUTES); \ | | ------------------ | | | | 24| 0| (DNS_RDATATYPEATTR_DNSSEC | DNS_RDATATYPEATTR_ZONECUTAUTH | \ | | | | 25| 0| DNS_RDATATYPEATTR_ATCNAME) | | ------------------ | | | Branch (2358:2): [True: 0, False: 105] | | ------------------ | | 2359| 0| case 48: return (RRTYPE_DNSKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_DNSKEY_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC) | | ------------------ | | | Branch (2359:2): [True: 0, False: 105] | | ------------------ | | 2360| 0| case 49: return (RRTYPE_DHCID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DHCID_ATTRIBUTES 0 | | ------------------ | | | Branch (2360:2): [True: 0, False: 105] | | ------------------ | | 2361| 0| case 50: return (RRTYPE_NSEC3_ATTRIBUTES); \ | | ------------------ | | | | 40| 0|#define RRTYPE_NSEC3_ATTRIBUTES DNS_RDATATYPEATTR_DNSSEC | | ------------------ | | | Branch (2361:2): [True: 0, False: 105] | | ------------------ | | 2362| 0| case 51: return (RRTYPE_NSEC3PARAM_ATTRIBUTES); \ | | ------------------ | | | | 38| 0|#define RRTYPE_NSEC3PARAM_ATTRIBUTES (DNS_RDATATYPEATTR_DNSSEC) | | ------------------ | | | Branch (2362:2): [True: 0, False: 105] | | ------------------ | | 2363| 0| case 52: return (RRTYPE_TLSA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TLSA_ATTRIBUTES 0 | | ------------------ | | | Branch (2363:2): [True: 0, False: 105] | | ------------------ | | 2364| 0| case 53: return (RRTYPE_SMIMEA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_SMIMEA_ATTRIBUTES 0 | | ------------------ | | | Branch (2364:2): [True: 0, False: 105] | | ------------------ | | 2365| 0| case 55: return (RRTYPE_HIP_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_HIP_ATTRIBUTES (0) | | ------------------ | | | Branch (2365:2): [True: 0, False: 105] | | ------------------ | | 2366| 0| case 56: return (RRTYPE_NINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_NINFO_ATTRIBUTES (0) | | ------------------ | | | Branch (2366:2): [True: 0, False: 105] | | ------------------ | | 2367| 0| case 57: return (RRTYPE_RKEY_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_RKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2367:2): [True: 0, False: 105] | | ------------------ | | 2368| 0| case 58: return (RRTYPE_TALINK_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_TALINK_ATTRIBUTES 0 | | ------------------ | | | Branch (2368:2): [True: 0, False: 105] | | ------------------ | | 2369| 0| case 59: return (RRTYPE_CDS_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CDS_ATTRIBUTES 0 | | ------------------ | | | Branch (2369:2): [True: 0, False: 105] | | ------------------ | | 2370| 0| case 60: return (RRTYPE_CDNSKEY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_CDNSKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2370:2): [True: 0, False: 105] | | ------------------ | | 2371| 0| case 61: return (RRTYPE_OPENPGPKEY_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_OPENPGPKEY_ATTRIBUTES 0 | | ------------------ | | | Branch (2371:2): [True: 0, False: 105] | | ------------------ | | 2372| 0| case 62: return (RRTYPE_CSYNC_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_CSYNC_ATTRIBUTES 0 | | ------------------ | | | Branch (2372:2): [True: 0, False: 105] | | ------------------ | | 2373| 0| case 63: return (RRTYPE_ZONEMD_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_ZONEMD_ATTRIBUTES 0 | | ------------------ | | | Branch (2373:2): [True: 0, False: 105] | | ------------------ | | 2374| 0| case 64: return (RRTYPE_SVCB_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_SVCB_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2374:2): [True: 0, False: 105] | | ------------------ | | 2375| 0| case 65: return (RRTYPE_HTTPS_ATTRIBUTES); \ | | ------------------ | | | | 18| 0|#define RRTYPE_HTTPS_ATTRIBUTES (DNS_RDATATYPEATTR_FOLLOWADDITIONAL) | | ------------------ | | | Branch (2375:2): [True: 0, False: 105] | | ------------------ | | 2376| 0| case 66: return (RRTYPE_DSYNC_ATTRIBUTES); \ | | ------------------ | | | | 24| 0|#define RRTYPE_DSYNC_ATTRIBUTES (0) | | ------------------ | | | Branch (2376:2): [True: 0, False: 105] | | ------------------ | | 2377| 0| case 67: return (RRTYPE_HHIT_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_HHIT_ATTRIBUTES (0) | | ------------------ | | | Branch (2377:2): [True: 0, False: 105] | | ------------------ | | 2378| 0| case 68: return (RRTYPE_BRID_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_BRID_ATTRIBUTES (0) | | ------------------ | | | Branch (2378:2): [True: 0, False: 105] | | ------------------ | | 2379| 0| case 99: return (RRTYPE_SPF_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_SPF_ATTRIBUTES (0) | | ------------------ | | | Branch (2379:2): [True: 0, False: 105] | | ------------------ | | 2380| 0| case 100: return (0); \ | | ------------------ | | | Branch (2380:2): [True: 0, False: 105] | | ------------------ | | 2381| 0| case 101: return (0); \ | | ------------------ | | | Branch (2381:2): [True: 0, False: 105] | | ------------------ | | 2382| 0| case 102: return (0); \ | | ------------------ | | | Branch (2382:2): [True: 0, False: 105] | | ------------------ | | 2383| 0| case 103: return (0); \ | | ------------------ | | | Branch (2383:2): [True: 0, False: 105] | | ------------------ | | 2384| 0| case 104: return (RRTYPE_NID_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_NID_ATTRIBUTES (0) | | ------------------ | | | Branch (2384:2): [True: 0, False: 105] | | ------------------ | | 2385| 0| case 105: return (RRTYPE_L32_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_L32_ATTRIBUTES (0) | | ------------------ | | | Branch (2385:2): [True: 0, False: 105] | | ------------------ | | 2386| 0| case 106: return (RRTYPE_L64_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_L64_ATTRIBUTES (0) | | ------------------ | | | Branch (2386:2): [True: 0, False: 105] | | ------------------ | | 2387| 0| case 107: return (RRTYPE_LP_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_LP_ATTRIBUTES (0) | | ------------------ | | | Branch (2387:2): [True: 0, False: 105] | | ------------------ | | 2388| 0| case 108: return (RRTYPE_EUI48_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EUI48_ATTRIBUTES (0) | | ------------------ | | | Branch (2388:2): [True: 0, False: 105] | | ------------------ | | 2389| 0| case 109: return (RRTYPE_EUI64_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_EUI64_ATTRIBUTES (0) | | ------------------ | | | Branch (2389:2): [True: 0, False: 105] | | ------------------ | | 2390| 0| case 128: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_NOTQUESTION); \ | | ------------------ | | | Branch (2390:2): [True: 0, False: 105] | | ------------------ | | 2391| 0| case 249: return (RRTYPE_TKEY_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TKEY_ATTRIBUTES (DNS_RDATATYPEATTR_META) | | ------------------ | | | Branch (2391:2): [True: 0, False: 105] | | ------------------ | | 2392| 0| case 250: return (RRTYPE_TSIG_ATTRIBUTES); \ | | ------------------ | | | | 18| 0| (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_NOTQUESTION) | | ------------------ | | | Branch (2392:2): [True: 0, False: 105] | | ------------------ | | 2393| 0| case 251: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2393:2): [True: 0, False: 105] | | ------------------ | | 2394| 0| case 252: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2394:2): [True: 0, False: 105] | | ------------------ | | 2395| 0| case 253: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2395:2): [True: 0, False: 105] | | ------------------ | | 2396| 0| case 254: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2396:2): [True: 0, False: 105] | | ------------------ | | 2397| 0| case 255: return (DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY); \ | | ------------------ | | | Branch (2397:2): [True: 0, False: 105] | | ------------------ | | 2398| 0| case 256: return (RRTYPE_URI_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_URI_ATTRIBUTES (0) | | ------------------ | | | Branch (2398:2): [True: 0, False: 105] | | ------------------ | | 2399| 0| case 257: return (RRTYPE_CAA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_CAA_ATTRIBUTES (0) | | ------------------ | | | Branch (2399:2): [True: 0, False: 105] | | ------------------ | | 2400| 0| case 258: return (RRTYPE_AVC_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_AVC_ATTRIBUTES (0) | | ------------------ | | | Branch (2400:2): [True: 0, False: 105] | | ------------------ | | 2401| 0| case 259: return (RRTYPE_DOA_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_DOA_ATTRIBUTES (0) | | ------------------ | | | Branch (2401:2): [True: 0, False: 105] | | ------------------ | | 2402| 0| case 260: return (RRTYPE_AMTRELAY_ATTRIBUTES); \ | | ------------------ | | | | 21| 0|#define RRTYPE_AMTRELAY_ATTRIBUTES (0) | | ------------------ | | | Branch (2402:2): [True: 0, False: 105] | | ------------------ | | 2403| 0| case 261: return (RRTYPE_RESINFO_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_RESINFO_ATTRIBUTES (DNS_RDATATYPEATTR_SINGLETON) | | ------------------ | | | Branch (2403:2): [True: 0, False: 105] | | ------------------ | | 2404| 0| case 262: return (RRTYPE_WALLET_ATTRIBUTES); \ | | ------------------ | | | | 17| 0|#define RRTYPE_WALLET_ATTRIBUTES (0) | | ------------------ | | | Branch (2404:2): [True: 0, False: 105] | | ------------------ | | 2405| 0| case 32768: return (RRTYPE_TA_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_TA_ATTRIBUTES 0 | | ------------------ | | | Branch (2405:2): [True: 0, False: 105] | | ------------------ | | 2406| 0| case 32769: return (RRTYPE_DLV_ATTRIBUTES); \ | | ------------------ | | | | 19| 0|#define RRTYPE_DLV_ATTRIBUTES 0 | | ------------------ | | | Branch (2406:2): [True: 0, False: 105] | | ------------------ | | 2407| 0| case 65533: return (RRTYPE_KEYDATA_ATTRIBUTES); \ | | ------------------ | | | | 22| 0|#define RRTYPE_KEYDATA_ATTRIBUTES (0) | | ------------------ | | | Branch (2407:2): [True: 0, False: 105] | | ------------------ | | 2408| 105| } ------------------ 1465| 0| if (type >= (dns_rdatatype_t)128 && type <= (dns_rdatatype_t)255) { ------------------ | Branch (1465:6): [True: 0, False: 0] | Branch (1465:38): [True: 0, False: 0] ------------------ 1466| 0| return DNS_RDATATYPEATTR_UNKNOWN | DNS_RDATATYPEATTR_META; 1467| 0| } 1468| 0| return DNS_RDATATYPEATTR_UNKNOWN; 1469| 0|} dns_rdatatype_fromtext: 1472| 6|dns_rdatatype_fromtext(dns_rdatatype_t *typep, isc_textregion_t *source) { 1473| 6| unsigned int hash; 1474| 6| unsigned int n; 1475| 6| unsigned char a, b; 1476| | 1477| 6| n = source->length; 1478| | 1479| 6| if (n == 0) { ------------------ | Branch (1479:6): [True: 0, False: 6] ------------------ 1480| 0| return DNS_R_UNKNOWN; 1481| 0| } 1482| | 1483| 6| a = isc_ascii_tolower(source->base[0]); ------------------ | | 31| 6|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 1484| 6| b = isc_ascii_tolower(source->base[n - 1]); ------------------ | | 31| 6|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 1485| | 1486| 6| hash = ((a + n) * b) % 256; 1487| | 1488| | /* 1489| | * This switch block is inlined via \#define, and will use "return" 1490| | * to return a result to the caller if it is a valid (known) 1491| | * rdatatype name. 1492| | */ 1493| 6| RDATATYPE_FROMTEXT_SW(hash, source->base, n, typep); ------------------ | | 2060| 6| switch (_hash) { \ | | ------------------ | | | Branch (2060:10): [True: 6, False: 0] | | ------------------ | | 2061| 0| case 34: \ | | ------------------ | | | Branch (2061:3): [True: 0, False: 6] | | ------------------ | | 2062| 0| RDATATYPE_COMPARE("a", 1, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2063| 0| break; \ | | 2064| 2| case 80: \ | | ------------------ | | | Branch (2064:3): [True: 2, False: 4] | | ------------------ | | 2065| 2| RDATATYPE_COMPARE("ns", 2, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 2| do { \ | | | | 2050| 2| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 2, False: 0] | | | | ------------------ | | | | 2051| 2| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 2, False: 0] | | | | ------------------ | | | | 2052| 2| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 2] | | | | ------------------ | | | | 2053| 2| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 2| *(_tp) = _d; \ | | | | 2055| 2| return (ISC_R_SUCCESS); \ | | | | 2056| 2| } \ | | | | 2057| 2| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2066| 2| break; \ | | 2067| 2| case 92: \ | | ------------------ | | | Branch (2067:3): [True: 0, False: 6] | | ------------------ | | 2068| 0| RDATATYPE_COMPARE("md", 3, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2069| 0| break; \ | | 2070| 0| case 58: \ | | ------------------ | | | Branch (2070:3): [True: 0, False: 6] | | ------------------ | | 2071| 0| RDATATYPE_COMPARE("mf", 4, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2072| 0| break; \ | | 2073| 0| case 8: \ | | ------------------ | | | Branch (2073:3): [True: 0, False: 6] | | ------------------ | | 2074| 0| RDATATYPE_COMPARE("cname", 5, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2075| 0| RDATATYPE_COMPARE("mx", 15, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2076| 0| break; \ | | 2077| 2| case 182: \ | | ------------------ | | | Branch (2077:3): [True: 2, False: 4] | | ------------------ | | 2078| 2| RDATATYPE_COMPARE("soa", 6, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 2| do { \ | | | | 2050| 2| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 2, False: 0] | | | | ------------------ | | | | 2051| 2| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 2, False: 0] | | | | ------------------ | | | | 2052| 2| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 2] | | | | ------------------ | | | | 2053| 2| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 2| *(_tp) = _d; \ | | | | 2055| 2| return (ISC_R_SUCCESS); \ | | | | 2056| 2| } \ | | | | 2057| 2| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2079| 2| RDATATYPE_COMPARE("ta", 32768, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2080| 0| break; \ | | 2081| 0| case 126: \ | | ------------------ | | | Branch (2081:3): [True: 0, False: 6] | | ------------------ | | 2082| 0| RDATATYPE_COMPARE("mb", 7, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2083| 0| break; \ | | 2084| 0| case 169: \ | | ------------------ | | | Branch (2084:3): [True: 0, False: 6] | | ------------------ | | 2085| 0| RDATATYPE_COMPARE("mg", 8, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2086| 0| break; \ | | 2087| 0| case 110: \ | | ------------------ | | | Branch (2087:3): [True: 0, False: 6] | | ------------------ | | 2088| 0| RDATATYPE_COMPARE("mr", 9, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2089| 0| RDATATYPE_COMPARE("minfo", 14, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2090| 0| break; \ | | 2091| 0| case 24: \ | | ------------------ | | | Branch (2091:3): [True: 0, False: 6] | | ------------------ | | 2092| 0| RDATATYPE_COMPARE("null", 10, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2093| 0| RDATATYPE_COMPARE("kx", 36, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2094| 0| RDATATYPE_COMPARE("nsec3param", 51, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2095| 0| break; \ | | 2096| 0| case 206: \ | | ------------------ | | | Branch (2096:3): [True: 0, False: 6] | | ------------------ | | 2097| 0| RDATATYPE_COMPARE("wks", 11, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2098| 0| break; \ | | 2099| 0| case 54: \ | | ------------------ | | | Branch (2099:3): [True: 0, False: 6] | | ------------------ | | 2100| 0| RDATATYPE_COMPARE("ptr", 12, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2101| 0| RDATATYPE_COMPARE("naptr", 35, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2102| 0| break; \ | | 2103| 0| case 67: \ | | ------------------ | | | Branch (2103:3): [True: 0, False: 6] | | ------------------ | | 2104| 0| RDATATYPE_COMPARE("hinfo", 13, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2105| 0| break; \ | | 2106| 0| case 236: \ | | ------------------ | | | Branch (2106:3): [True: 0, False: 6] | | ------------------ | | 2107| 0| RDATATYPE_COMPARE("txt", 16, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2108| 0| break; \ | | 2109| 0| case 192: \ | | ------------------ | | | Branch (2109:3): [True: 0, False: 6] | | ------------------ | | 2110| 0| RDATATYPE_COMPARE("rp", 17, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2111| 0| break; \ | | 2112| 0| case 12: \ | | ------------------ | | | Branch (2112:3): [True: 0, False: 6] | | ------------------ | | 2113| 0| RDATATYPE_COMPARE("afsdb", 18, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2114| 0| break; \ | | 2115| 0| case 119: \ | | ------------------ | | | Branch (2115:3): [True: 0, False: 6] | | ------------------ | | 2116| 0| RDATATYPE_COMPARE("x25", 19, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2117| 0| RDATATYPE_COMPARE("resinfo", 261, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2118| 0| break; \ | | 2119| 0| case 214: \ | | ------------------ | | | Branch (2119:3): [True: 0, False: 6] | | ------------------ | | 2120| 0| RDATATYPE_COMPARE("isdn", 20, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2121| 0| break; \ | | 2122| 0| case 144: \ | | ------------------ | | | Branch (2122:3): [True: 0, False: 6] | | ------------------ | | 2123| 0| RDATATYPE_COMPARE("rt", 21, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2124| 0| break; \ | | 2125| 0| case 224: \ | | ------------------ | | | Branch (2125:3): [True: 0, False: 6] | | ------------------ | | 2126| 0| RDATATYPE_COMPARE("nsap", 22, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2127| 0| RDATATYPE_COMPARE("uid", 101, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2128| 0| break; \ | | 2129| 0| case 140: \ | | ------------------ | | | Branch (2129:3): [True: 0, False: 6] | | ------------------ | | 2130| 0| RDATATYPE_COMPARE("nsap-ptr", 23, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2131| 0| RDATATYPE_COMPARE("l64", 106, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2132| 0| break; \ | | 2133| 0| case 122: \ | | ------------------ | | | Branch (2133:3): [True: 0, False: 6] | | ------------------ | | 2134| 0| RDATATYPE_COMPARE("sig", 24, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2135| 0| RDATATYPE_COMPARE("dlv", 32769, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2136| 0| break; \ | | 2137| 2| case 254: \ | | ------------------ | | | Branch (2137:3): [True: 2, False: 4] | | ------------------ | | 2138| 2| RDATATYPE_COMPARE("key", 25, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 2| do { \ | | | | 2050| 2| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 2, False: 0] | | | | ------------------ | | | | 2051| 2| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 2, False: 0] | | | | ------------------ | | | | 2052| 2| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 2] | | | | ------------------ | | | | 2053| 2| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 2| *(_tp) = _d; \ | | | | 2055| 2| return (ISC_R_SUCCESS); \ | | | | 2056| 2| } \ | | | | 2057| 2| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2139| 2| RDATATYPE_COMPARE("talink", 58, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2140| 0| break; \ | | 2141| 0| case 112: \ | | ------------------ | | | Branch (2141:3): [True: 0, False: 6] | | ------------------ | | 2142| 0| RDATATYPE_COMPARE("px", 26, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2143| 0| break; \ | | 2144| 0| case 17: \ | | ------------------ | | | Branch (2144:3): [True: 0, False: 6] | | ------------------ | | 2145| 0| RDATATYPE_COMPARE("gpos", 27, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2146| 0| break; \ | | 2147| 0| case 69: \ | | ------------------ | | | Branch (2147:3): [True: 0, False: 6] | | ------------------ | | 2148| 0| RDATATYPE_COMPARE("aaaa", 28, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2149| 0| RDATATYPE_COMPARE("atma", 34, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2150| 0| break; \ | | 2151| 0| case 237: \ | | ------------------ | | | Branch (2151:3): [True: 0, False: 6] | | ------------------ | | 2152| 0| RDATATYPE_COMPARE("loc", 29, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2153| 0| break; \ | | 2154| 0| case 52: \ | | ------------------ | | | Branch (2154:3): [True: 0, False: 6] | | ------------------ | | 2155| 0| RDATATYPE_COMPARE("nxt", 30, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2156| 0| break; \ | | 2157| 0| case 160: \ | | ------------------ | | | Branch (2157:3): [True: 0, False: 6] | | ------------------ | | 2158| 0| RDATATYPE_COMPARE("eid", 31, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2159| 0| break; \ | | 2160| 0| case 220: \ | | ------------------ | | | Branch (2160:3): [True: 0, False: 6] | | ------------------ | | 2161| 0| RDATATYPE_COMPARE("nimloc", 32, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2162| 0| break; \ | | 2163| 0| case 100: \ | | ------------------ | | | Branch (2163:3): [True: 0, False: 6] | | ------------------ | | 2164| 0| RDATATYPE_COMPARE("srv", 33, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2165| 0| break; \ | | 2166| 0| case 172: \ | | ------------------ | | | Branch (2166:3): [True: 0, False: 6] | | ------------------ | | 2167| 0| RDATATYPE_COMPARE("cert", 37, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2168| 0| RDATATYPE_COMPARE("avc", 258, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2169| 0| break; \ | | 2170| 0| case 226: \ | | ------------------ | | | Branch (2170:3): [True: 0, False: 6] | | ------------------ | | 2171| 0| RDATATYPE_COMPARE("a6", 38, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2172| 0| break; \ | | 2173| 0| case 109: \ | | ------------------ | | | Branch (2173:3): [True: 0, False: 6] | | ------------------ | | 2174| 0| RDATATYPE_COMPARE("dname", 39, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2175| 0| break; \ | | 2176| 0| case 189: \ | | ------------------ | | | Branch (2176:3): [True: 0, False: 6] | | ------------------ | | 2177| 0| RDATATYPE_COMPARE("sink", 40, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2178| 0| break; \ | | 2179| 0| case 168: \ | | ------------------ | | | Branch (2179:3): [True: 0, False: 6] | | ------------------ | | 2180| 0| RDATATYPE_COMPARE("opt", 41, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2181| 0| break; \ | | 2182| 0| case 48: \ | | ------------------ | | | Branch (2182:3): [True: 0, False: 6] | | ------------------ | | 2183| 0| RDATATYPE_COMPARE("apl", 42, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2184| 0| RDATATYPE_COMPARE("eui48", 108, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2185| 0| break; \ | | 2186| 0| case 210: \ | | ------------------ | | | Branch (2186:3): [True: 0, False: 6] | | ------------------ | | 2187| 0| RDATATYPE_COMPARE("ds", 43, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2188| 0| RDATATYPE_COMPARE("cds", 59, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2189| 0| break; \ | | 2190| 0| case 128: \ | | ------------------ | | | Branch (2190:3): [True: 0, False: 6] | | ------------------ | | 2191| 0| RDATATYPE_COMPARE("sshfp", 44, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2192| 0| break; \ | | 2193| 0| case 105: \ | | ------------------ | | | Branch (2193:3): [True: 0, False: 6] | | ------------------ | | 2194| 0| RDATATYPE_COMPARE("ipseckey", 45, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2195| 0| break; \ | | 2196| 0| case 225: \ | | ------------------ | | | Branch (2196:3): [True: 0, False: 6] | | ------------------ | | 2197| 0| RDATATYPE_COMPARE("rrsig", 46, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2198| 0| break; \ | | 2199| 0| case 22: \ | | ------------------ | | | Branch (2199:3): [True: 0, False: 6] | | ------------------ | | 2200| 0| RDATATYPE_COMPARE("nsec", 47, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2201| 0| break; \ | | 2202| 0| case 26: \ | | ------------------ | | | Branch (2202:3): [True: 0, False: 6] | | ------------------ | | 2203| 0| RDATATYPE_COMPARE("dnskey", 48, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2204| 0| RDATATYPE_COMPARE("cdnskey", 60, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2205| 0| break; \ | | 2206| 0| case 4: \ | | ------------------ | | | Branch (2206:3): [True: 0, False: 6] | | ------------------ | | 2207| 0| RDATATYPE_COMPARE("dhcid", 49, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2208| 0| RDATATYPE_COMPARE("spf", 99, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2209| 0| break; \ | | 2210| 0| case 233: \ | | ------------------ | | | Branch (2210:3): [True: 0, False: 6] | | ------------------ | | 2211| 0| RDATATYPE_COMPARE("nsec3", 50, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2212| 0| break; \ | | 2213| 0| case 120: \ | | ------------------ | | | Branch (2213:3): [True: 0, False: 6] | | ------------------ | | 2214| 0| RDATATYPE_COMPARE("tlsa", 52, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2215| 0| break; \ | | 2216| 0| case 217: \ | | ------------------ | | | Branch (2216:3): [True: 0, False: 6] | | ------------------ | | 2217| 0| RDATATYPE_COMPARE("smimea", 53, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2218| 0| break; \ | | 2219| 0| case 208: \ | | ------------------ | | | Branch (2219:3): [True: 0, False: 6] | | ------------------ | | 2220| 0| RDATATYPE_COMPARE("hip", 55, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2221| 0| break; \ | | 2222| 0| case 221: \ | | ------------------ | | | Branch (2222:3): [True: 0, False: 6] | | ------------------ | | 2223| 0| RDATATYPE_COMPARE("ninfo", 56, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2224| 0| break; \ | | 2225| 0| case 198: \ | | ------------------ | | | Branch (2225:3): [True: 0, False: 6] | | ------------------ | | 2226| 0| RDATATYPE_COMPARE("rkey", 57, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2227| 0| break; \ | | 2228| 0| case 49: \ | | ------------------ | | | Branch (2228:3): [True: 0, False: 6] | | ------------------ | | 2229| 0| RDATATYPE_COMPARE("openpgpkey", 61, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2230| 0| break; \ | | 2231| 0| case 56: \ | | ------------------ | | | Branch (2231:3): [True: 0, False: 6] | | ------------------ | | 2232| 0| RDATATYPE_COMPARE("csync", 62, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2233| 0| RDATATYPE_COMPARE("uri", 256, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2234| 0| break; \ | | 2235| 0| case 0: \ | | ------------------ | | | Branch (2235:3): [True: 0, False: 6] | | ------------------ | | 2236| 0| RDATATYPE_COMPARE("zonemd", 63, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2237| 0| break; \ | | 2238| 0| case 142: \ | | ------------------ | | | Branch (2238:3): [True: 0, False: 6] | | ------------------ | | 2239| 0| RDATATYPE_COMPARE("svcb", 64, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2240| 0| break; \ | | 2241| 0| case 247: \ | | ------------------ | | | Branch (2241:3): [True: 0, False: 6] | | ------------------ | | 2242| 0| RDATATYPE_COMPARE("https", 65, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2243| 0| break; \ | | 2244| 0| case 155: \ | | ------------------ | | | Branch (2244:3): [True: 0, False: 6] | | ------------------ | | 2245| 0| RDATATYPE_COMPARE("dsync", 66, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2246| 0| break; \ | | 2247| 0| case 240: \ | | ------------------ | | | Branch (2247:3): [True: 0, False: 6] | | ------------------ | | 2248| 0| RDATATYPE_COMPARE("hhit", 67, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2249| 0| break; \ | | 2250| 0| case 216: \ | | ------------------ | | | Branch (2250:3): [True: 0, False: 6] | | ------------------ | | 2251| 0| RDATATYPE_COMPARE("brid", 68, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2252| 0| break; \ | | 2253| 0| case 230: \ | | ------------------ | | | Branch (2253:3): [True: 0, False: 6] | | ------------------ | | 2254| 0| RDATATYPE_COMPARE("uinfo", 100, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2255| 0| break; \ | | 2256| 0| case 104: \ | | ------------------ | | | Branch (2256:3): [True: 0, False: 6] | | ------------------ | | 2257| 0| RDATATYPE_COMPARE("gid", 102, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2258| 0| break; \ | | 2259| 0| case 145: \ | | ------------------ | | | Branch (2259:3): [True: 0, False: 6] | | ------------------ | | 2260| 0| RDATATYPE_COMPARE("unspec", 103, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2261| 0| break; \ | | 2262| 0| case 36: \ | | ------------------ | | | Branch (2262:3): [True: 0, False: 6] | | ------------------ | | 2263| 0| RDATATYPE_COMPARE("nid", 104, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2264| 0| break; \ | | 2265| 0| case 174: \ | | ------------------ | | | Branch (2265:3): [True: 0, False: 6] | | ------------------ | | 2266| 0| RDATATYPE_COMPARE("l32", 105, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2267| 0| break; \ | | 2268| 0| case 32: \ | | ------------------ | | | Branch (2268:3): [True: 0, False: 6] | | ------------------ | | 2269| 0| RDATATYPE_COMPARE("lp", 107, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2270| 0| break; \ | | 2271| 0| case 136: \ | | ------------------ | | | Branch (2271:3): [True: 0, False: 6] | | ------------------ | | 2272| 0| RDATATYPE_COMPARE("eui64", 109, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2273| 0| break; \ | | 2274| 0| case 196: \ | | ------------------ | | | Branch (2274:3): [True: 0, False: 6] | | ------------------ | | 2275| 0| RDATATYPE_COMPARE("nxname", 128, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2276| 0| break; \ | | 2277| 0| case 184: \ | | ------------------ | | | Branch (2277:3): [True: 0, False: 6] | | ------------------ | | 2278| 0| RDATATYPE_COMPARE("tkey", 249, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2279| 0| break; \ | | 2280| 0| case 72: \ | | ------------------ | | | Branch (2280:3): [True: 0, False: 6] | | ------------------ | | 2281| 0| RDATATYPE_COMPARE("tsig", 250, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2282| 0| break; \ | | 2283| 0| case 138: \ | | ------------------ | | | Branch (2283:3): [True: 0, False: 6] | | ------------------ | | 2284| 0| RDATATYPE_COMPARE("ixfr", 251, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2285| 0| break; \ | | 2286| 0| case 250: \ | | ------------------ | | | Branch (2286:3): [True: 0, False: 6] | | ------------------ | | 2287| 0| RDATATYPE_COMPARE("axfr", 252, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2288| 0| break; \ | | 2289| 0| case 164: \ | | ------------------ | | | Branch (2289:3): [True: 0, False: 6] | | ------------------ | | 2290| 0| RDATATYPE_COMPARE("mailb", 253, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2291| 0| RDATATYPE_COMPARE("wallet", 262, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2292| 0| break; \ | | 2293| 0| case 50: \ | | ------------------ | | | Branch (2293:3): [True: 0, False: 6] | | ------------------ | | 2294| 0| RDATATYPE_COMPARE("maila", 254, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2295| 0| RDATATYPE_COMPARE("keydata", 65533, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2296| 0| break; \ | | 2297| 0| case 68: \ | | ------------------ | | | Branch (2297:3): [True: 0, False: 6] | | ------------------ | | 2298| 0| RDATATYPE_COMPARE("any", 255, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2299| 0| break; \ | | 2300| 0| case 166: \ | | ------------------ | | | Branch (2300:3): [True: 0, False: 6] | | ------------------ | | 2301| 0| RDATATYPE_COMPARE("caa", 257, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2302| 0| break; \ | | 2303| 0| case 7: \ | | ------------------ | | | Branch (2303:3): [True: 0, False: 6] | | ------------------ | | 2304| 0| RDATATYPE_COMPARE("doa", 259, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2305| 0| break; \ | | 2306| 0| case 161: \ | | ------------------ | | | Branch (2306:3): [True: 0, False: 6] | | ------------------ | | 2307| 0| RDATATYPE_COMPARE("amtrelay", 260, _typename, _length, _typep); \ | | ------------------ | | | | 2049| 0| do { \ | | | | 2050| 0| if (sizeof(_s) - 1 == _n && \ | | | | ------------------ | | | | | Branch (2050:7): [True: 0, False: 0] | | | | ------------------ | | | | 2051| 0| strncasecmp(_s,(_tn),(sizeof(_s) - 1)) == 0) { \ | | | | ------------------ | | | | | Branch (2051:7): [True: 0, False: 0] | | | | ------------------ | | | | 2052| 0| if ((dns_rdatatype_attributes(_d) & DNS_RDATATYPEATTR_RESERVED) != 0) \ | | | | ------------------ | | | | | Branch (2052:8): [True: 0, False: 0] | | | | ------------------ | | | | 2053| 0| return (ISC_R_NOTIMPLEMENTED); \ | | | | 2054| 0| *(_tp) = _d; \ | | | | 2055| 0| return (ISC_R_SUCCESS); \ | | | | 2056| 0| } \ | | | | 2057| 0| } while (0) | | | | ------------------ | | | | | Branch (2057:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 2308| 0| break; \ | | 2309| 6| } ------------------ 1494| | 1495| 0| if (source->length > 4 && source->length < (4 + sizeof("65000")) && ------------------ | Branch (1495:6): [True: 0, False: 0] | Branch (1495:28): [True: 0, False: 0] ------------------ 1496| 0| strncasecmp("type", source->base, 4) == 0) ------------------ | Branch (1496:6): [True: 0, False: 0] ------------------ 1497| 0| { 1498| 0| char buf[sizeof("65000")]; 1499| | 1500| | /* 1501| | * source->base is not required to be NUL terminated. 1502| | * Copy up to remaining bytes and NUL terminate. 1503| | */ 1504| 0| snprintf(buf, sizeof(buf), "%.*s", (int)(source->length - 4), 1505| 0| source->base + 4); 1506| 0| RETERR(isc_parse_unsigned_number(typep, buf, 10)); ------------------ | | 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| } ------------------ 1507| 0| return ISC_R_SUCCESS; 1508| 0| } 1509| | 1510| 0| return DNS_R_UNKNOWN; 1511| 0|} dns_rdata_covers: 2278| 512|dns_rdata_covers(dns_rdata_t *rdata) { 2279| 512| if (rdata->type == dns_rdatatype_rrsig) { ------------------ | | 161| 512|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (2279:6): [True: 0, False: 512] ------------------ 2280| 0| return covers_rrsig(rdata); 2281| 0| } 2282| 512| return covers_sig(rdata); 2283| 512|} rdata.c:uint8_fromregion: 2122| 1.23k|uint8_fromregion(isc_region_t *region) { 2123| 1.23k| REQUIRE(region->length >= 1); ------------------ | | 198| 1.23k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.23k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.23k, False: 0] | | | | ------------------ | | | | 42| 1.23k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2124| | 2125| 1.23k| return region->base[0]; 2126| 1.23k|} rdata.c:name_length: 1559| 1.25k|name_length(const dns_name_t *name) { 1560| 1.25k| return name->length; 1561| 1.25k|} rdata.c:mem_tobuffer: 2137| 5.05k|mem_tobuffer(isc_buffer_t *target, void *base, unsigned int length) { 2138| 5.05k| isc_region_t tr; 2139| | 2140| 5.05k| if (length == 0U) { ------------------ | Branch (2140:6): [True: 0, False: 5.05k] ------------------ 2141| 0| return ISC_R_SUCCESS; 2142| 0| } 2143| | 2144| 5.05k| isc_buffer_availableregion(target, &tr); 2145| 5.05k| if (length > tr.length) { ------------------ | Branch (2145:6): [True: 368, False: 4.68k] ------------------ 2146| 368| return ISC_R_NOSPACE; 2147| 368| } 2148| 4.68k| if (tr.base != base) { ------------------ | Branch (2148:6): [True: 4.68k, False: 0] ------------------ 2149| 4.68k| memmove(tr.base, base, length); 2150| 4.68k| } 2151| 4.68k| isc_buffer_add(target, length); 2152| 4.68k| return ISC_R_SUCCESS; 2153| 5.05k|} rdata.c:check_private: 550| 333|check_private(isc_buffer_t *source, dns_secalg_t alg) { 551| 333| isc_region_t sr; 552| 333| if (alg == DNS_KEYALG_PRIVATEDNS) { ------------------ | Branch (552:6): [True: 189, False: 144] ------------------ 553| 189| dns_fixedname_t fixed; 554| | 555| 189| RETERR(dns_name_fromwire(dns_fixedname_initname(&fixed), source, ------------------ | | 276| 189| { \ | | 277| 189| isc_result_t _r = (x); \ | | 278| 189| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 2, False: 187] | | ------------------ | | 279| 2| return ((_r)); \ | | 280| 2| } \ | | 281| 189| } ------------------ 556| 189| DNS_DECOMPRESS_NEVER, NULL)); 557| 187| } else if (alg == DNS_KEYALG_PRIVATEOID) { ------------------ | Branch (557:13): [True: 144, False: 0] ------------------ 558| | /* 559| | * Check that we can extract the OID from the start of the 560| | * key data. We have a length byte followed by the OID BER 561| | * encoded. 562| | */ 563| 144| const unsigned char *in = NULL; 564| 144| ASN1_OBJECT *obj = NULL; 565| | 566| 144| isc_buffer_activeregion(source, &sr); 567| 144| if (sr.length < 1 || (unsigned int)*sr.base + 1 > sr.length) { ------------------ | Branch (567:7): [True: 0, False: 144] | Branch (567:24): [True: 11, False: 133] ------------------ 568| 11| RETERR(DNS_R_FORMERR); ------------------ | | 276| 11| { \ | | 277| 11| isc_result_t _r = (x); \ | | 278| 11| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 11, False: 0] | | ------------------ | | 279| 11| return ((_r)); \ | | 280| 11| } \ | | 281| 11| } ------------------ 569| 0| } 570| 133| in = sr.base + 1; 571| 133| obj = d2i_ASN1_OBJECT(NULL, &in, *sr.base); 572| 133| if (obj == NULL) { ------------------ | Branch (572:7): [True: 44, False: 89] ------------------ 573| 44| ERR_clear_error(); 574| 44| RETERR(DNS_R_FORMERR); ------------------ | | 276| 44| { \ | | 277| 44| isc_result_t _r = (x); \ | | 278| 44| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 44, False: 0] | | ------------------ | | 279| 44| return ((_r)); \ | | 280| 44| } \ | | 281| 44| } ------------------ 575| 0| } 576| 89| ASN1_OBJECT_free(obj); 577| 89| if ((in - sr.base) != (*sr.base + 1)) { ------------------ | Branch (577:7): [True: 11, False: 78] ------------------ 578| 11| RETERR(DNS_R_FORMERR); ------------------ | | 276| 11| { \ | | 277| 11| isc_result_t _r = (x); \ | | 278| 11| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 11, False: 0] | | ------------------ | | 279| 11| return ((_r)); \ | | 280| 11| } \ | | 281| 11| } ------------------ 579| 0| } 580| 89| } 581| 265| return ISC_R_SUCCESS; 582| 333|} rdata.c:uint32_fromregion: 2095| 1.50k|uint32_fromregion(isc_region_t *region) { 2096| 1.50k| uint32_t value; 2097| | 2098| 1.50k| REQUIRE(region->length >= 4); ------------------ | | 198| 1.50k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.50k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.50k, False: 0] | | | | ------------------ | | | | 42| 1.50k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2099| 1.50k| value = (uint32_t)region->base[0] << 24; 2100| 1.50k| value |= (uint32_t)region->base[1] << 16; 2101| 1.50k| value |= (uint32_t)region->base[2] << 8; 2102| 1.50k| value |= (uint32_t)region->base[3]; 2103| 1.50k| return value; 2104| 1.50k|} rdata.c:buffer_fromregion: 2039| 6|buffer_fromregion(isc_buffer_t *buffer, isc_region_t *region) { 2040| 6| isc_buffer_init(buffer, region->base, region->length); 2041| 6| isc_buffer_add(buffer, region->length); 2042| 6| isc_buffer_setactive(buffer, region->length); 2043| 6|} rdata.c:uint16_tobuffer: 2058| 2|uint16_tobuffer(uint32_t value, isc_buffer_t *target) { 2059| 2| isc_region_t region; 2060| | 2061| 2| if (value > 0xffff) { ------------------ | Branch (2061:6): [True: 0, False: 2] ------------------ 2062| 0| return ISC_R_RANGE; 2063| 0| } 2064| 2| isc_buffer_availableregion(target, ®ion); 2065| 2| if (region.length < 2) { ------------------ | Branch (2065:6): [True: 0, False: 2] ------------------ 2066| 0| return ISC_R_NOSPACE; 2067| 0| } 2068| 2| isc_buffer_putuint16(target, (uint16_t)value); 2069| 2| return ISC_R_SUCCESS; 2070| 2|} rdata.c:uint32_tobuffer: 2046| 10|uint32_tobuffer(uint32_t value, isc_buffer_t *target) { 2047| 10| isc_region_t region; 2048| | 2049| 10| isc_buffer_availableregion(target, ®ion); 2050| 10| if (region.length < 4) { ------------------ | Branch (2050:6): [True: 0, False: 10] ------------------ 2051| 0| return ISC_R_NOSPACE; 2052| 0| } 2053| 10| isc_buffer_putuint32(target, value); 2054| 10| return ISC_R_SUCCESS; 2055| 10|} rdata.c:buffer_empty: 2034| 1.16k|buffer_empty(isc_buffer_t *source) { 2035| 1.16k| return (source->current == source->active) ? true : false; ------------------ | Branch (2035:9): [True: 1.07k, False: 92] ------------------ 2036| 1.16k|} rdata.c:uint16_fromregion: 2115| 7.20k|uint16_fromregion(isc_region_t *region) { 2116| 7.20k| REQUIRE(region->length >= 2); ------------------ | | 198| 7.20k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 7.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 7.20k, False: 0] | | | | ------------------ | | | | 42| 7.20k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 2117| | 2118| 7.20k| return (region->base[0] << 8) | region->base[1]; 2119| 7.20k|} rdata.c:fromwire_any_tsig: 243| 1.12k|fromwire_any_tsig(ARGS_FROMWIRE) { 244| 1.12k| isc_region_t sr; 245| 1.12k| dns_name_t name; 246| 1.12k| unsigned long n; 247| | 248| 1.12k| REQUIRE(type == dns_rdatatype_tsig); ------------------ | | 198| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.12k, False: 0] | | | | ------------------ | | | | 42| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 249| 1.12k| REQUIRE(rdclass == dns_rdataclass_any); ------------------ | | 198| 1.12k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.12k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.12k, False: 0] | | | | ------------------ | | | | 42| 1.12k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 250| | 251| 1.12k| UNUSED(type); ------------------ | | 69| 1.12k|#define UNUSED(x) (void)(x) ------------------ 252| 1.12k| UNUSED(rdclass); ------------------ | | 69| 1.12k|#define UNUSED(x) (void)(x) ------------------ 253| | 254| 1.12k| dctx = dns_decompress_setpermitted(dctx, false); 255| | 256| | /* 257| | * Algorithm Name. 258| | */ 259| 1.12k| dns_name_init(&name); 260| 1.12k| RETERR(dns_name_fromwire(&name, source, dctx, target)); ------------------ | | 276| 1.12k| { \ | | 277| 1.12k| isc_result_t _r = (x); \ | | 278| 1.12k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 50, False: 1.07k] | | ------------------ | | 279| 50| return ((_r)); \ | | 280| 50| } \ | | 281| 1.12k| } ------------------ 261| | 262| 1.07k| isc_buffer_activeregion(source, &sr); 263| | /* 264| | * Time Signed + Fudge. 265| | */ 266| 1.07k| if (sr.length < 8) { ------------------ | Branch (266:6): [True: 17, False: 1.05k] ------------------ 267| 17| return ISC_R_UNEXPECTEDEND; 268| 17| } 269| 1.05k| RETERR(mem_tobuffer(target, sr.base, 8)); ------------------ | | 276| 1.05k| { \ | | 277| 1.05k| isc_result_t _r = (x); \ | | 278| 1.05k| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 1.05k] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 1.05k| } ------------------ 270| 1.05k| isc_region_consume(&sr, 8); ------------------ | | 51| 1.05k| do { \ | | 52| 1.05k| isc_region_t *_r = (r); \ | | 53| 1.05k| unsigned int _l = (l); \ | | 54| 1.05k| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 1.05k|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 1.05k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 1.05k, False: 0] | | | | | | ------------------ | | | | | | 54| 1.05k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 1.05k| _r->base += _l; \ | | 56| 1.05k| _r->length -= _l; \ | | 57| 1.05k| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 1.05k] | | ------------------ ------------------ 271| 1.05k| isc_buffer_forward(source, 8); 272| | 273| | /* 274| | * Signature Length + Signature. 275| | */ 276| 1.05k| if (sr.length < 2) { ------------------ | Branch (276:6): [True: 21, False: 1.03k] ------------------ 277| 21| return ISC_R_UNEXPECTEDEND; 278| 21| } 279| 1.03k| n = uint16_fromregion(&sr); 280| 1.03k| if (sr.length < n + 2) { ------------------ | Branch (280:6): [True: 50, False: 984] ------------------ 281| 50| return ISC_R_UNEXPECTEDEND; 282| 50| } 283| 984| RETERR(mem_tobuffer(target, sr.base, n + 2)); ------------------ | | 276| 984| { \ | | 277| 984| isc_result_t _r = (x); \ | | 278| 984| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 125, False: 859] | | ------------------ | | 279| 125| return ((_r)); \ | | 280| 125| } \ | | 281| 984| } ------------------ 284| 859| isc_region_consume(&sr, n + 2); ------------------ | | 51| 859| do { \ | | 52| 859| isc_region_t *_r = (r); \ | | 53| 859| unsigned int _l = (l); \ | | 54| 859| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 859|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 859| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 859, False: 0] | | | | | | ------------------ | | | | | | 54| 859| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 859| _r->base += _l; \ | | 56| 859| _r->length -= _l; \ | | 57| 859| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 859] | | ------------------ ------------------ 285| 859| isc_buffer_forward(source, n + 2); 286| | 287| | /* 288| | * Original ID + Error. 289| | */ 290| 859| if (sr.length < 4) { ------------------ | Branch (290:6): [True: 44, False: 815] ------------------ 291| 44| return ISC_R_UNEXPECTEDEND; 292| 44| } 293| 815| RETERR(mem_tobuffer(target, sr.base, 4)); ------------------ | | 276| 815| { \ | | 277| 815| isc_result_t _r = (x); \ | | 278| 815| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 2, False: 813] | | ------------------ | | 279| 2| return ((_r)); \ | | 280| 2| } \ | | 281| 815| } ------------------ 294| 813| isc_region_consume(&sr, 4); ------------------ | | 51| 813| do { \ | | 52| 813| isc_region_t *_r = (r); \ | | 53| 813| unsigned int _l = (l); \ | | 54| 813| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 813|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 813| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 813, False: 0] | | | | | | ------------------ | | | | | | 54| 813| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 813| _r->base += _l; \ | | 56| 813| _r->length -= _l; \ | | 57| 813| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 813] | | ------------------ ------------------ 295| 813| isc_buffer_forward(source, 4); 296| | 297| | /* 298| | * Other Length + Other. 299| | */ 300| 813| if (sr.length < 2) { ------------------ | Branch (300:6): [True: 7, False: 806] ------------------ 301| 7| return ISC_R_UNEXPECTEDEND; 302| 7| } 303| 806| n = uint16_fromregion(&sr); 304| 806| if (sr.length < n + 2) { ------------------ | Branch (304:6): [True: 80, False: 726] ------------------ 305| 80| return ISC_R_UNEXPECTEDEND; 306| 80| } 307| 726| isc_buffer_forward(source, n + 2); 308| 726| return mem_tobuffer(target, sr.base, n + 2); 309| 806|} rdata.c:tostruct_any_tsig: 432| 748|tostruct_any_tsig(ARGS_TOSTRUCT) { 433| 748| dns_rdata_any_tsig_t *tsig; 434| 748| dns_name_t alg; 435| 748| isc_region_t sr; 436| | 437| 748| REQUIRE(rdata->type == dns_rdatatype_tsig); ------------------ | | 198| 748|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 748| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 748, False: 0] | | | | ------------------ | | | | 42| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 438| 748| REQUIRE(rdata->rdclass == dns_rdataclass_any); ------------------ | | 198| 748|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 748| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 748, False: 0] | | | | ------------------ | | | | 42| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 439| 748| REQUIRE(rdata->length != 0); ------------------ | | 198| 748|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 748| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 748, False: 0] | | | | ------------------ | | | | 42| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 440| | 441| 748| tsig = (dns_rdata_any_tsig_t *)target; 442| 748| DNS_RDATACOMMON_INIT(tsig, rdata->type, rdata->rdclass); ------------------ | | 44| 748| do { \ | | 45| 748| (_data)->common.rdtype = (_rdtype); \ | | 46| 748| (_data)->common.rdclass = (_rdclass); \ | | 47| 748| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 748] | | ------------------ ------------------ 443| | 444| 748| dns_rdata_toregion(rdata, &sr); 445| | 446| | /* 447| | * Algorithm Name. 448| | */ 449| 748| dns_name_init(&alg); 450| 748| dns_name_fromregion(&alg, &sr); 451| 748| dns_name_init(&tsig->algorithm); 452| 748| dns_name_clone(&alg, &tsig->algorithm); ------------------ | | 1519| 748| dns_name__clone(DNS_NAME__RO_ARG(source), target) | | ------------------ | | | | 1507| 748| _Generic((arg), \ | | | | 1508| 748| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 748| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 748| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 748| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 748| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 748| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 453| | 454| 748| isc_region_consume(&sr, name_length(&tsig->algorithm)); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 455| | 456| | /* 457| | * Time Signed. 458| | */ 459| 748| INSIST(sr.length >= 6); ------------------ | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 748| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 748, False: 0] | | | | ------------------ | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 460| 748| tsig->timesigned = ((uint64_t)sr.base[0] << 40) | 461| 748| ((uint64_t)sr.base[1] << 32) | 462| 748| ((uint64_t)sr.base[2] << 24) | 463| 748| ((uint64_t)sr.base[3] << 16) | 464| 748| ((uint64_t)sr.base[4] << 8) | (uint64_t)sr.base[5]; 465| 748| isc_region_consume(&sr, 6); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 466| | 467| | /* 468| | * Fudge. 469| | */ 470| 748| tsig->fudge = uint16_fromregion(&sr); 471| 748| isc_region_consume(&sr, 2); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 472| | 473| | /* 474| | * Signature Size. 475| | */ 476| 748| tsig->siglen = uint16_fromregion(&sr); 477| 748| isc_region_consume(&sr, 2); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 478| | 479| | /* 480| | * Signature. 481| | */ 482| 748| INSIST(sr.length >= tsig->siglen); ------------------ | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 748| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 748, False: 0] | | | | ------------------ | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 483| 748| tsig->signature = sr.base; 484| 748| isc_region_consume(&sr, tsig->siglen); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 485| | 486| | /* 487| | * Original ID. 488| | */ 489| 748| tsig->originalid = uint16_fromregion(&sr); 490| 748| isc_region_consume(&sr, 2); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 491| | 492| | /* 493| | * Error. 494| | */ 495| 748| tsig->error = uint16_fromregion(&sr); 496| 748| isc_region_consume(&sr, 2); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 497| | 498| | /* 499| | * Other Size. 500| | */ 501| 748| tsig->otherlen = uint16_fromregion(&sr); 502| 748| isc_region_consume(&sr, 2); ------------------ | | 51| 748| do { \ | | 52| 748| isc_region_t *_r = (r); \ | | 53| 748| unsigned int _l = (l); \ | | 54| 748| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 748| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 748, False: 0] | | | | | | ------------------ | | | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 748| _r->base += _l; \ | | 56| 748| _r->length -= _l; \ | | 57| 748| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 748] | | ------------------ ------------------ 503| | 504| | /* 505| | * Other. 506| | */ 507| 748| INSIST(sr.length == tsig->otherlen); ------------------ | | 202| 748|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 748| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 748, False: 0] | | | | ------------------ | | | | 54| 748| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 508| 748| tsig->other = sr.base; 509| | 510| 748| return ISC_R_SUCCESS; 511| 748|} 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) { ------------------ | | 171| 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); ------------------ | | 158| 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: 356| 117|tostruct_key(ARGS_TOSTRUCT) { 357| 117| dns_rdata_key_t *key = target; 358| | 359| 117| REQUIRE(key != NULL); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 360| 117| REQUIRE(rdata != NULL); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 361| 117| REQUIRE(rdata->type == dns_rdatatype_key); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 362| | 363| 117| DNS_RDATACOMMON_INIT(key, rdata->type, rdata->rdclass); ------------------ | | 44| 117| do { \ | | 45| 117| (_data)->common.rdtype = (_rdtype); \ | | 46| 117| (_data)->common.rdclass = (_rdclass); \ | | 47| 117| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 117] | | ------------------ ------------------ 364| | 365| 117| return generic_tostruct_key(CALL_TOSTRUCT); ------------------ | | 109| 117|#define CALL_TOSTRUCT rdata, target ------------------ 366| 117|} rdata.c:generic_tostruct_key: 317| 117|generic_tostruct_key(ARGS_TOSTRUCT) { 318| 117| dns_rdata_key_t *key = target; 319| 117| isc_region_t sr; 320| | 321| 117| REQUIRE(key != NULL); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 322| 117| REQUIRE(rdata->length >= 4U); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 323| | 324| 117| REQUIRE(key != NULL); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 325| 117| REQUIRE(key->common.rdclass == rdata->rdclass); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 326| 117| REQUIRE(key->common.rdtype == rdata->type); ------------------ | | 198| 117|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 117| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 117, False: 0] | | | | ------------------ | | | | 42| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 327| | 328| 117| dns_rdata_toregion(rdata, &sr); 329| | 330| | /* Flags */ 331| 117| key->flags = uint16_fromregion(&sr); 332| 117| isc_region_consume(&sr, 2); ------------------ | | 51| 117| do { \ | | 52| 117| isc_region_t *_r = (r); \ | | 53| 117| unsigned int _l = (l); \ | | 54| 117| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 117|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 117| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 117, False: 0] | | | | | | ------------------ | | | | | | 54| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 117| _r->base += _l; \ | | 56| 117| _r->length -= _l; \ | | 57| 117| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 117] | | ------------------ ------------------ 333| | 334| | /* Protocol */ 335| 117| key->protocol = uint8_fromregion(&sr); 336| 117| isc_region_consume(&sr, 1); ------------------ | | 51| 117| do { \ | | 52| 117| isc_region_t *_r = (r); \ | | 53| 117| unsigned int _l = (l); \ | | 54| 117| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 117|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 117| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 117, False: 0] | | | | | | ------------------ | | | | | | 54| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 117| _r->base += _l; \ | | 56| 117| _r->length -= _l; \ | | 57| 117| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 117] | | ------------------ ------------------ 337| | 338| | /* Algorithm */ 339| 117| key->algorithm = uint8_fromregion(&sr); 340| 117| isc_region_consume(&sr, 1); ------------------ | | 51| 117| do { \ | | 52| 117| isc_region_t *_r = (r); \ | | 53| 117| unsigned int _l = (l); \ | | 54| 117| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 117|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 117| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 117, False: 0] | | | | | | ------------------ | | | | | | 54| 117| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 117| _r->base += _l; \ | | 56| 117| _r->length -= _l; \ | | 57| 117| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 117] | | ------------------ ------------------ 341| | 342| | /* Data */ 343| 117| key->datalen = sr.length; 344| 117| key->data = sr.base; 345| 117| return ISC_R_SUCCESS; 346| 117|} 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) { ------------------ | | 212| 2|#define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES | | ------------------ | | | | 167| 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) { ------------------ | | 213| 0|#define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL | | ------------------ | | | | 168| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 157| 2| REQUIRE(ns != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 158| 2| REQUIRE(rdata->length != 0); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| dns_name_clone(&name, &ns->name); ------------------ | | 1519| 2| dns_name__clone(DNS_NAME__RO_ARG(source), target) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 167| 2| return ISC_R_SUCCESS; 168| 2|} rdata.c:fromwire_sig: 249| 798|fromwire_sig(ARGS_FROMWIRE) { 250| 798| isc_region_t sr; 251| 798| dns_name_t name; 252| 798| unsigned char algorithm; 253| | 254| 798| REQUIRE(type == dns_rdatatype_sig); ------------------ | | 198| 798|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 798| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 798, False: 0] | | | | ------------------ | | | | 42| 798| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 255| | 256| 798| UNUSED(type); ------------------ | | 69| 798|#define UNUSED(x) (void)(x) ------------------ 257| 798| UNUSED(rdclass); ------------------ | | 69| 798|#define UNUSED(x) (void)(x) ------------------ 258| | 259| | /* 260| | * RFC 3597 section 4 asks receivers to decompress this type, 261| | * even though senders must not compress it. 262| | */ 263| 798| dctx = dns_decompress_setpermitted(dctx, true); 264| | 265| 798| isc_buffer_activeregion(source, &sr); 266| | /* 267| | * type covered: 2 268| | * algorithm: 1 269| | * labels: 1 270| | * original ttl: 4 271| | * signature expiration: 4 272| | * time signed: 4 273| | * key footprint: 2 274| | */ 275| 798| if (sr.length < 18) { ------------------ | Branch (275:6): [True: 16, False: 782] ------------------ 276| 16| return ISC_R_UNEXPECTEDEND; 277| 16| } 278| | 279| 782| algorithm = sr.base[2]; 280| | 281| 782| isc_buffer_forward(source, 18); 282| 782| RETERR(mem_tobuffer(target, sr.base, 18)); ------------------ | | 276| 782| { \ | | 277| 782| isc_result_t _r = (x); \ | | 278| 782| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 782] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 782| } ------------------ 283| | 284| | /* 285| | * Signer. 286| | */ 287| 782| dns_name_init(&name); 288| 782| RETERR(dns_name_fromwire(&name, source, dctx, target)); ------------------ | | 276| 782| { \ | | 277| 782| isc_result_t _r = (x); \ | | 278| 782| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 20, False: 762] | | ------------------ | | 279| 20| return ((_r)); \ | | 280| 20| } \ | | 281| 782| } ------------------ 289| | 290| | /* 291| | * Sig. 292| | */ 293| 762| isc_buffer_activeregion(source, &sr); 294| 762| if (sr.length == 0) { ------------------ | Branch (294:6): [True: 7, False: 755] ------------------ 295| 7| return ISC_R_UNEXPECTEDEND; 296| 7| } 297| | 298| 755| if (algorithm == DNS_KEYALG_PRIVATEDNS || ------------------ | Branch (298:6): [True: 189, False: 566] ------------------ 299| 566| algorithm == DNS_KEYALG_PRIVATEOID) ------------------ | Branch (299:6): [True: 144, False: 422] ------------------ 300| 333| { 301| 333| isc_buffer_t b = *source; 302| 333| RETERR(check_private(&b, algorithm)); ------------------ | | 276| 333| { \ | | 277| 333| isc_result_t _r = (x); \ | | 278| 333| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 68, False: 265] | | ------------------ | | 279| 68| return ((_r)); \ | | 280| 68| } \ | | 281| 333| } ------------------ 303| 265| } 304| | 305| 687| isc_buffer_forward(source, sr.length); 306| 687| return mem_tobuffer(target, sr.base, sr.length); 307| 755|} rdata.c:tostruct_sig: 450| 498|tostruct_sig(ARGS_TOSTRUCT) { 451| 498| isc_region_t sr; 452| 498| dns_rdata_sig_t *sig = target; 453| 498| dns_name_t signer; 454| | 455| 498| REQUIRE(rdata->type == dns_rdatatype_sig); ------------------ | | 198| 498|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 498, False: 0] | | | | ------------------ | | | | 42| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 456| 498| REQUIRE(sig != NULL); ------------------ | | 198| 498|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 498, False: 0] | | | | ------------------ | | | | 42| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 457| 498| REQUIRE(rdata->length != 0); ------------------ | | 198| 498|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 498, False: 0] | | | | ------------------ | | | | 42| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 458| | 459| 498| DNS_RDATACOMMON_INIT(sig, rdata->type, rdata->rdclass); ------------------ | | 44| 498| do { \ | | 45| 498| (_data)->common.rdtype = (_rdtype); \ | | 46| 498| (_data)->common.rdclass = (_rdclass); \ | | 47| 498| } while (0) | | ------------------ | | | Branch (47:11): [Folded, False: 498] | | ------------------ ------------------ 460| | 461| 498| dns_rdata_toregion(rdata, &sr); 462| | 463| | /* 464| | * Type covered. 465| | */ 466| 498| sig->covered = uint16_fromregion(&sr); 467| 498| isc_region_consume(&sr, 2); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 468| | 469| | /* 470| | * Algorithm. 471| | */ 472| 498| sig->algorithm = uint8_fromregion(&sr); 473| 498| isc_region_consume(&sr, 1); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 474| | 475| | /* 476| | * Labels. 477| | */ 478| 498| sig->labels = uint8_fromregion(&sr); 479| 498| isc_region_consume(&sr, 1); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 480| | 481| | /* 482| | * Original TTL. 483| | */ 484| 498| sig->originalttl = uint32_fromregion(&sr); 485| 498| isc_region_consume(&sr, 4); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 486| | 487| | /* 488| | * Expire time. 489| | */ 490| 498| sig->timeexpire = uint32_fromregion(&sr); 491| 498| isc_region_consume(&sr, 4); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 492| | 493| | /* 494| | * Time signed. 495| | */ 496| 498| sig->timesigned = uint32_fromregion(&sr); 497| 498| isc_region_consume(&sr, 4); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 498| | 499| | /* 500| | * Key ID. 501| | */ 502| 498| sig->keyid = uint16_fromregion(&sr); 503| 498| isc_region_consume(&sr, 2); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 504| | 505| 498| dns_name_init(&signer); 506| 498| dns_name_fromregion(&signer, &sr); 507| 498| dns_name_init(&sig->signer); 508| 498| dns_name_clone(&signer, &sig->signer); ------------------ | | 1519| 498| dns_name__clone(DNS_NAME__RO_ARG(source), target) | | ------------------ | | | | 1507| 498| _Generic((arg), \ | | | | 1508| 498| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 498| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 498| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 498| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 498| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 498| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 509| 498| isc_region_consume(&sr, name_length(&sig->signer)); ------------------ | | 51| 498| do { \ | | 52| 498| isc_region_t *_r = (r); \ | | 53| 498| unsigned int _l = (l); \ | | 54| 498| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 498|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 498| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 498, False: 0] | | | | | | ------------------ | | | | | | 54| 498| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 498| _r->base += _l; \ | | 56| 498| _r->length -= _l; \ | | 57| 498| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 498] | | ------------------ ------------------ 510| | 511| | /* 512| | * Signature. 513| | */ 514| 498| sig->siglen = sr.length; 515| 498| sig->signature = sr.base; 516| 498| return ISC_R_SUCCESS; 517| 498|} rdata.c:covers_sig: 562| 512|covers_sig(dns_rdata_t *rdata) { 563| 512| dns_rdatatype_t type; 564| 512| isc_region_t r; 565| | 566| 512| REQUIRE(rdata->type == dns_rdatatype_sig); ------------------ | | 198| 512|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 512| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 512, False: 0] | | | | ------------------ | | | | 42| 512| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 567| | 568| 512| dns_rdata_toregion(rdata, &r); 569| 512| type = uint16_fromregion(&r); 570| | 571| 512| return type; 572| 512|} 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) { ------------------ | | 212| 4|#define DNS_RDATA_CHECKNAMES DNS_NAME_CHECKNAMES | | ------------------ | | | | 167| 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) { ------------------ | | 213| 0|#define DNS_RDATA_CHECKNAMESFAIL DNS_NAME_CHECKNAMESFAIL | | ------------------ | | | | 168| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 312| 2| REQUIRE(soa != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 313| 2| REQUIRE(rdata->length != 0); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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)); ------------------ | | 51| 2| do { \ | | 52| 2| isc_region_t *_r = (r); \ | | 53| 2| unsigned int _l = (l); \ | | 54| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 2| _r->base += _l; \ | | 56| 2| _r->length -= _l; \ | | 57| 2| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 2] | | ------------------ ------------------ 322| 2| dns_name_init(&soa->origin); 323| 2| dns_name_clone(&name, &soa->origin); ------------------ | | 1519| 2| dns_name__clone(DNS_NAME__RO_ARG(source), target) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 324| | 325| 2| dns_name_fromregion(&name, ®ion); 326| 2| isc_region_consume(®ion, name_length(&name)); ------------------ | | 51| 2| do { \ | | 52| 2| isc_region_t *_r = (r); \ | | 53| 2| unsigned int _l = (l); \ | | 54| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 2| _r->base += _l; \ | | 56| 2| _r->length -= _l; \ | | 57| 2| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 2] | | ------------------ ------------------ 327| 2| dns_name_init(&soa->contact); 328| 2| dns_name_clone(&name, &soa->contact); ------------------ | | 1519| 2| dns_name__clone(DNS_NAME__RO_ARG(source), target) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 329| | 330| 2| soa->serial = uint32_fromregion(®ion); 331| 2| isc_region_consume(®ion, 4); ------------------ | | 51| 2| do { \ | | 52| 2| isc_region_t *_r = (r); \ | | 53| 2| unsigned int _l = (l); \ | | 54| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 2| _r->base += _l; \ | | 56| 2| _r->length -= _l; \ | | 57| 2| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 2] | | ------------------ ------------------ 332| | 333| 2| soa->refresh = uint32_fromregion(®ion); 334| 2| isc_region_consume(®ion, 4); ------------------ | | 51| 2| do { \ | | 52| 2| isc_region_t *_r = (r); \ | | 53| 2| unsigned int _l = (l); \ | | 54| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 2| _r->base += _l; \ | | 56| 2| _r->length -= _l; \ | | 57| 2| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 2] | | ------------------ ------------------ 335| | 336| 2| soa->retry = uint32_fromregion(®ion); 337| 2| isc_region_consume(®ion, 4); ------------------ | | 51| 2| do { \ | | 52| 2| isc_region_t *_r = (r); \ | | 53| 2| unsigned int _l = (l); \ | | 54| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 2| _r->base += _l; \ | | 56| 2| _r->length -= _l; \ | | 57| 2| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 2] | | ------------------ ------------------ 338| | 339| 2| soa->expire = uint32_fromregion(®ion); 340| 2| isc_region_consume(®ion, 4); ------------------ | | 51| 2| do { \ | | 52| 2| isc_region_t *_r = (r); \ | | 53| 2| unsigned int _l = (l); \ | | 54| 2| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 2| _r->base += _l; \ | | 56| 2| _r->length -= _l; \ | | 57| 2| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 2] | | ------------------ ------------------ 341| | 342| 2| soa->minimum = uint32_fromregion(®ion); 343| | 344| 2| return ISC_R_SUCCESS; 345| 2|} dns_rdatalist_init: 40| 2.89k|dns_rdatalist_init(dns_rdatalist_t *rdatalist) { 41| 2.89k| REQUIRE(rdatalist != NULL); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 42| | 43| | /* 44| | * Initialize rdatalist. 45| | */ 46| 2.89k| *rdatalist = (dns_rdatalist_t){ 47| 2.89k| .rdata = ISC_LIST_INITIALIZER, ------------------ | | 21| 2.89k| { \ | | 22| 2.89k| .head = NULL, \ | | 23| 2.89k| .tail = NULL, \ | | 24| 2.89k| } ------------------ 48| 2.89k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 2.89k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 2.89k| { \ | | | | 27| 2.89k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2.89k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 2.89k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 2.89k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 2.89k| } | | ------------------ ------------------ 49| 2.89k| }; 50| 2.89k| memset(rdatalist->upper, 0xeb, sizeof(rdatalist->upper)); 51| | 52| | /* 53| | * Clear upper set bit. 54| | */ 55| 2.89k| rdatalist->upper[0] &= ~0x01; 56| 2.89k|} dns_rdatalist_tordataset: 59| 2.89k|dns_rdatalist_tordataset(dns_rdatalist_t *rdatalist, dns_rdataset_t *rdataset) { 60| | /* 61| | * Make 'rdataset' refer to the rdata in 'rdatalist'. 62| | */ 63| | 64| 2.89k| REQUIRE(rdatalist != NULL); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 65| 2.89k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.79k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | | Branch (41:11): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 66| 2.89k| REQUIRE(!dns_rdataset_isassociated(rdataset)); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 67| | 68| | /* Check if dns_rdatalist_init has was called. */ 69| 2.89k| REQUIRE(rdatalist->upper[0] == 0xea); ------------------ | | 198| 2.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.89k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.89k, False: 0] | | | | ------------------ | | | | 42| 2.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 70| | 71| 2.89k| *rdataset = (dns_rdataset_t){ 72| 2.89k| .methods = &methods, 73| 2.89k| .rdclass = rdatalist->rdclass, 74| 2.89k| .type = rdatalist->type, 75| 2.89k| .covers = rdatalist->covers, 76| 2.89k| .ttl = rdatalist->ttl, 77| 2.89k| .rdlist.list = rdatalist, 78| | 79| 2.89k| .link = rdataset->link, 80| 2.89k| .attributes = rdataset->attributes, 81| 2.89k| .magic = rdataset->magic, 82| 2.89k| }; 83| 2.89k|} dns_rdatalist_fromrdataset: 87| 1.07k| dns_rdatalist_t **rdatalist) { 88| 1.07k| REQUIRE(rdatalist != NULL && rdataset != NULL); ------------------ | | 198| 1.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.14k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.07k, False: 0] | | | | | Branch (41:11): [True: 1.07k, False: 0] | | | | ------------------ | | | | 42| 1.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 89| 1.07k| REQUIRE(rdataset->methods == &methods); ------------------ | | 198| 1.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.07k, False: 0] | | | | ------------------ | | | | 42| 1.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 90| | 91| 1.07k| *rdatalist = rdataset->rdlist.list; 92| 1.07k|} dns_rdatalist_disassociate: 95| 2.89k|dns_rdatalist_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 96| 2.89k| UNUSED(rdataset); ------------------ | | 69| 2.89k|#define UNUSED(x) (void)(x) ------------------ 97| 2.89k|} dns__rdatalist_first: 100| 1.25k|dns__rdatalist_first(dns_rdataset_t *rdataset) { 101| 1.25k| dns_rdatalist_t *rdatalist = NULL; 102| | 103| 1.25k| rdatalist = rdataset->rdlist.list; 104| 1.25k| rdataset->rdlist.iter = ISC_LIST_HEAD(rdatalist->rdata); ------------------ | | 62| 1.25k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 105| | 106| 1.25k| if (rdataset->rdlist.iter == NULL) { ------------------ | Branch (106:6): [True: 0, False: 1.25k] ------------------ 107| 0| return ISC_R_NOMORE; 108| 0| } 109| | 110| 1.25k| return ISC_R_SUCCESS; 111| 1.25k|} dns__rdatalist_next: 114| 6|dns__rdatalist_next(dns_rdataset_t *rdataset) { 115| 6| dns_rdata_t *rdata; 116| | 117| 6| rdata = rdataset->rdlist.iter; 118| 6| if (rdata == NULL) { ------------------ | Branch (118:6): [True: 0, False: 6] ------------------ 119| 0| return ISC_R_NOMORE; 120| 0| } 121| | 122| 6| rdataset->rdlist.iter = ISC_LIST_NEXT(rdata, link); ------------------ | | 140| 6|#define ISC_LIST_NEXT(elt, link) ((elt)->link.next) ------------------ 123| | 124| 6| if (rdataset->rdlist.iter == NULL) { ------------------ | Branch (124:6): [True: 6, False: 0] ------------------ 125| 6| return ISC_R_NOMORE; 126| 6| } 127| | 128| 0| return ISC_R_SUCCESS; 129| 6|} dns__rdatalist_current: 132| 1.25k|dns__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 133| 1.25k| dns_rdata_t *list_rdata; 134| | 135| 1.25k| list_rdata = rdataset->rdlist.iter; 136| 1.25k| INSIST(list_rdata != NULL); ------------------ | | 202| 1.25k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 1.25k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 1.25k, False: 0] | | | | ------------------ | | | | 54| 1.25k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 137| | 138| 1.25k| dns_rdata_clone(list_rdata, rdata); 139| 1.25k|} dns__rdatalist_count: 153| 6|dns__rdatalist_count(dns_rdataset_t *rdataset) { 154| 6| dns_rdatalist_t *rdatalist = NULL; 155| 6| unsigned int count; 156| | 157| 6| REQUIRE(rdataset != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 158| | 159| 6| rdatalist = rdataset->rdlist.list; 160| | 161| 6| count = 0; 162| 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] | | ------------------ ------------------ 163| 6| count++; 164| 6| } 165| | 166| 6| return count; 167| 6|} dns__rdatalist_setownercase: 259| 1.07k|dns__rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) { 260| 1.07k| dns_rdatalist_t *rdatalist; 261| 1.07k| unsigned int i; 262| | 263| | /* 264| | * We do not need to worry about label lengths as they are all 265| | * less than or equal to 63. 266| | */ 267| 1.07k| rdatalist = rdataset->rdlist.list; 268| 1.07k| memset(rdatalist->upper, 0, sizeof(rdatalist->upper)); 269| 6.11k| for (i = 1; i < name->length; i++) { ------------------ | Branch (269:14): [True: 5.04k, False: 1.07k] ------------------ 270| 5.04k| if (name->ndata[i] >= 0x41 && name->ndata[i] <= 0x5a) { ------------------ | Branch (270:7): [True: 3.92k, False: 1.12k] | Branch (270:33): [True: 0, False: 3.92k] ------------------ 271| 0| rdatalist->upper[i / 8] |= 1 << (i % 8); 272| 0| } 273| 5.04k| } 274| | /* 275| | * Record that upper has been set. 276| | */ 277| 1.07k| rdatalist->upper[0] |= 0x01; 278| 1.07k|} dns_rdataset_init: 56| 4.11k|dns_rdataset_init(dns_rdataset_t *rdataset) { 57| | /* 58| | * Make 'rdataset' a valid, disassociated rdataset. 59| | */ 60| | 61| 4.11k| REQUIRE(rdataset != NULL); ------------------ | | 198| 4.11k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.11k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4.11k, False: 0] | | | | ------------------ | | | | 42| 4.11k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 62| | 63| 4.11k| *rdataset = (dns_rdataset_t){ 64| 4.11k| .magic = DNS_RDATASET_MAGIC, ------------------ | | 91| 4.11k|#define DNS_RDATASET_MAGIC ISC_MAGIC('D', 'N', 'S', 'R') | | ------------------ | | | | 31| 4.11k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 65| 4.11k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.11k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.11k| { \ | | | | 27| 4.11k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.11k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.11k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.11k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.11k| } | | ------------------ ------------------ 66| 4.11k| }; 67| 4.11k|} 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 76| 4| REQUIRE(rdataset->methods == NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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.01k|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.01k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 3.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.02k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.01k, False: 0] | | | | | Branch (41:11): [True: 3.01k, False: 0] | | | | ------------------ | | | | 42| 3.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 91| 3.01k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 3.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.01k, False: 0] | | | | ------------------ | | | | 42| 3.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 92| | 93| 3.01k| if (rdataset->methods->disassociate != NULL) { ------------------ | Branch (93:6): [True: 3.01k, False: 0] ------------------ 94| 3.01k| (rdataset->methods->disassociate)(rdataset DNS__DB_FLARG_PASS); 95| 3.01k| } 96| 3.01k| *rdataset = (dns_rdataset_t){ 97| 3.01k| .magic = DNS_RDATASET_MAGIC, ------------------ | | 91| 3.01k|#define DNS_RDATASET_MAGIC ISC_MAGIC('D', 'N', 'S', 'R') | | ------------------ | | | | 31| 3.01k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 98| 3.01k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 3.01k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 3.01k| { \ | | | | 27| 3.01k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.01k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 3.01k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.01k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 3.01k| } | | ------------------ ------------------ 99| 3.01k| }; 100| 3.01k|} dns_rdataset_isassociated: 103| 7.87k|dns_rdataset_isassociated(const dns_rdataset_t *rdataset) { 104| | /* 105| | * Is 'rdataset' associated? 106| | */ 107| | 108| 7.87k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 7.87k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 15.7k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 7.87k, False: 0] | | | | | Branch (41:11): [True: 7.87k, False: 0] | | | | ------------------ | | | | 42| 7.87k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 109| | 110| 7.87k| if (rdataset->methods != NULL) { ------------------ | Branch (110:6): [True: 677, False: 7.19k] ------------------ 111| 677| return true; 112| 677| } 113| | 114| 7.19k| return false; 115| 7.87k|} 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) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 158| 6| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 159| 6| REQUIRE(rdataset->methods->count != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 160| | 161| 6| return (rdataset->methods->count)(rdataset); 162| 6|} dns_rdataset_first: 180| 1.37k|dns_rdataset_first(dns_rdataset_t *rdataset) { 181| 1.37k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 1.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.74k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.37k, False: 0] | | | | | Branch (41:11): [True: 1.37k, False: 0] | | | | ------------------ | | | | 42| 1.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 182| 1.37k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 1.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.37k, False: 0] | | | | ------------------ | | | | 42| 1.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 183| 1.37k| REQUIRE(rdataset->methods->first != NULL); ------------------ | | 198| 1.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.37k, False: 0] | | | | ------------------ | | | | 42| 1.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 184| | 185| 1.37k| isc_result_t result = rdataset->methods->first(rdataset); 186| 1.37k| ENSURE(result == ISC_R_SUCCESS || result == ISC_R_NOMORE); ------------------ | | 200| 1.37k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 1.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:11): [True: 1.37k, False: 0] | | | | | Branch (47:11): [True: 0, False: 0] | | | | ------------------ | | | | 48| 1.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 187| 1.37k| return result; 188| 1.37k|} dns_rdataset_next: 191| 126|dns_rdataset_next(dns_rdataset_t *rdataset) { 192| 126| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 126|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 252| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 126, False: 0] | | | | | Branch (41:11): [True: 126, False: 0] | | | | ------------------ | | | | 42| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 193| 126| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 126|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 126| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 126, False: 0] | | | | ------------------ | | | | 42| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 194| 126| REQUIRE(rdataset->methods->next != NULL); ------------------ | | 198| 126|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 126| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 126, False: 0] | | | | ------------------ | | | | 42| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 195| | 196| 126| isc_result_t result = rdataset->methods->next(rdataset); 197| 126| ENSURE(result == ISC_R_SUCCESS || result == ISC_R_NOMORE); ------------------ | | 200| 126|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 252| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:11): [True: 0, False: 126] | | | | | Branch (47:11): [True: 126, False: 0] | | | | ------------------ | | | | 48| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 198| 126| return result; 199| 126|} dns_rdataset_current: 202| 1.37k|dns_rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 203| | /* 204| | * Make 'rdata' refer to the current rdata. 205| | */ 206| | 207| 1.37k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 1.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.74k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.37k, False: 0] | | | | | Branch (41:11): [True: 1.37k, False: 0] | | | | ------------------ | | | | 42| 1.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 208| 1.37k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 1.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.37k, False: 0] | | | | ------------------ | | | | 42| 1.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 209| 1.37k| REQUIRE(rdataset->methods->current != NULL); ------------------ | | 198| 1.37k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.37k, False: 0] | | | | ------------------ | | | | 42| 1.37k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 210| | 211| 1.37k| (rdataset->methods->current)(rdataset, rdata); 212| 1.37k|} dns__rdataset_setownercase: 518| 1.07k|dns__rdataset_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) { 519| 1.07k| REQUIRE(DNS_RDATASET_VALID(rdataset)); ------------------ | | 198| 1.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.14k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.07k, False: 0] | | | | | Branch (41:11): [True: 1.07k, False: 0] | | | | ------------------ | | | | 42| 1.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 520| 1.07k| REQUIRE(rdataset->methods != NULL); ------------------ | | 198| 1.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.07k, False: 0] | | | | ------------------ | | | | 42| 1.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 521| | 522| 1.07k| if (rdataset->methods->setownercase != NULL && ------------------ | Branch (522:6): [True: 1.07k, False: 0] ------------------ 523| 1.07k| !rdataset->attributes.keepcase) ------------------ | Branch (523:6): [True: 1.07k, False: 0] ------------------ 524| 1.07k| { 525| 1.07k| (rdataset->methods->setownercase)(rdataset, name); 526| 1.07k| } 527| 1.07k|} dns_rdatavec_fromrdataset: 284| 6| isc_region_t *region, uint32_t maxrrperset) { 285| 6| if (rdataset->type == dns_rdatatype_none && ------------------ | | 115| 12|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (285:6): [True: 0, False: 6] ------------------ 286| 0| rdataset->covers == dns_rdatatype_none) ------------------ | | 115| 0|#define dns_rdatatype_none ((dns_rdatatype_t)dns_rdatatype_none) ------------------ | Branch (286:6): [True: 0, False: 0] ------------------ 287| 0| { 288| 0| return DNS_R_DISALLOWED; 289| 0| } 290| | 291| 6| INSIST(!rdataset->attributes.negative); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 292| 6| INSIST(rdataset->type != dns_rdatatype_none); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 293| 6| INSIST(dns_rdatatype_issig(rdataset->type) || ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 0, False: 6] | | | | | Branch (53:11): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 294| 6| rdataset->covers == dns_rdatatype_none); 295| | 296| 6| return makevec(rdataset, mctx, region, maxrrperset); 297| 6|} dns_rdatavec_size: 300| 6|dns_rdatavec_size(dns_vecheader_t *header) { 301| 6| REQUIRE(header != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 302| | 303| 6| return sizeof(*header) + header->raw_length; 304| 6|} dns_vecheader_setownercase: 613| 6|dns_vecheader_setownercase(dns_vecheader_t *header, const dns_name_t *name) { 614| 6| REQUIRE(!CASESET(header)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 615| | 616| 6| bool casefullylower = true; 617| | 618| | /* 619| | * We do not need to worry about label lengths as they are all 620| | * less than or equal to 63. 621| | */ 622| 6| memset(header->upper, 0, sizeof(header->upper)); 623| 60| for (size_t i = 0; i < name->length; i++) { ------------------ | Branch (623:21): [True: 54, False: 6] ------------------ 624| 54| if (isupper(name->ndata[i])) { ------------------ | Branch (624:7): [True: 0, False: 54] ------------------ 625| 0| header->upper[i / 8] |= 1 << (i % 8); 626| 0| casefullylower = false; 627| 0| } 628| 54| } 629| 6| if (casefullylower) { ------------------ | Branch (629:6): [True: 6, False: 0] ------------------ 630| 6| DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASEFULLYLOWER); ------------------ | | 144| 6| atomic_fetch_or_release(&(header)->attributes, attribute) | | ------------------ | | | | 58| 6| atomic_fetch_or_explicit((o), (v), memory_order_release) | | ------------------ ------------------ 631| 6| } 632| | DNS_VECHEADER_SETATTR(header, DNS_VECHEADERATTR_CASESET); ------------------ | | 144| 6| atomic_fetch_or_release(&(header)->attributes, attribute) | | ------------------ | | | | 58| 6| atomic_fetch_or_explicit((o), (v), memory_order_release) | | ------------------ ------------------ 633| 6|} vecheader_first: 649| 121| dns_rdataclass_t rdclass) { 650| 121| uint16_t count = header->count; 651| | 652| 121| *iter = (rdatavec_iter_t){ 653| 121| .iter_pos = count == 0 ? NULL : header->raw, ------------------ | Branch (653:15): [True: 0, False: 121] ------------------ 654| 121| .iter_count = count, 655| 121| .iter_rdclass = rdclass, 656| 121| .iter_type = DNS_TYPEPAIR_TYPE(header->typepair), ------------------ | | 29| 121| ({ \ | | 30| 121| dns_rdatatype_t __base = (dns_rdatatype_t)((type) & 0xFFFF); \ | | 31| 121| dns_rdatatype_t __covers = (dns_rdatatype_t)((type) >> 16); \ | | 32| 121| DNS__TYPEPAIR_CHECK(__base, __covers); \ | | ------------------ | | | | 25| 121|#define DNS__TYPEPAIR_CHECK(base, covers) (void)(base), (void)(covers) | | ------------------ | | 33| 121| __base; \ | | 34| 121| }) ------------------ 657| 121| }; 658| | 659| 121| return count == 0 ? ISC_R_NOMORE : ISC_R_SUCCESS; ------------------ | Branch (659:9): [True: 0, False: 121] ------------------ 660| 121|} vecheader_next: 663| 120|vecheader_next(rdatavec_iter_t *iter) { 664| 120| unsigned int count = iter->iter_count; 665| 120| if (count <= 1) { ------------------ | Branch (665:6): [True: 120, False: 0] ------------------ 666| 120| iter->iter_pos = NULL; 667| 120| iter->iter_count = 0; 668| 120| return ISC_R_NOMORE; 669| 120| } 670| 0| iter->iter_count = count - 1; 671| | 672| 0| unsigned char *raw = iter->iter_pos; 673| 0| uint16_t length = peek_uint16(raw); ------------------ | | 36| 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]))) | | ------------------ ------------------ 674| 0| raw += length; 675| 0| iter->iter_pos = raw + sizeof(uint16_t); 676| | 677| 0| return ISC_R_SUCCESS; 678| 120|} vecheader_current: 681| 121|vecheader_current(rdatavec_iter_t *iter, dns_rdata_t *rdata) { 682| 121| unsigned char *raw = NULL; 683| 121| unsigned int length; 684| 121| isc_region_t r; 685| 121| unsigned int flags = 0; 686| | 687| 121| raw = iter->iter_pos; 688| 121| REQUIRE(raw != NULL); ------------------ | | 198| 121|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 121| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 121, False: 0] | | | | ------------------ | | | | 42| 121| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 689| | 690| 121| length = get_uint16(raw); ------------------ | | 38| 121| ({ \ | | 39| 121| uint16_t __ret = peek_uint16(buffer); \ | | ------------------ | | | | 36| 121|#define peek_uint16(buffer) ISC_U8TO16_BE(buffer) | | | | ------------------ | | | | | | 226| 121|#define ISC_U8TO16_BE(p) (((uint16_t)((p)[0]) << 8) | ((uint16_t)((p)[1]))) | | | | ------------------ | | ------------------ | | 40| 121| buffer += sizeof(uint16_t); \ | | 41| 121| __ret; \ | | 42| 121| }) ------------------ 691| | 692| 121| if (iter->iter_type == dns_rdatatype_rrsig) { ------------------ | | 161| 121|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (692:6): [True: 0, False: 121] ------------------ 693| 0| if (*raw & DNS_RDATAVEC_OFFLINE) { ------------------ | | 59| 0|#define DNS_RDATAVEC_OFFLINE 0x01 /* RRSIG is for offline DNSKEY */ ------------------ | Branch (693:7): [True: 0, False: 0] ------------------ 694| 0| flags |= DNS_RDATA_OFFLINE; ------------------ | | 169| 0|#define DNS_RDATA_OFFLINE 0x0002 /*%< RRSIG has a offline key. */ ------------------ 695| 0| } 696| 0| length--; 697| 0| raw++; 698| 0| } 699| 121| r.length = length; 700| 121| r.base = raw; 701| 121| dns_rdata_fromregion(rdata, iter->iter_rdclass, iter->iter_type, &r); 702| 121| rdata->flags |= flags; 703| 121|} dns_vectop_new: 798| 6|dns_vectop_new(isc_mem_t *mctx, dns_typepair_t typepair) { 799| 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) ------------------ 800| 6| *top = (dns_vectop_t){ 801| 6| .next_type = ISC_SLINK_INITIALIZER, ------------------ | | 30| 6| { \ | | 31| 6| .next = NULL, \ | | 32| 6| } ------------------ 802| 6| .headers = ISC_SLIST_INITIALIZER, ------------------ | | 25| 6| { \ | | 26| 6| .head = NULL, \ | | 27| 6| } ------------------ 803| 6| .typepair = typepair, 804| 6| }; 805| | 806| 6| return top; 807| 6|} rdatavec.c:makevec: 121| 6| uint32_t maxrrperset) { 122| 6| dns_rdata_t *rdata = NULL; 123| 6| unsigned char *rawbuf = NULL; 124| 6| unsigned int headerlen = sizeof(dns_vecheader_t); 125| 6| uint32_t buflen = headerlen; 126| 6| isc_result_t result; 127| 6| unsigned int nitems; 128| 6| unsigned int nalloc; 129| 6| unsigned int length; 130| 6| size_t i; 131| 6| size_t rdatasize; 132| | 133| | /* 134| | * If the source rdataset is also a vec, we don't need 135| | * to do anything special, just copy the whole vec to a 136| | * new buffer. 137| | */ 138| 6| if (rdataset->methods == &dns_rdatavec_rdatasetmethods) { ------------------ | Branch (138:6): [True: 0, False: 6] ------------------ 139| 0| dns_vecheader_t *header = dns_vecheader_getheader(rdataset); 140| | 141| 0| rawbuf = newvec(rdataset, mctx, region, header->count, 142| 0| header->raw_length); 143| 0| memmove(rawbuf, header->raw, header->raw_length); 144| 0| return ISC_R_SUCCESS; 145| 0| } 146| | 147| | /* 148| | * If there are no rdata then we just need to allocate a header 149| | * with a zero record count. 150| | */ 151| 6| nitems = dns_rdataset_count(rdataset); 152| 6| if (nitems == 0) { ------------------ | Branch (152:6): [True: 0, False: 6] ------------------ 153| 0| if (rdataset->type != 0) { ------------------ | Branch (153:7): [True: 0, False: 0] ------------------ 154| 0| return ISC_R_FAILURE; 155| 0| } 156| 0| (void)newvec(rdataset, mctx, region, 0, 0); 157| 0| return ISC_R_SUCCESS; 158| 0| } 159| | 160| 6| if (maxrrperset > 0 && nitems > maxrrperset) { ------------------ | Branch (160:6): [True: 0, False: 6] | Branch (160:25): [True: 0, False: 0] ------------------ 161| 0| return DNS_R_TOOMANYRECORDS; 162| 0| } 163| | 164| 6| if (nitems > 0xffff) { ------------------ | Branch (164:6): [True: 0, False: 6] ------------------ 165| 0| return ISC_R_NOSPACE; 166| 0| } 167| | 168| | /* 169| | * Remember the original number of items. 170| | */ 171| 6| nalloc = nitems; 172| | 173| 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] | | ------------------ ------------------ 174| 6| rdata = isc_mem_get(mctx, rdatasize); ------------------ | | 144| 6|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 175| | 176| | /* 177| | * Save all of the rdata members into an array. 178| | */ 179| 6| result = dns_rdataset_first(rdataset); 180| 6| if (result != ISC_R_SUCCESS && result != ISC_R_NOMORE) { ------------------ | Branch (180:6): [True: 0, False: 6] | Branch (180:33): [True: 0, False: 0] ------------------ 181| 0| goto free_rdatas; 182| 0| } 183| 12| for (i = 0; i < nalloc && result == ISC_R_SUCCESS; i++) { ------------------ | Branch (183:14): [True: 6, False: 6] | Branch (183:28): [True: 6, False: 0] ------------------ 184| 6| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 185| 6| dns_rdata_init(&rdata[i]); 186| 6| dns_rdataset_current(rdataset, &rdata[i]); 187| 6| result = dns_rdataset_next(rdataset); 188| 6| } 189| 6| if (i != nalloc || result != ISC_R_NOMORE) { ------------------ | Branch (189:6): [True: 0, False: 6] | Branch (189:21): [True: 0, False: 6] ------------------ 190| | /* 191| | * Somehow we iterated over fewer rdatas than 192| | * dns_rdataset_count() said there were or there 193| | * were more items than dns_rdataset_count said 194| | * there were. 195| | */ 196| 0| result = ISC_R_FAILURE; 197| 0| goto free_rdatas; 198| 0| } 199| | 200| | /* 201| | * Put into DNSSEC order. 202| | */ 203| 6| if (nalloc > 1U) { ------------------ | Branch (203:6): [True: 0, False: 6] ------------------ 204| 0| qsort(rdata, nalloc, sizeof(rdata[0]), compare_rdata); 205| 0| } 206| 6| nitems = 0; 207| | 208| | /* 209| | * Remove duplicates and compute the total storage required. 210| | * 211| | * If an rdata is not a duplicate, accumulate the storage size 212| | * required for the rdata. We do not store the class, type, etc, 213| | * just the rdata, so our overhead is 2 bytes for the length of each 214| | * rdata, plus the rdata itself. 215| | */ 216| 12| for (i = 0; i < nalloc; i++) { ------------------ | Branch (216:14): [True: 6, False: 6] ------------------ 217| 6| bool duplicate = i + 1 < nalloc && ------------------ | Branch (217:20): [True: 0, False: 6] ------------------ 218| 0| compare_rdata(&rdata[i], &rdata[i + 1]) == 0; ------------------ | Branch (218:6): [True: 0, False: 0] ------------------ 219| | 220| 6| if (duplicate) { ------------------ | Branch (220:7): [True: 0, False: 6] ------------------ 221| 0| continue; 222| 0| } 223| | 224| 6| buflen += sizeof(uint16_t) + rdata[i].length + 225| 6| (rdataset->type == dns_rdatatype_rrsig); ------------------ | | 161| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ 226| 6| if (buflen - headerlen > DNS_RDATA_MAXLENGTH) { ------------------ | | 183| 6|#define DNS_RDATA_MAXLENGTH 65512U ------------------ | Branch (226:7): [True: 0, False: 6] ------------------ 227| 0| result = ISC_R_NOSPACE; 228| 0| goto free_rdatas; 229| 0| } 230| | 231| 6| rdata[nitems++] = rdata[i]; 232| 6| } 233| | 234| | /* 235| | * Ensure that singleton types are actually singletons. 236| | */ 237| 6| if (nitems > 1 && dns_rdatatype_issingleton(rdataset->type)) { ------------------ | Branch (237:6): [True: 0, False: 6] | Branch (237:20): [True: 0, False: 0] ------------------ 238| | /* 239| | * We have a singleton type, but there's more than one 240| | * RR in the rdataset. 241| | */ 242| 0| result = DNS_R_SINGLETON; 243| 0| goto free_rdatas; 244| 0| } 245| | 246| | /* 247| | * Allocate the memory, set up a buffer, start copying in 248| | * data. 249| | */ 250| 6| rawbuf = newvec(rdataset, mctx, region, nitems, buflen - headerlen); 251| | 252| 12| for (i = 0; i < nitems; i++) { ------------------ | Branch (252:14): [True: 6, False: 6] ------------------ 253| 6| length = rdata[i].length; 254| 6| if (rdataset->type == dns_rdatatype_rrsig) { ------------------ | | 161| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (254:7): [True: 0, False: 6] ------------------ 255| 0| length++; 256| 0| } 257| 6| INSIST(length <= 0xffff); ------------------ | | 202| 6|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6, False: 0] | | | | ------------------ | | | | 54| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 258| | 259| 6| put_uint16(rawbuf, length); ------------------ | | 44| 6| { \ | | 45| 6| ISC_U16TO8_BE(buffer, val); \ | | ------------------ | | | | 223| 6| (p)[0] = (uint8_t)((v) >> 8); \ | | | | 224| 6| (p)[1] = (uint8_t)((v)); | | ------------------ | | 46| 6| (buffer) += sizeof(uint16_t); \ | | 47| 6| } ------------------ 260| | 261| | /* 262| | * Store the per RR meta data. 263| | */ 264| 6| if (rdataset->type == dns_rdatatype_rrsig) { ------------------ | | 161| 6|#define dns_rdatatype_rrsig ((dns_rdatatype_t)dns_rdatatype_rrsig) ------------------ | Branch (264:7): [True: 0, False: 6] ------------------ 265| 0| *rawbuf++ = (rdata[i].flags & DNS_RDATA_OFFLINE) ------------------ | | 169| 0|#define DNS_RDATA_OFFLINE 0x0002 /*%< RRSIG has a offline key. */ ------------------ | Branch (265:16): [True: 0, False: 0] ------------------ 266| 0| ? DNS_RDATAVEC_OFFLINE ------------------ | | 59| 0|#define DNS_RDATAVEC_OFFLINE 0x01 /* RRSIG is for offline DNSKEY */ ------------------ 267| 0| : 0; 268| 0| } 269| 6| if (rdata[i].length != 0) { ------------------ | Branch (269:7): [True: 6, False: 0] ------------------ 270| 6| memmove(rawbuf, rdata[i].data, rdata[i].length); 271| 6| } 272| 6| rawbuf += rdata[i].length; 273| 6| } 274| | 275| 6| result = ISC_R_SUCCESS; 276| | 277| 6|free_rdatas: 278| | 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] | | ------------------ ------------------ 279| 6| return result; 280| 6|} rdatavec.c:newvec: 97| 6| uint16_t count, uint32_t raw_length) { 98| 6| size_t size = sizeof(dns_vecheader_t) + raw_length; 99| 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) ------------------ 100| | 101| 6| *header = (dns_vecheader_t){ 102| 6| .count = count, 103| 6| .raw_length = raw_length, 104| 6| .next_header = ISC_SLINK_INITIALIZER, ------------------ | | 30| 6| { \ | | 31| 6| .next = NULL, \ | | 32| 6| } ------------------ 105| 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| }) ------------------ 106| 6| rdataset->covers), 107| 6| .trust = rdataset->trust, 108| 6| .ttl = rdataset->ttl, 109| 6| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 6|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 110| 6| .mctx = isc_mem_ref(mctx), 111| 6| }; 112| | 113| 6| region->base = (unsigned char *)header; 114| 6| region->length = size; 115| | 116| 6| return header->raw; 117| 6|} rdatavec.c:rdataset_disassociate: 708| 121|rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 709| 121| dns_vecheader_unref(rdataset->vec.header); 710| 121|} rdatavec.c:rdataset_first: 713| 121|rdataset_first(dns_rdataset_t *rdataset) { 714| 121| return vecheader_first(&rdataset->vec.iter, rdataset->vec.header, 715| 121| rdataset->rdclass); 716| 121|} rdatavec.c:rdataset_next: 719| 120|rdataset_next(dns_rdataset_t *rdataset) { 720| 120| return vecheader_next(&rdataset->vec.iter); 721| 120|} rdatavec.c:rdataset_current: 724| 121|rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { 725| 121| vecheader_current(&rdataset->vec.iter, rdata); 726| 121|} dns__tsig_algvalid: 101| 520|dns__tsig_algvalid(unsigned int alg) { 102| 520| return alg == DST_ALG_HMACMD5 || alg == DST_ALG_HMACSHA1 || ------------------ | Branch (102:9): [True: 1, False: 519] | Branch (102:35): [True: 4, False: 515] ------------------ 103| 515| alg == DST_ALG_HMACSHA224 || alg == DST_ALG_HMACSHA256 || ------------------ | Branch (103:9): [True: 1, False: 514] | Branch (103:38): [True: 219, False: 295] ------------------ 104| 295| alg == DST_ALG_HMACSHA384 || alg == DST_ALG_HMACSHA512; ------------------ | Branch (104:9): [True: 1, False: 294] | Branch (104:38): [True: 1, False: 293] ------------------ 105| 520|} dns_tsigkey_createfromkey: 159| 304| dns_tsigkey_t **keyp) { 160| 304| dns_tsigkey_t *tkey = NULL; 161| 304| isc_result_t result; 162| | 163| 304| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 198| 304|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 608| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 304, False: 0] | | | | | Branch (41:11): [True: 304, False: 0] | | | | ------------------ | | | | 42| 304| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 164| 304| REQUIRE(name != NULL); ------------------ | | 198| 304|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 304| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 304, False: 0] | | | | ------------------ | | | | 42| 304| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 165| 304| REQUIRE(mctx != NULL); ------------------ | | 198| 304|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 304| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 304, False: 0] | | | | ------------------ | | | | 42| 304| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 166| | 167| 304| tkey = isc_mem_get(mctx, sizeof(dns_tsigkey_t)); ------------------ | | 144| 304|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 168| 304| *tkey = (dns_tsigkey_t){ 169| 304| .generated = generated, 170| 304| .restored = restored, 171| 304| .inception = inception, 172| 304| .expire = expire, 173| 304| .alg = algorithm, 174| 304| .algname = DNS_NAME_INITEMPTY, ------------------ | | 210| 304|#define DNS_NAME_INITEMPTY { .magic = DNS_NAME_MAGIC } | | ------------------ | | | | 153| 304|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | | | ------------------ | | | | | | 31| 304|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | | | ------------------ | | ------------------ ------------------ 175| 304| .lrulink = ISC_LINK_INITIALIZER, ------------------ | | 30| 304|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 304| { \ | | | | 27| 304| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 304|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 304| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 304|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 304| } | | ------------------ ------------------ 176| 304| }; 177| | 178| 304| tkey->name = dns_fixedname_initname(&tkey->fn); 179| 304| dns_name_copy(name, tkey->name); ------------------ | | 1525| 304| dns_name__copy(DNS_NAME__RO_ARG(source), dest) | | ------------------ | | | | 1507| 304| _Generic((arg), \ | | | | 1508| 304| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 304| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 304| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 304| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 304| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 304| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 180| 304| (void)dns_name_downcase(tkey->name, tkey->name); 181| | 182| 304| if (algorithm != DST_ALG_UNKNOWN) { ------------------ | Branch (182:6): [True: 12, False: 292] ------------------ 183| 12| if (dstkey != NULL && dst_key_alg(dstkey) != algorithm) { ------------------ | Branch (183:7): [True: 2, False: 10] | Branch (183:25): [True: 0, False: 2] ------------------ 184| 0| result = DNS_R_BADALG; 185| 0| goto cleanup_name; 186| 0| } 187| 292| } else if (dstkey != NULL) { ------------------ | Branch (187:13): [True: 0, False: 292] ------------------ 188| 0| result = DNS_R_BADALG; 189| 0| goto cleanup_name; 190| 0| } 191| | 192| 304| if (creator != NULL) { ------------------ | Branch (192:6): [True: 0, False: 304] ------------------ 193| 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) ------------------ 194| 0| dns_name_init(tkey->creator); 195| 0| dns_name_dup(creator, mctx, tkey->creator); ------------------ | | 1522| 0| dns_name__dup(DNS_NAME__RO_ARG(source), mctx, target) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 196| 0| } 197| | 198| 304| if (dstkey != NULL) { ------------------ | Branch (198:6): [True: 2, False: 302] ------------------ 199| 2| dst_key_attach(dstkey, &tkey->key); 200| 2| } 201| | 202| 304| isc_refcount_init(&tkey->references, 1); ------------------ | | 44| 304|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 203| 304| isc_mem_attach(mctx, &tkey->mctx); 204| | 205| | /* 206| | * Ignore this if it's a GSS key, since the key size is meaningless. 207| | */ 208| 304| if (dstkey != NULL && dst_key_size(dstkey) < 64 && ------------------ | Branch (208:6): [True: 2, False: 302] | Branch (208:24): [True: 0, False: 2] ------------------ 209| 0| algorithm != DST_ALG_GSSAPI) ------------------ | Branch (209:6): [True: 0, False: 0] ------------------ 210| 0| { 211| 0| char namestr[DNS_NAME_FORMATSIZE]; 212| 0| dns_name_format(name, namestr, sizeof(namestr)); ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 213| 0| isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, 214| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 215| 0| "the key '%s' is too short to be secure", 216| 0| namestr); 217| 0| } 218| | 219| 304| tkey->magic = TSIG_MAGIC; ------------------ | | 46| 304|#define TSIG_MAGIC ISC_MAGIC('T', 'S', 'I', 'G') | | ------------------ | | | | 31| 304|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 220| | 221| 304| if (tkey->restored) { ------------------ | Branch (221:6): [True: 0, False: 304] ------------------ 222| 0| tsig_log(tkey, ISC_LOG_DEBUG(3), "restored from file"); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 223| 304| } else if (tkey->generated) { ------------------ | Branch (223:13): [True: 0, False: 304] ------------------ 224| 0| tsig_log(tkey, ISC_LOG_DEBUG(3), "generated"); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 225| 304| } else { 226| 304| tsig_log(tkey, ISC_LOG_DEBUG(3), "statically configured"); ------------------ | | 36| 304|#define ISC_LOG_DEBUG(level) (level) ------------------ 227| 304| } 228| | 229| 304| SET_IF_NOT_NULL(keyp, tkey); ------------------ | | 104| 304| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 304, False: 0] | | ------------------ | | 105| 304| *(obj) = (val); \ | | 106| 304| } ------------------ 230| 304| return ISC_R_SUCCESS; 231| | 232| 0|cleanup_name: 233| 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] | | ------------------ ------------------ 234| | 235| 0| return result; 236| 304|} dns__tsig_algfromname: 282| 557|dns__tsig_algfromname(const dns_name_t *algorithm) { 283| 4.37k| for (size_t i = 0; i < ARRAY_SIZE(known_algs); ++i) { ------------------ | | 98| 4.37k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (283:21): [True: 3.83k, False: 538] ------------------ 284| 3.83k| const dns_name_t *name = known_algs[i].name; 285| 3.83k| if (algorithm == name || dns_name_equal(algorithm, name)) { ------------------ | | 1541| 3.83k| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 3.83k| _Generic((arg), \ | | | | 1508| 3.83k| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 3.83k| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 3.83k| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 3.83k| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 3.83k| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 3.83k| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 3.83k| _Generic((arg), \ | | | | 1508| 3.83k| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 3.83k| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 3.83k| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 3.83k| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 3.83k| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 3.83k| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1541:2): [True: 19, False: 3.82k] | | ------------------ ------------------ | Branch (285:7): [True: 0, False: 3.83k] ------------------ 286| 19| return known_algs[i].dstalg; 287| 19| } 288| 3.83k| } 289| 538| return DST_ALG_UNKNOWN; 290| 557|} dns_tsigkey_create: 524| 304| dns_tsigkey_t **key) { 525| 304| dst_key_t *dstkey = NULL; 526| 304| isc_result_t result; 527| | 528| 304| REQUIRE(length >= 0); ------------------ | | 198| 304|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 304| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 304, False: 0] | | | | ------------------ | | | | 42| 304| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 529| 304| if (length > 0) { ------------------ | Branch (529:6): [True: 2, False: 302] ------------------ 530| 2| REQUIRE(secret != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 531| 2| } 532| | 533| 304| if (dns__tsig_algvalid(algorithm)) { ------------------ | Branch (533:6): [True: 11, False: 293] ------------------ 534| 11| if (secret != NULL) { ------------------ | Branch (534:7): [True: 2, False: 9] ------------------ 535| 2| isc_buffer_t b; 536| | 537| 2| isc_buffer_init(&b, secret, length); 538| 2| isc_buffer_add(&b, length); 539| 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| } ------------------ 540| 2| name, algorithm, 0, DNS_KEYPROTO_DNSSEC, 541| 2| dns_rdataclass_in, &b, mctx, &dstkey)); 542| 2| } 543| 293| } else if (length > 0) { ------------------ | Branch (543:13): [True: 0, False: 293] ------------------ 544| 0| return DNS_R_BADALG; 545| 0| } 546| | 547| 304| result = dns_tsigkey_createfromkey(name, algorithm, dstkey, false, 548| 304| false, NULL, 0, 0, mctx, key); 549| 304| if (dstkey != NULL) { ------------------ | Branch (549:6): [True: 2, False: 302] ------------------ 550| 2| dst_key_free(&dstkey); 551| 2| } 552| 304| return result; 553| 304|} dns_tsig_verify: 879| 600| dns_tsigkeyring_t *ring1, dns_tsigkeyring_t *ring2) { 880| 600| dns_rdata_any_tsig_t tsig, querytsig; 881| 600| isc_region_t r, source_r, header_r, sig_r; 882| 600| isc_buffer_t databuf; 883| 600| unsigned char data[32]; 884| 600| dns_name_t *keyname = NULL; 885| 600| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 600| { \ | | 150| 600| .data = NULL, \ | | 151| 600| .link = ISC_LINK_INITIALIZER, \ | | ------------------ | | | | 30| 600|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | | | ------------------ | | | | | | 26| 600| { \ | | | | | | 27| 600| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 600|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 28| 600| .next = ISC_LINK_TOMBSTONE(type), \ | | | | | | ------------------ | | | | | | | | 18| 600|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 29| 600| } | | | | ------------------ | | ------------------ | | 152| 600| } ------------------ 886| 600| isc_stdtime_t now; 887| 600| isc_result_t result; 888| 600| dns_tsigkey_t *tsigkey = NULL; 889| 600| dst_key_t *key = NULL; 890| 600| unsigned char header[DNS_MESSAGE_HEADERLEN]; 891| 600| dst_context_t *ctx = NULL; 892| 600| isc_mem_t *mctx = NULL; 893| 600| uint16_t addcount, id; 894| 600| unsigned int siglen; 895| 600| unsigned int alg; 896| 600| bool response; 897| | 898| 600| REQUIRE(source != NULL); ------------------ | | 198| 600|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 600| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 600, False: 0] | | | | ------------------ | | | | 42| 600| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 899| 600| REQUIRE(DNS_MESSAGE_VALID(msg)); ------------------ | | 198| 600|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 600, False: 0] | | | | | Branch (41:11): [True: 600, False: 0] | | | | ------------------ | | | | 42| 600| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 900| 600| tsigkey = dns_message_gettsigkey(msg); 901| 600| response = is_response(msg); ------------------ | | 49| 600|#define is_response(msg) ((msg->flags & DNS_MESSAGEFLAG_QR) != 0) ------------------ 902| | 903| 600| REQUIRE(tsigkey == NULL || VALID_TSIGKEY(tsigkey)); ------------------ | | 198| 600|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.48k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 294, False: 0] | | | | | Branch (41:11): [True: 294, False: 0] | | | | | Branch (41:11): [True: 306, False: 294] | | | | ------------------ | | | | 42| 600| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 904| | 905| 600| msg->verify_attempted = 1; 906| 600| msg->verified_sig = 0; 907| 600| msg->tsigstatus = dns_tsigerror_badsig; 908| | 909| 600| if (msg->tcp_continuation) { ------------------ | Branch (909:6): [True: 0, False: 600] ------------------ 910| 0| if (tsigkey == NULL || msg->querytsig == NULL) { ------------------ | Branch (910:7): [True: 0, False: 0] | Branch (910:26): [True: 0, False: 0] ------------------ 911| 0| return DNS_R_UNEXPECTEDTSIG; 912| 0| } 913| 0| return tsig_verify_tcp(source, msg); 914| 0| } 915| | 916| | /* 917| | * There should be a TSIG record... 918| | */ 919| 600| if (msg->tsig == NULL) { ------------------ | Branch (919:6): [True: 40, False: 560] ------------------ 920| 40| return DNS_R_EXPECTEDTSIG; 921| 40| } 922| | 923| | /* 924| | * If this is a response and there's no key or query TSIG, there 925| | * shouldn't be one on the response. 926| | */ 927| 560| if (response && (tsigkey == NULL || msg->querytsig == NULL)) { ------------------ | Branch (927:6): [True: 196, False: 364] | Branch (927:19): [True: 2, False: 194] | Branch (927:38): [True: 2, False: 192] ------------------ 928| 4| return DNS_R_UNEXPECTEDTSIG; 929| 4| } 930| | 931| 556| mctx = msg->mctx; 932| | 933| | /* 934| | * If we're here, we know the message is well formed and contains a 935| | * TSIG record. 936| | */ 937| | 938| 556| keyname = dns_name(msg->tsigname); ------------------ | | 1515| 556|#define dns_name(source) DNS_NAME__RO_ARG(source) | | ------------------ | | | | 1507| 556| _Generic((arg), \ | | | | 1508| 556| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 556| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 556| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 556| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 556| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 556| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 939| 556| RETERR(dns_rdataset_first(msg->tsig)); ------------------ | | 276| 556| { \ | | 277| 556| isc_result_t _r = (x); \ | | 278| 556| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 556] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 556| } ------------------ 940| 556| dns_rdataset_current(msg->tsig, &rdata); 941| 556| RETERR(dns_rdata_tostruct(&rdata, &tsig)); ------------------ | | 276| 556| { \ | | 277| 556| isc_result_t _r = (x); \ | | 278| 556| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 556] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 556| } ------------------ 942| 556| dns_rdata_reset(&rdata); 943| 556| if (response) { ------------------ | Branch (943:6): [True: 192, False: 364] ------------------ 944| 192| RETERR(dns_rdataset_first(msg->querytsig)); ------------------ | | 276| 192| { \ | | 277| 192| isc_result_t _r = (x); \ | | 278| 192| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 192] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 192| } ------------------ 945| 192| dns_rdataset_current(msg->querytsig, &rdata); 946| 192| RETERR(dns_rdata_tostruct(&rdata, &querytsig)); ------------------ | | 276| 192| { \ | | 277| 192| isc_result_t _r = (x); \ | | 278| 192| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 192] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 192| } ------------------ 947| 192| } 948| | 949| | /* 950| | * Do the key name and algorithm match that of the query? 951| | */ 952| 556| if (response && ------------------ | Branch (952:6): [True: 192, False: 364] ------------------ 953| 192| (!dns_name_equal(keyname, tsigkey->name) || ------------------ | | 1541| 384| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 192| _Generic((arg), \ | | | | 1508| 192| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 192| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 192| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 192| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 192| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 192| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 192| _Generic((arg), \ | | | | 1508| 192| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 192| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 192| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 192| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 192| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 192| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (953:7): [True: 0, False: 192] ------------------ 954| 192| !dns_name_equal(&tsig.algorithm, &querytsig.algorithm))) ------------------ | | 1541| 192| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 192| _Generic((arg), \ | | | | 1508| 192| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 192| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 192| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 192| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 192| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 192| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 192| _Generic((arg), \ | | | | 1508| 192| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 192| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 192| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 192| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 192| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 192| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ | Branch (954:7): [True: 38, False: 154] ------------------ 955| 38| { 956| 38| msg->tsigstatus = dns_tsigerror_badkey; 957| 38| tsig_log(msg->tsigkey, 2, 958| 38| "key name and algorithm do not match"); 959| 38| return DNS_R_TSIGVERIFYFAILURE; 960| 38| } 961| | 962| | /* 963| | * Get the current time. 964| | */ 965| 518| if (msg->fuzzing) { ------------------ | Branch (965:6): [True: 518, False: 0] ------------------ 966| 518| now = msg->fuzztime; 967| 518| } else { 968| 0| now = isc_stdtime_now(); 969| 0| } 970| | 971| | /* 972| | * Find dns_tsigkey_t based on keyname. 973| | */ 974| 518| if (tsigkey == NULL) { ------------------ | Branch (974:6): [True: 304, False: 214] ------------------ 975| 304| result = ISC_R_NOTFOUND; 976| 304| if (ring1 != NULL) { ------------------ | Branch (976:7): [True: 295, False: 9] ------------------ 977| 295| result = dns_tsigkey_find(&tsigkey, keyname, 978| 295| &tsig.algorithm, ring1); 979| 295| } 980| 304| if (result == ISC_R_NOTFOUND && ring2 != NULL) { ------------------ | Branch (980:7): [True: 302, False: 2] | Branch (980:35): [True: 293, False: 9] ------------------ 981| 293| result = dns_tsigkey_find(&tsigkey, keyname, 982| 293| &tsig.algorithm, ring2); 983| 293| } 984| 304| if (result != ISC_R_SUCCESS) { ------------------ | Branch (984:7): [True: 302, False: 2] ------------------ 985| 302| msg->tsigstatus = dns_tsigerror_badkey; 986| 302| alg = dns__tsig_algfromname(&tsig.algorithm); 987| 302| RETERR(dns_tsigkey_create(keyname, alg, NULL, 0, mctx, ------------------ | | 276| 302| { \ | | 277| 302| isc_result_t _r = (x); \ | | 278| 302| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 302] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 302| } ------------------ 988| 302| &msg->tsigkey)); 989| 302| if (alg == DST_ALG_UNKNOWN) { ------------------ | Branch (989:8): [True: 292, False: 10] ------------------ 990| 292| dns_name_clone(&tsig.algorithm, ------------------ | | 1519| 292| dns_name__clone(DNS_NAME__RO_ARG(source), target) | | ------------------ | | | | 1507| 292| _Generic((arg), \ | | | | 1508| 292| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 292| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 292| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 292| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 292| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 292| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 991| 292| &msg->tsigkey->algname); 992| 292| } 993| | 994| 302| tsig_log(msg->tsigkey, 2, "unknown key"); 995| 302| return DNS_R_TSIGVERIFYFAILURE; 996| 302| } 997| 2| msg->tsigkey = tsigkey; 998| 2| } 999| | 1000| 216| key = tsigkey->key; 1001| | 1002| | /* 1003| | * Check digest length. 1004| | */ 1005| 216| alg = dst_key_alg(key); 1006| 216| RETERR(dst_key_sigsize(key, &siglen)); ------------------ | | 276| 216| { \ | | 277| 216| isc_result_t _r = (x); \ | | 278| 216| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 216] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 216| } ------------------ 1007| 216| if (dns__tsig_algvalid(alg)) { ------------------ | Branch (1007:6): [True: 216, False: 0] ------------------ 1008| 216| uint16_t digestbits = dst_key_getbits(key); 1009| | 1010| 216| if (tsig.siglen > siglen) { ------------------ | Branch (1010:7): [True: 20, False: 196] ------------------ 1011| 20| tsig_log(msg->tsigkey, 2, "signature length too big"); 1012| 20| return DNS_R_FORMERR; 1013| 20| } 1014| 196| if (tsig.siglen > 0 && ------------------ | Branch (1014:7): [True: 47, False: 149] ------------------ 1015| 47| (tsig.siglen < 10 || tsig.siglen < ((siglen + 1) / 2))) ------------------ | Branch (1015:8): [True: 8, False: 39] | Branch (1015:28): [True: 3, False: 36] ------------------ 1016| 11| { 1017| 11| tsig_log(msg->tsigkey, 2, 1018| 11| "signature length below minimum"); 1019| 11| return DNS_R_FORMERR; 1020| 11| } 1021| | 1022| 185| if (tsig.siglen > 0 && digestbits != 0 && ------------------ | Branch (1022:7): [True: 36, False: 149] | Branch (1022:26): [True: 0, False: 36] ------------------ 1023| 0| tsig.siglen < ((digestbits + 7) / 8)) ------------------ | Branch (1023:7): [True: 0, False: 0] ------------------ 1024| 0| { 1025| 0| msg->tsigstatus = dns_tsigerror_badtrunc; 1026| 0| tsig_log(msg->tsigkey, 2, 1027| 0| "truncated signature length too small"); 1028| 0| return DNS_R_TSIGVERIFYFAILURE; 1029| 0| } 1030| 185| if (tsig.siglen > 0 && digestbits == 0 && tsig.siglen < siglen) ------------------ | Branch (1030:7): [True: 36, False: 149] | Branch (1030:26): [True: 36, False: 0] | Branch (1030:45): [True: 7, False: 29] ------------------ 1031| 7| { 1032| 7| msg->tsigstatus = dns_tsigerror_badtrunc; 1033| 7| tsig_log(msg->tsigkey, 2, "signature length too small"); 1034| 7| return DNS_R_TSIGVERIFYFAILURE; 1035| 7| } 1036| 185| } 1037| | 1038| 178| if (tsig.siglen > 0) { ------------------ | Branch (1038:6): [True: 29, False: 149] ------------------ 1039| 29| uint16_t addcount_n; 1040| | 1041| 29| sig_r.base = tsig.signature; 1042| 29| sig_r.length = tsig.siglen; 1043| | 1044| 29| RETERR(dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, ------------------ | | 276| 29| { \ | | 277| 29| isc_result_t _r = (x); \ | | 278| 29| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 29] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 29| } ------------------ 1045| 29| false, &ctx)); 1046| | 1047| 29| if (response) { ------------------ | Branch (1047:7): [True: 5, False: 24] ------------------ 1048| 5| isc_buffer_init(&databuf, data, sizeof(data)); 1049| 5| isc_buffer_putuint16(&databuf, querytsig.siglen); 1050| 5| isc_buffer_usedregion(&databuf, &r); 1051| 5| result = dst_context_adddata(ctx, &r); 1052| 5| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1052:8): [True: 0, False: 5] ------------------ 1053| 0| goto cleanup_context; 1054| 0| } 1055| 5| if (querytsig.siglen > 0) { ------------------ | Branch (1055:8): [True: 5, False: 0] ------------------ 1056| 5| r.length = querytsig.siglen; 1057| 5| r.base = querytsig.signature; 1058| 5| result = dst_context_adddata(ctx, &r); 1059| 5| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1059:9): [True: 0, False: 5] ------------------ 1060| 0| goto cleanup_context; 1061| 0| } 1062| 5| } 1063| 5| } 1064| | 1065| | /* 1066| | * Extract the header. 1067| | */ 1068| 29| isc_buffer_usedregion(source, &r); 1069| 29| memmove(header, r.base, DNS_MESSAGE_HEADERLEN); ------------------ | | 145| 29|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1070| 29| isc_region_consume(&r, DNS_MESSAGE_HEADERLEN); ------------------ | | 51| 29| do { \ | | 52| 29| isc_region_t *_r = (r); \ | | 53| 29| unsigned int _l = (l); \ | | 54| 29| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 29|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 29| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 29, False: 0] | | | | | | ------------------ | | | | | | 54| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 29| _r->base += _l; \ | | 56| 29| _r->length -= _l; \ | | 57| 29| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 29] | | ------------------ ------------------ 1071| | 1072| | /* 1073| | * Decrement the additional field counter. 1074| | */ 1075| 29| memmove(&addcount, &header[DNS_MESSAGE_HEADERLEN - 2], 2); ------------------ | | 145| 29|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1076| 29| addcount_n = ntohs(addcount); 1077| 29| addcount = htons((uint16_t)(addcount_n - 1)); 1078| 29| memmove(&header[DNS_MESSAGE_HEADERLEN - 2], &addcount, 2); ------------------ | | 145| 29|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1079| | 1080| | /* 1081| | * Put in the original id. 1082| | */ 1083| 29| id = htons(tsig.originalid); 1084| 29| memmove(&header[0], &id, 2); 1085| | 1086| | /* 1087| | * Digest the modified header. 1088| | */ 1089| 29| header_r.base = (unsigned char *)header; 1090| 29| header_r.length = DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 29|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1091| 29| result = dst_context_adddata(ctx, &header_r); 1092| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1092:7): [True: 0, False: 29] ------------------ 1093| 0| goto cleanup_context; 1094| 0| } 1095| | 1096| | /* 1097| | * Digest all non-TSIG records. 1098| | */ 1099| 29| isc_buffer_usedregion(source, &source_r); 1100| 29| r.base = source_r.base + DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 29|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1101| 29| r.length = msg->sigstart - DNS_MESSAGE_HEADERLEN; ------------------ | | 145| 29|#define DNS_MESSAGE_HEADERLEN 12 /*%< 6 uint16_t's */ ------------------ 1102| 29| result = dst_context_adddata(ctx, &r); 1103| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1103:7): [True: 0, False: 29] ------------------ 1104| 0| goto cleanup_context; 1105| 0| } 1106| | 1107| | /* 1108| | * Digest the key name. 1109| | */ 1110| 29| dns_name_toregion(tsigkey->name, &r); ------------------ | | 1548| 29|#define dns_name_toregion(name, r) dns_name__toregion(DNS_NAME__RO_ARG(name), r) | | ------------------ | | | | 1507| 29| _Generic((arg), \ | | | | 1508| 29| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 29| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 29| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 29| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 29| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 29| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1111| 29| result = dst_context_adddata(ctx, &r); 1112| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1112:7): [True: 0, False: 29] ------------------ 1113| 0| goto cleanup_context; 1114| 0| } 1115| | 1116| 29| isc_buffer_init(&databuf, data, sizeof(data)); 1117| 29| isc_buffer_putuint16(&databuf, tsig.common.rdclass); 1118| 29| isc_buffer_putuint32(&databuf, msg->tsig->ttl); 1119| 29| isc_buffer_usedregion(&databuf, &r); 1120| 29| result = dst_context_adddata(ctx, &r); 1121| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1121:7): [True: 0, False: 29] ------------------ 1122| 0| goto cleanup_context; 1123| 0| } 1124| | 1125| | /* 1126| | * Digest the key algorithm. 1127| | */ 1128| 29| dns_name_toregion(dns_tsigkey_algorithm(tsigkey), &r); ------------------ | | 1548| 29|#define dns_name_toregion(name, r) dns_name__toregion(DNS_NAME__RO_ARG(name), r) | | ------------------ | | | | 1507| 29| _Generic((arg), \ | | | | 1508| 29| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 29| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 29| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 29| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 29| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 29| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1129| 29| result = dst_context_adddata(ctx, &r); 1130| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1130:7): [True: 0, False: 29] ------------------ 1131| 0| goto cleanup_context; 1132| 0| } 1133| | 1134| 29| isc_buffer_clear(&databuf); 1135| 29| isc_buffer_putuint48(&databuf, tsig.timesigned); 1136| 29| isc_buffer_putuint16(&databuf, tsig.fudge); 1137| 29| isc_buffer_putuint16(&databuf, tsig.error); 1138| 29| isc_buffer_putuint16(&databuf, tsig.otherlen); 1139| 29| isc_buffer_usedregion(&databuf, &r); 1140| 29| result = dst_context_adddata(ctx, &r); 1141| 29| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1141:7): [True: 0, False: 29] ------------------ 1142| 0| goto cleanup_context; 1143| 0| } 1144| | 1145| 29| if (tsig.otherlen > 0) { ------------------ | Branch (1145:7): [True: 25, False: 4] ------------------ 1146| 25| r.base = tsig.other; 1147| 25| r.length = tsig.otherlen; 1148| 25| result = dst_context_adddata(ctx, &r); 1149| 25| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1149:8): [True: 0, False: 25] ------------------ 1150| 0| goto cleanup_context; 1151| 0| } 1152| 25| } 1153| | 1154| 29| result = dst_context_verify(ctx, &sig_r); 1155| 29| if (result == DST_R_VERIFYFAILURE) { ------------------ | Branch (1155:7): [True: 27, False: 2] ------------------ 1156| 27| result = DNS_R_TSIGVERIFYFAILURE; 1157| 27| tsig_log(msg->tsigkey, 2, 1158| 27| "signature failed to verify(1)"); 1159| 27| goto cleanup_context; 1160| 27| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (1160:14): [True: 0, False: 2] ------------------ 1161| 0| goto cleanup_context; 1162| 0| } 1163| 2| msg->verified_sig = 1; 1164| 149| } else if (!response || (tsig.error != dns_tsigerror_badsig && ------------------ | Branch (1164:13): [True: 6, False: 143] | Branch (1164:27): [True: 115, False: 28] ------------------ 1165| 115| tsig.error != dns_tsigerror_badkey)) ------------------ | Branch (1165:6): [True: 27, False: 88] ------------------ 1166| 33| { 1167| 33| tsig_log(msg->tsigkey, 2, "signature was empty"); 1168| 33| return DNS_R_TSIGVERIFYFAILURE; 1169| 33| } 1170| | 1171| | /* 1172| | * Here at this point, the MAC has been verified. Even if any of 1173| | * the following code returns a TSIG error, the reply will be 1174| | * signed and WILL always include the request MAC in the digest 1175| | * computation. 1176| | */ 1177| | 1178| | /* 1179| | * Is the time ok? 1180| | */ 1181| 118| if (now + msg->timeadjust > tsig.timesigned + tsig.fudge) { ------------------ | Branch (1181:6): [True: 1, False: 117] ------------------ 1182| 1| msg->tsigstatus = dns_tsigerror_badtime; 1183| 1| tsig_log(msg->tsigkey, 2, "signature has expired"); 1184| 1| result = DNS_R_CLOCKSKEW; 1185| 1| goto cleanup_context; 1186| 117| } else if (now + msg->timeadjust < tsig.timesigned - tsig.fudge) { ------------------ | Branch (1186:13): [True: 107, False: 10] ------------------ 1187| 107| msg->tsigstatus = dns_tsigerror_badtime; 1188| 107| tsig_log(msg->tsigkey, 2, "signature is in the future"); 1189| 107| result = DNS_R_CLOCKSKEW; 1190| 107| goto cleanup_context; 1191| 107| } 1192| | 1193| 10| if (response && tsig.error != dns_rcode_noerror) { ------------------ | | 270| 9|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ | Branch (1193:6): [True: 9, False: 1] | Branch (1193:18): [True: 8, False: 1] ------------------ 1194| 8| msg->tsigstatus = tsig.error; 1195| 8| if (tsig.error == dns_tsigerror_badtime) { ------------------ | Branch (1195:7): [True: 0, False: 8] ------------------ 1196| 0| result = DNS_R_CLOCKSKEW; 1197| 8| } else { 1198| 8| result = DNS_R_TSIGERRORSET; 1199| 8| } 1200| 8| goto cleanup_context; 1201| 8| } 1202| | 1203| 2| msg->tsigstatus = dns_rcode_noerror; ------------------ | | 270| 2|#define dns_rcode_noerror ((dns_rcode_t)dns_rcode_noerror) ------------------ 1204| 2| result = ISC_R_SUCCESS; 1205| | 1206| 145|cleanup_context: 1207| 145| if (ctx != NULL) { ------------------ | Branch (1207:6): [True: 29, False: 116] ------------------ 1208| 29| dst_context_destroy(&ctx); 1209| 29| } 1210| | 1211| 145| return result; 1212| 2|} dns_tsigkey_find: 1522| 588| const dns_name_t *algorithm, dns_tsigkeyring_t *ring) { 1523| 588| dns_tsigkey_t *key = NULL; 1524| 588| isc_result_t result; 1525| 588| isc_rwlocktype_t locktype = isc_rwlocktype_read; 1526| 588| isc_stdtime_t now = isc_stdtime_now(); 1527| | 1528| 588| REQUIRE(name != NULL); ------------------ | | 198| 588|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 588| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 588, False: 0] | | | | ------------------ | | | | 42| 588| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1529| 588| REQUIRE(VALID_TSIGKEYRING(ring)); ------------------ | | 198| 588|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 588, False: 0] | | | | | Branch (41:11): [True: 588, False: 0] | | | | ------------------ | | | | 42| 588| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1530| 588| REQUIRE(tsigkey != NULL && *tsigkey == NULL); ------------------ | | 198| 588|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 588, False: 0] | | | | | Branch (41:11): [True: 588, False: 0] | | | | ------------------ | | | | 42| 588| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1531| | 1532| 588|again: 1533| 588| RWLOCK(&ring->lock, locktype); ------------------ | | 30| 588| { \ | | 31| 588| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | 32| 588| (t), __FILE__, __LINE__)); \ | | 33| 588| isc_rwlock_lock((lp), (t)); \ | | ------------------ | | | | 252| 588| { \ | | | | 253| 588| switch (type) { \ | | | | 254| 588| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (254:3): [True: 588, False: 0] | | | | ------------------ | | | | 255| 588| isc_rwlock_rdlock(rwl); \ | | | | 256| 588| break; \ | | | | 257| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (257:3): [True: 0, False: 588] | | | | ------------------ | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | 259| 0| break; \ | | | | 260| 0| default: \ | | | | ------------------ | | | | | Branch (260:3): [True: 0, False: 588] | | | | ------------------ | | | | 261| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 262| 588| } \ | | | | 263| 588| } | | ------------------ | | 34| 588| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | 35| 588| (lp), (t), __FILE__, __LINE__)); \ | | 36| 588| } ------------------ 1534| 588| result = isc_hashmap_find(ring->keys, dns_name_hash(name), tkey_match, ------------------ | | 1531| 588|#define dns_name_hash(name) dns_name__hash(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 588| _Generic((arg), \ | | | | 1508| 588| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 588| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 588| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 588| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 588| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 588| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1535| 588| name, (void **)&key); 1536| 588| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (1536:6): [True: 333, False: 255] ------------------ 1537| 333| RWUNLOCK(&ring->lock, locktype); ------------------ | | 38| 333| { \ | | 39| 333| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | 40| 333| (lp), (t), __FILE__, __LINE__)); \ | | 41| 333| isc_rwlock_unlock((lp), (t)); \ | | ------------------ | | | | 282| 333| { \ | | | | 283| 333| switch (type) { \ | | | | 284| 333| case isc_rwlocktype_read: \ | | | | ------------------ | | | | | Branch (284:3): [True: 333, False: 0] | | | | ------------------ | | | | 285| 333| isc_rwlock_rdunlock(rwl); \ | | | | 286| 333| break; \ | | | | 287| 0| case isc_rwlocktype_write: \ | | | | ------------------ | | | | | Branch (287:3): [True: 0, False: 333] | | | | ------------------ | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | 289| 0| break; \ | | | | 290| 0| default: \ | | | | ------------------ | | | | | Branch (290:3): [True: 0, False: 333] | | | | ------------------ | | | | 291| 0| UNREACHABLE(); \ | | | | ------------------ | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 333| } \ | | | | 293| 333| } | | ------------------ | | 42| 333| } ------------------ 1538| 333| return result; 1539| 333| } 1540| | 1541| 255| if (algorithm != NULL && key->alg != dns__tsig_algfromname(algorithm)) { ------------------ | Branch (1541:6): [True: 255, False: 0] | Branch (1541:27): [True: 253, False: 2] ------------------ 1542| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 253| } \ | | | | 293| 253| } | | ------------------ | | 42| 253| } ------------------ 1543| 253| return ISC_R_NOTFOUND; 1544| 253| } 1545| 2| if (key->inception != key->expire && isc_serial_lt(key->expire, now)) { ------------------ | Branch (1545:6): [True: 0, False: 2] | Branch (1545:39): [True: 0, False: 0] ------------------ 1546| | /* 1547| | * The key has expired. 1548| | */ 1549| 0| if (locktype == isc_rwlocktype_read) { ------------------ | Branch (1549:7): [True: 0, False: 0] ------------------ 1550| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 1551| 0| locktype = isc_rwlocktype_write; 1552| 0| key = NULL; 1553| 0| goto again; 1554| 0| } 1555| 0| dns__tsigkey_delete(ring, key); 1556| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 0| } \ | | | | 293| 0| } | | ------------------ | | 42| 0| } ------------------ 1557| 0| return ISC_R_NOTFOUND; 1558| 0| } 1559| 2| dns_tsigkey_ref(key); 1560| 2| RWUNLOCK(&ring->lock, locktype); ------------------ | | 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 1561| 2| if (key->generated) { ------------------ | Branch (1561:6): [True: 0, False: 2] ------------------ 1562| | 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| } ------------------ 1563| 0| } 1564| 2| *tsigkey = key; 1565| 2| return ISC_R_SUCCESS; 1566| 2|} dns_tsigkey_algorithm: 1569| 29|dns_tsigkey_algorithm(dns_tsigkey_t *tkey) { 1570| 29| REQUIRE(VALID_TSIGKEY(tkey)); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 58| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 29, False: 0] | | | | | Branch (41:11): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1571| | 1572| 29| switch (tkey->alg) { 1573| 0| case DST_ALG_HMACMD5: ------------------ | Branch (1573:2): [True: 0, False: 29] ------------------ 1574| 0| return dns_tsig_hmacmd5_name; 1575| 0| case DST_ALG_HMACSHA1: ------------------ | Branch (1575:2): [True: 0, False: 29] ------------------ 1576| 0| return dns_tsig_hmacsha1_name; 1577| 0| case DST_ALG_HMACSHA224: ------------------ | Branch (1577:2): [True: 0, False: 29] ------------------ 1578| 0| return dns_tsig_hmacsha224_name; 1579| 29| case DST_ALG_HMACSHA256: ------------------ | Branch (1579:2): [True: 29, False: 0] ------------------ 1580| 29| return dns_tsig_hmacsha256_name; 1581| 0| case DST_ALG_HMACSHA384: ------------------ | Branch (1581:2): [True: 0, False: 29] ------------------ 1582| 0| return dns_tsig_hmacsha384_name; 1583| 0| case DST_ALG_HMACSHA512: ------------------ | Branch (1583:2): [True: 0, False: 29] ------------------ 1584| 0| return dns_tsig_hmacsha512_name; 1585| 0| case DST_ALG_GSSAPI: ------------------ | Branch (1585:2): [True: 0, False: 29] ------------------ 1586| 0| return dns_tsig_gssapi_name; 1587| | 1588| 0| case DST_ALG_UNKNOWN: ------------------ | Branch (1588:2): [True: 0, False: 29] ------------------ 1589| | /* 1590| | * If the tsigkey object was created with an 1591| | * unknown algorithm, then we cloned 1592| | * the algorithm name here. 1593| | */ 1594| 0| return &tkey->algname; 1595| | 1596| 0| default: ------------------ | Branch (1596:2): [True: 0, False: 29] ------------------ 1597| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 1598| 29| } 1599| 29|} dns_tsigkeyring_create: 1602| 6|dns_tsigkeyring_create(isc_mem_t *mctx, dns_tsigkeyring_t **ringp) { 1603| 6| dns_tsigkeyring_t *ring = NULL; 1604| | 1605| 6| REQUIRE(mctx != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1606| 6| REQUIRE(ringp != NULL && *ringp == NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1607| | 1608| 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) ------------------ 1609| 6| *ring = (dns_tsigkeyring_t){ 1610| 6| .magic = TSIGKEYRING_MAGIC, ------------------ | | 43| 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)) | | ------------------ ------------------ 1611| 6| .mctx = isc_mem_ref(mctx), 1612| 6| .references = ISC_REFCOUNT_INITIALIZER(1), ------------------ | | 34| 6|#define ISC_REFCOUNT_INITIALIZER(a) (a) ------------------ 1613| 6| }; 1614| | 1615| 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| } ------------------ 1616| | 1617| 6| isc_hashmap_create(mctx, 12, &ring->keys); 1618| 6| isc_rwlock_init(&ring->lock); 1619| | 1620| 6| *ringp = ring; 1621| 6|} dns_tsigkeyring_add: 1624| 2|dns_tsigkeyring_add(dns_tsigkeyring_t *ring, dns_tsigkey_t *tkey) { 1625| 2| isc_result_t result; 1626| | 1627| 2| REQUIRE(VALID_TSIGKEY(tkey)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1628| 2| REQUIRE(VALID_TSIGKEYRING(ring)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1629| | 1630| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 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| } ------------------ 1631| 2| result = isc_hashmap_add(ring->keys, dns_name_hash(tkey->name), ------------------ | | 1531| 2|#define dns_name_hash(name) dns_name__hash(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 1632| 2| tkey_match, tkey->name, tkey, NULL); 1633| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1633:6): [True: 2, False: 0] ------------------ 1634| 2| dns_tsigkey_ref(tkey); 1635| | 1636| | /* 1637| | * If this is a TKEY-generated key, add it to the LRU list, 1638| | * and if we've exceeded the quota for generated keys, 1639| | * delete the least recently used one. 1640| | */ 1641| 2| if (tkey->generated) { ------------------ | Branch (1641:7): [True: 0, False: 2] ------------------ 1642| 0| if (++ring->generated > DNS_TSIG_MAXGENERATEDKEYS) { ------------------ | | 62| 0|#define DNS_TSIG_MAXGENERATEDKEYS 4096 ------------------ | Branch (1642:8): [True: 0, False: 0] ------------------ 1643| 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 (1643:26): [True: 0, False: 0] ------------------ 1644| 0| ring->lrulist, visited, lrulink); 1645| 0| dns__tsigkey_delete(ring, key); 1646| 0| } 1647| | /* 1648| | * Insert the new key AFTER any possible eviction, so 1649| | * that the key is not evicted immediately after the 1650| | * insertion. 1651| | */ 1652| 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] | | | | ------------------ | | ------------------ ------------------ 1653| 0| } 1654| 2| } 1655| 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() | | | | | | ------------------ | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | ------------------ | | | | ------------------ | | | | 292| 2| } \ | | | | 293| 2| } | | ------------------ | | 42| 2| } ------------------ 1656| | 1657| 2| return result; 1658| 2|} tsig.c:tsig_log: 108| 850|tsig_log(dns_tsigkey_t *key, int level, const char *fmt, ...) { 109| 850| va_list ap; 110| 850| char message[4096]; 111| 850| char namestr[DNS_NAME_FORMATSIZE]; 112| 850| char creatorstr[DNS_NAME_FORMATSIZE]; 113| | 114| 850| if (!isc_log_wouldlog(level)) { ------------------ | Branch (114:6): [True: 850, False: 0] ------------------ 115| 850| return; 116| 850| } 117| 0| if (key != NULL) { ------------------ | Branch (117:6): [True: 0, False: 0] ------------------ 118| 0| dns_name_format(key->name, namestr, sizeof(namestr)); ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 119| 0| } else { 120| 0| strlcpy(namestr, "", sizeof(namestr)); 121| 0| } 122| | 123| 0| if (key != NULL && key->generated && key->creator != NULL) { ------------------ | Branch (123:6): [True: 0, False: 0] | Branch (123:21): [True: 0, False: 0] | Branch (123:39): [True: 0, False: 0] ------------------ 124| 0| dns_name_format(key->creator, creatorstr, sizeof(creatorstr)); ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 125| 0| } else { 126| 0| strlcpy(creatorstr, "", sizeof(creatorstr)); 127| 0| } 128| | 129| 0| va_start(ap, fmt); 130| 0| vsnprintf(message, sizeof(message), fmt, ap); 131| 0| va_end(ap); 132| 0| if (key != NULL && key->generated) { ------------------ | Branch (132:6): [True: 0, False: 0] | Branch (132:21): [True: 0, False: 0] ------------------ 133| 0| isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, level, 134| 0| "tsig key '%s' (%s): %s", namestr, creatorstr, 135| 0| message); 136| 0| } else { 137| 0| isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_TSIG, level, 138| 0| "tsig key '%s': %s", namestr, message); 139| 0| } 140| 0|} tsig.c:destroy_tsigkey: 556| 302|destroy_tsigkey(dns_tsigkey_t *key) { 557| 302| REQUIRE(VALID_TSIGKEY(key)); ------------------ | | 198| 302|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 604| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 302, False: 0] | | | | | Branch (41:11): [True: 302, False: 0] | | | | ------------------ | | | | 42| 302| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 558| | 559| 302| key->magic = 0; 560| 302| if (key->key != NULL) { ------------------ | Branch (560:6): [True: 0, False: 302] ------------------ 561| 0| dst_key_free(&key->key); 562| 0| } 563| 302| if (key->creator != NULL) { ------------------ | Branch (563:6): [True: 0, False: 302] ------------------ 564| 0| dns_name_free(key->creator, key->mctx); 565| 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] | | ------------------ ------------------ 566| 0| } 567| | isc_mem_putanddetach(&key->mctx, key, sizeof(dns_tsigkey_t)); ------------------ | | 187| 302| do { \ | | 188| 302| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 302| (p) = NULL; \ | | 190| 302| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 302] | | ------------------ ------------------ 568| 302|} tsig.c:tkey_match: 143| 255|tkey_match(void *node, const void *key) { 144| 255| dns_tsigkey_t *tkey = node; 145| | 146| 255| return dns_name_equal(tkey->name, (const dns_name_t *)key); ------------------ | | 1541| 255| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 255| _Generic((arg), \ | | | | 1508| 255| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 255| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 255| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 255| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 255| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 255| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 255| _Generic((arg), \ | | | | 1508| 255| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 255| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 255| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 255| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 255| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 255| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 147| 255|} 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) | | ------------------ | | | | 53| 14| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 14, False: 0] | | | | ------------------ | | | | 54| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 91| 2| REQUIRE(expire_min_s <= expire_max_s); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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: 89| 2| dns_view_t **viewp) { 90| 2| dns_view_t *view = NULL; 91| 2| isc_result_t result; 92| 2| char buffer[1024]; 93| | 94| 2| REQUIRE(name != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 95| 2| REQUIRE(viewp != NULL && *viewp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 96| | 97| 2| switch (rdclass) { 98| 2| case dns_rdataclass_in: ------------------ | | 24| 2|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (98:2): [True: 2, False: 0] ------------------ 99| 2| break; 100| 0| case dns_rdataclass_chaos: ------------------ | | 26| 0|#define dns_rdataclass_chaos ((dns_rdataclass_t)dns_rdataclass_chaos) ------------------ | Branch (100:2): [True: 0, False: 2] ------------------ 101| 0| if (strcmp(name, "_bind") == 0) { ------------------ | Branch (101:7): [True: 0, False: 0] ------------------ 102| | /* allowed */ 103| 0| break; 104| 0| } 105| 0| FALLTHROUGH; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 106| 0| default: ------------------ | Branch (106:2): [True: 0, False: 2] ------------------ 107| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 108| 2| } 109| | 110| 2| result = isc_file_sanitize(NULL, name, "nta", buffer, sizeof(buffer)); 111| 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] | | ------------------ ------------------ 112| | 113| 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) ------------------ 114| 2| *view = (dns_view_t){ 115| 2| .rdclass = rdclass, 116| 2| .name = isc_mem_strdup(mctx, name), ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 117| 2| .nta_file = isc_mem_strdup(mctx, buffer), ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 118| 2| .recursion = true, 119| 2| .enablevalidation = true, 120| 2| .minimalresponses = dns_minimal_no, 121| 2| .transfer_format = dns_one_answer, 122| 2| .msgcompression = true, 123| 2| .provideixfr = true, 124| 2| .maxcachettl = 7 * 24 * 3600, 125| 2| .maxncachettl = 3 * 3600, 126| 2| .dstport = 53, 127| 2| .staleanswerttl = 1, 128| 2| .staleanswersok = dns_stale_answer_conf, 129| 2| .sendcookie = true, 130| 2| .synthfromdnssec = true, 131| 2| .trust_anchor_telemetry = true, 132| 2| .root_key_sentinel = true, 133| 2| .udpsize = DEFAULT_EDNS_BUFSIZE, ------------------ | | 79| 2|#define DEFAULT_EDNS_BUFSIZE 1232 ------------------ 134| 2| .max_restarts = DEFAULT_MAX_RESTARTS, ------------------ | | 74| 2|#define DEFAULT_MAX_RESTARTS 11 ------------------ 135| 2| }; 136| | 137| 2| isc_refcount_init(&view->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 138| 2| isc_refcount_init(&view->weakrefs, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 139| | 140| 2| dns_fixedname_init(&view->redirectfixed); 141| | 142| 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] | | ------------------ ------------------ 143| 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] | | ------------------ ------------------ 144| 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] | | ------------------ ------------------ 145| | 146| 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] | | | | ------------------ | | ------------------ ------------------ 147| | 148| 2| isc_mem_attach(mctx, &view->mctx); 149| | 150| 2| if (dispatchmgr != NULL) { ------------------ | Branch (150:6): [True: 0, False: 2] ------------------ 151| 0| dns_dispatchmgr_attach(dispatchmgr, &view->dispatchmgr); 152| 0| } 153| | 154| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 155| | 156| 2| dns_zt_create(mctx, view, &view->zonetable); 157| | 158| 2| dns_fwdtable_create(mctx, view, &view->fwdtable); 159| | 160| 2| dns_tsigkeyring_create(view->mctx, &view->dynamickeys); 161| | 162| 2| view->failcache = dns_badcache_new(view->mctx); 163| | 164| 2| view->unreachcache = dns_unreachcache_new( 165| 2| view->mctx, UNREACH_HOLD_TIME_INITIAL_SEC, ------------------ | | 82| 2|#define UNREACH_HOLD_TIME_INITIAL_SEC ((uint16_t)10) ------------------ 166| 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) ------------------ 167| | 168| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 169| | 170| 2| dns_order_create(view->mctx, &view->order); 171| | 172| 2| dns_peerlist_new(view->mctx, &view->peers); 173| | 174| 2| dns_aclenv_create(view->mctx, &view->aclenv); 175| | 176| 2| dns_nametree_create(view->mctx, DNS_NAMETREE_COUNT, "sfd", &view->sfd); 177| | 178| 2| view->magic = DNS_VIEW_MAGIC; ------------------ | | 253| 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)) | | ------------------ ------------------ 179| 2| *viewp = view; 180| 2|} dns_view_weakattach: 512| 2|dns_view_weakattach(dns_view_t *source, dns_view_t **targetp) { 513| 2| REQUIRE(DNS_VIEW_VALID(source)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 514| 2| REQUIRE(targetp != NULL && *targetp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 515| | 516| 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) | | | | ------------------ | | | | | | 53| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:11): [True: 2, False: 0] | | | | | | | Branch (53:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 85| 2| __v; \ | | 86| 2| }) ------------------ 517| | 518| 2| *targetp = source; 519| 2|} dns_view_setkeyring: 612| 1.09k|dns_view_setkeyring(dns_view_t *view, dns_tsigkeyring_t *ring) { 613| 1.09k| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 1.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.09k, False: 0] | | | | | Branch (41:11): [True: 1.09k, False: 0] | | | | ------------------ | | | | 42| 1.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 614| 1.09k| REQUIRE(ring != NULL); ------------------ | | 198| 1.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.09k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.09k, False: 0] | | | | ------------------ | | | | 42| 1.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 615| 1.09k| if (view->statickeys != NULL) { ------------------ | Branch (615:6): [True: 1.09k, False: 1] ------------------ 616| 1.09k| dns_tsigkeyring_detach(&view->statickeys); 617| 1.09k| } 618| 1.09k| dns_tsigkeyring_attach(ring, &view->statickeys); 619| 1.09k|} dns_view_freeze: 668| 2|dns_view_freeze(dns_view_t *view) { 669| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 670| 2| REQUIRE(!view->frozen); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 671| | 672| 2| if (view->resolver != NULL) { ------------------ | Branch (672:6): [True: 0, False: 2] ------------------ 673| 0| INSIST(view->cachedb != NULL); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 674| 0| dns_resolver_freeze(view->resolver); 675| 0| } 676| | view->frozen = true; 677| 2|} dns_view_addzone: 688| 2|dns_view_addzone(dns_view_t *view, dns_zone_t *zone) { 689| 2| isc_result_t result; 690| 2| dns_zt_t *zonetable = NULL; 691| | 692| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 693| 2| REQUIRE(!view->frozen); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 694| | 695| 2| rcu_read_lock(); 696| 2| zonetable = rcu_dereference(view->zonetable); 697| 2| if (zonetable != NULL) { ------------------ | Branch (697:6): [True: 2, False: 0] ------------------ 698| 2| result = dns_zt_mount(zonetable, zone); 699| 2| } else { 700| 0| result = ISC_R_SHUTTINGDOWN; 701| 0| } 702| 2| rcu_read_unlock(); 703| | 704| 2| return result; 705| 2|} dns_view_find: 752| 389| dns_rdataset_t *sigrdataset) { 753| 389| isc_result_t result; 754| 389| dns_db_t *db = NULL, *zdb = NULL; 755| 389| bool is_cache, is_staticstub_zone; 756| 389| dns_rdataset_t zrdataset, zsigrdataset; 757| 389| dns_zone_t *zone = NULL; 758| 389| dns_zt_t *zonetable = NULL; 759| | 760| | /* 761| | * Find an rdataset whose owner name is 'name', and whose type is 762| | * 'type'. 763| | */ 764| | 765| 389| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 389|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 778| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 389, False: 0] | | | | | Branch (41:11): [True: 389, False: 0] | | | | ------------------ | | | | 42| 389| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 766| 389| REQUIRE(view->frozen); ------------------ | | 198| 389|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 389| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 389, False: 0] | | | | ------------------ | | | | 42| 389| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 767| 389| REQUIRE(type != dns_rdatatype_rrsig); ------------------ | | 198| 389|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 389| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 389, False: 0] | | | | ------------------ | | | | 42| 389| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 768| 389| REQUIRE(rdataset != NULL); /* XXXBEW - remove this */ ------------------ | | 198| 389|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 389| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 389, False: 0] | | | | ------------------ | | | | 42| 389| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 769| | 770| | /* 771| | * Initialize. 772| | */ 773| 389| dns_rdataset_init(&zrdataset); 774| 389| dns_rdataset_init(&zsigrdataset); 775| | 776| | /* 777| | * Find a database to answer the query. 778| | */ 779| 389| is_staticstub_zone = false; 780| 389| rcu_read_lock(); 781| 389| zonetable = rcu_dereference(view->zonetable); 782| 389| if (zonetable != NULL) { ------------------ | Branch (782:6): [True: 389, False: 0] ------------------ 783| 389| result = dns_zt_find(zonetable, name, DNS_ZTFIND_MIRROR, &zone); 784| 389| } else { 785| 0| result = ISC_R_SHUTTINGDOWN; 786| 0| } 787| 389| rcu_read_unlock(); 788| 389| if (zone != NULL && dns_zone_gettype(zone) == dns_zone_staticstub && ------------------ | Branch (788:6): [True: 208, False: 181] | Branch (788:22): [True: 0, False: 208] ------------------ 789| 0| !use_static_stub) ------------------ | Branch (789:6): [True: 0, False: 0] ------------------ 790| 0| { 791| 0| result = ISC_R_NOTFOUND; 792| 0| } 793| 389| if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) { ------------------ | Branch (793:6): [True: 117, False: 272] | Branch (793:33): [True: 91, False: 181] ------------------ 794| 208| result = dns_zone_getdb(zone, &db); 795| 208| if (result != ISC_R_SUCCESS && view->cachedb != NULL) { ------------------ | Branch (795:7): [True: 0, False: 208] | Branch (795:34): [True: 0, False: 0] ------------------ 796| 0| dns_db_attach(view->cachedb, &db); 797| 208| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (797:14): [True: 0, False: 208] ------------------ 798| 0| goto cleanup; 799| 0| } 800| 208| if (dns_zone_gettype(zone) == dns_zone_staticstub && ------------------ | Branch (800:7): [True: 0, False: 208] ------------------ 801| 0| dns_name_equal(name, dns_zone_getorigin(zone))) ------------------ | | 1541| 0| dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__equal(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1541:2): [True: 0, False: 0] | | ------------------ ------------------ 802| 0| { 803| 0| is_staticstub_zone = true; 804| 0| } 805| 208| } else if (result == ISC_R_NOTFOUND && view->cachedb != NULL) { ------------------ | Branch (805:13): [True: 181, False: 0] | Branch (805:41): [True: 0, False: 181] ------------------ 806| 0| dns_db_attach(view->cachedb, &db); 807| 181| } else { 808| 181| goto cleanup; 809| 181| } 810| | 811| 208| is_cache = dns_db_iscache(db); 812| | 813| 208|db_find: 814| | /* 815| | * Now look for an answer in the database. 816| | */ 817| 208| result = dns_db_find(db, name, NULL, type, options, now, foundname, ------------------ | | 820| 208| dns__db_find(db, DNS_NAME__RO_ARG(name), version, type, options, now, \ | | ------------------ | | | | 1507| 208| _Generic((arg), \ | | | | 1508| 208| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 208| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 208| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 208| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 208| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 208| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | 821| 208| foundname, NULL, NULL, rdataset, \ | | 822| 208| sigrdataset DNS__DB_FILELINE) ------------------ 818| 208| rdataset, sigrdataset); 819| | 820| 208| if (result == DNS_R_DELEGATION || result == ISC_R_NOTFOUND) { ------------------ | Branch (820:6): [True: 0, False: 208] | Branch (820:36): [True: 0, False: 208] ------------------ 821| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 302| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 0, False: 0] | | | Branch (302:26): [True: 0, False: 0] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 822| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 302| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 0, False: 0] | | | Branch (302:26): [True: 0, False: 0] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 823| 0| if (!is_cache) { ------------------ | Branch (823:7): [True: 0, False: 0] ------------------ 824| 0| dns_db_detach(&db); 825| 0| if (view->cachedb != NULL && !is_staticstub_zone) { ------------------ | Branch (825:8): [True: 0, False: 0] | Branch (825:33): [True: 0, False: 0] ------------------ 826| | /* 827| | * Either the answer is in the cache, or we 828| | * don't know it. 829| | * Note that if the result comes from a 830| | * static-stub zone we stop the search here 831| | * (see the function description in view.h). 832| | */ 833| 0| is_cache = true; 834| 0| dns_db_attach(view->cachedb, &db); 835| 0| goto db_find; 836| 0| } 837| 0| } else { 838| | /* 839| | * We don't have the data in the cache. If we've got 840| | * glue from the zone, use it. 841| | */ 842| 0| if (dns_rdataset_isassociated(&zrdataset)) { ------------------ | Branch (842:8): [True: 0, False: 0] ------------------ 843| 0| dns_rdataset_clone(&zrdataset, rdataset); ------------------ | | 354| 0| dns__rdataset_clone(source, target DNS__DB_FILELINE) ------------------ 844| 0| if (sigrdataset != NULL && ------------------ | Branch (844:9): [True: 0, False: 0] ------------------ 845| 0| dns_rdataset_isassociated(&zsigrdataset)) ------------------ | Branch (845:9): [True: 0, False: 0] ------------------ 846| 0| { 847| 0| dns_rdataset_clone(&zsigrdataset, ------------------ | | 354| 0| dns__rdataset_clone(source, target DNS__DB_FILELINE) ------------------ 848| 0| sigrdataset); 849| 0| } 850| 0| result = DNS_R_GLUE; 851| 0| if (db != NULL) { ------------------ | Branch (851:9): [True: 0, False: 0] ------------------ 852| 0| dns_db_detach(&db); 853| 0| } 854| 0| dns_db_attach(zdb, &db); 855| 0| goto cleanup; 856| 0| } 857| 0| } 858| | /* 859| | * We don't know the answer. 860| | */ 861| 0| result = ISC_R_NOTFOUND; 862| 208| } else if (result == DNS_R_GLUE) { ------------------ | Branch (862:13): [True: 0, False: 208] ------------------ 863| | /* 864| | * Glue is the answer wanted. 865| | */ 866| 0| result = ISC_R_SUCCESS; 867| 0| } 868| | 869| 389|cleanup: 870| 389| dns_rdataset_cleanup(&zrdataset); ------------------ | | 302| 389| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 389, Folded] | | | Branch (302:26): [True: 0, False: 389] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 871| 389| dns_rdataset_cleanup(&zsigrdataset); ------------------ | | 302| 389| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 389, Folded] | | | Branch (302:26): [True: 0, False: 389] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 872| | 873| 389| if (zdb != NULL) { ------------------ | Branch (873:6): [True: 0, False: 389] ------------------ 874| 0| dns_db_detach(&zdb); 875| 0| } 876| | 877| 389| if (db != NULL) { ------------------ | Branch (877:6): [True: 208, False: 181] ------------------ 878| 208| if (dbp != NULL) { ------------------ | Branch (878:7): [True: 0, False: 208] ------------------ 879| 0| *dbp = db; 880| 208| } else { 881| 208| dns_db_detach(&db); 882| 208| } 883| 208| } 884| | 885| 389| if (zone != NULL) { ------------------ | Branch (885:6): [True: 208, False: 181] ------------------ 886| 208| dns_zone_detach(&zone); 887| 208| } 888| | 889| 389| return result; 890| 208|} dns_view_simplefind: 896| 389| dns_rdataset_t *sigrdataset) { 897| 389| isc_result_t result; 898| 389| dns_fixedname_t foundname; 899| | 900| 389| dns_fixedname_init(&foundname); 901| 389| result = dns_view_find(view, name, type, now, options, false, NULL, 902| 389| dns_name(&foundname), rdataset, sigrdataset); ------------------ | | 1515| 389|#define dns_name(source) DNS_NAME__RO_ARG(source) | | ------------------ | | | | 1507| 389| _Generic((arg), \ | | | | 1508| 389| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 389| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 389| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 389| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 389| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 389| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 903| 389| if (result == DNS_R_NXDOMAIN) { ------------------ | Branch (903:6): [True: 91, False: 298] ------------------ 904| | /* 905| | * The rdataset and sigrdataset of the relevant NSEC record 906| | * may be returned, but the caller cannot use them because 907| | * foundname is not returned by this simplified API. We 908| | * disassociate them here to prevent any misuse by the caller. 909| | */ 910| 91| dns_rdataset_cleanup(rdataset); ------------------ | | 302| 91| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 91, False: 0] | | | Branch (302:26): [True: 0, False: 91] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 911| 91| dns_rdataset_cleanup(sigrdataset); ------------------ | | 302| 91| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 0, False: 91] | | | Branch (302:26): [True: 0, False: 0] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 912| 298| } else if (result != ISC_R_SUCCESS && result != DNS_R_GLUE && ------------------ | Branch (912:13): [True: 181, False: 117] | Branch (912:40): [True: 181, False: 0] ------------------ 913| 181| result != DNS_R_HINT && result != DNS_R_NCACHENXDOMAIN && ------------------ | Branch (913:6): [True: 181, False: 0] | Branch (913:30): [True: 181, False: 0] ------------------ 914| 181| result != DNS_R_NCACHENXRRSET && result != DNS_R_NXRRSET && ------------------ | Branch (914:6): [True: 181, False: 0] | Branch (914:39): [True: 181, False: 0] ------------------ 915| 181| result != DNS_R_HINTNXRRSET && result != ISC_R_NOTFOUND) ------------------ | Branch (915:6): [True: 181, False: 0] | Branch (915:37): [True: 0, False: 181] ------------------ 916| 0| { 917| 0| dns_rdataset_cleanup(rdataset); ------------------ | | 302| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 0, False: 0] | | | Branch (302:26): [True: 0, False: 0] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 918| 0| dns_rdataset_cleanup(sigrdataset); ------------------ | | 302| 0| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 0, False: 0] | | | Branch (302:26): [True: 0, False: 0] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 919| 0| result = ISC_R_NOTFOUND; 920| 0| } 921| | 922| 389| return result; 923| 389|} dns_view_checksig: 1244| 460|dns_view_checksig(dns_view_t *view, isc_buffer_t *source, dns_message_t *msg) { 1245| 460| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 460|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 920| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 460, False: 0] | | | | | Branch (41:11): [True: 460, False: 0] | | | | ------------------ | | | | 42| 460| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1246| 460| REQUIRE(source != NULL); ------------------ | | 198| 460|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 460| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 460, False: 0] | | | | ------------------ | | | | 42| 460| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1247| | 1248| 460| return dns_tsig_verify(source, msg, view->statickeys, 1249| 460| view->dynamickeys); 1250| 460|} dns_view_sfd_add: 1893| 2|dns_view_sfd_add(dns_view_t *view, const dns_name_t *name) { 1894| 2| isc_result_t result; 1895| | 1896| 2| REQUIRE(DNS_VIEW_VALID(view)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1897| | 1898| 2| result = dns_nametree_add(view->sfd, name, 0); 1899| 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] | | ------------------ ------------------ 1900| 2|} dns_zone_create: 468| 2|dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx, isc_tid_t tid) { 469| 2| isc_time_t now; 470| 2| dns_zone_t *zone = NULL; 471| | 472| 2| REQUIRE(zonep != NULL && *zonep == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 473| 2| REQUIRE(mctx != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 474| | 475| 2| now = isc_time_now(); 476| 2| zone = isc_mem_getx(mctx, sizeof(*zone), ------------------ | | 148| 4|#define isc_mem_getx(c, s, f) isc__mem_get((c), (s), (f)_ISC_MEM_FILELINE) | | ------------------ | | | Branch (148:55): [True: 2, Folded] | | ------------------ ------------------ 477| 2| ISC_MEM_ALIGN(ISC_OS_CACHELINE_SIZE)); 478| 2| *zone = (dns_zone_t){ 479| 2| .masterformat = dns_masterformat_none, 480| 2| .journalsize = -1, 481| 2| .rdclass = dns_rdataclass_none, ------------------ | | 32| 2|#define dns_rdataclass_none ((dns_rdataclass_t)dns_rdataclass_none) ------------------ 482| 2| .type = dns_zone_none, 483| 2| .refresh = DNS_ZONE_DEFAULTREFRESH, ------------------ | | 153| 2|#define DNS_ZONE_DEFAULTREFRESH 3600 /*%< 1 hour */ ------------------ 484| 2| .retry = DNS_ZONE_DEFAULTRETRY, ------------------ | | 163| 2| 60 /*%< 1 minute, subject to \ ------------------ 485| 2| .maxrefresh = DNS_ZONE_MAXREFRESH, ------------------ | | 150| 2|#define DNS_ZONE_MAXREFRESH 2419200 /*%< 4 weeks */ ------------------ 486| 2| .minrefresh = DNS_ZONE_MINREFRESH, ------------------ | | 147| 2|#define DNS_ZONE_MINREFRESH 300 /*%< 5 minutes */ ------------------ 487| 2| .maxretry = DNS_ZONE_MAXRETRY, ------------------ | | 159| 2|#define DNS_ZONE_MAXRETRY 1209600 /*%< 2 weeks */ ------------------ 488| 2| .minretry = DNS_ZONE_MINRETRY, ------------------ | | 156| 2|#define DNS_ZONE_MINRETRY 300 /*%< 5 minutes */ ------------------ 489| 2| .checkdstype = dns_checkdstype_yes, 490| 2| .zero_no_soa_ttl = true, 491| 2| .check_names = dns_severity_ignore, 492| 2| .idlein = DNS_DEFAULT_IDLEIN, ------------------ | | 61| 2|#define DNS_DEFAULT_IDLEIN 3600 /*%< 1 hour */ ------------------ 493| 2| .idleout = DNS_DEFAULT_IDLEOUT, ------------------ | | 62| 2|#define DNS_DEFAULT_IDLEOUT 3600 /*%< 1 hour */ ------------------ 494| 2| .maxxfrin = MAX_XFER_TIME, ------------------ | | 63| 2|#define MAX_XFER_TIME (2 * 3600) /*%< Documented default is 2 hours */ ------------------ 495| 2| .maxxfrout = MAX_XFER_TIME, ------------------ | | 63| 2|#define MAX_XFER_TIME (2 * 3600) /*%< Documented default is 2 hours */ ------------------ 496| 2| .sigvalidityinterval = 30 * 24 * 3600, 497| 2| .sigresigninginterval = 7 * 24 * 3600, 498| 2| .statlevel = dns_zonestat_none, 499| 2| .signatures = 10, 500| 2| .nodes = 100, 501| 2| .privatetype = (dns_rdatatype_t)0xffffU, 502| 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 | | ------------------ ------------------ 503| 2| .requestixfr = true, 504| 2| .ixfr_ratio = 100, 505| 2| .requestexpire = true, 506| 2| .updatemethod = dns_updatemethod_increment, 507| 2| .tid = tid, 508| 2| .notifytime = now, 509| 2| .newincludes = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 510| 2| .checkds_requests = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 511| 2| .signing = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 512| 2| .nsec3chain = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 513| 2| .maintenance_queue = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 514| 2| .forwards = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 515| 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| } | | ------------------ ------------------ 516| 2| }; 517| 2| dns_remote_t r = { 518| 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)) | | ------------------ ------------------ 519| 2| }; 520| | 521| 2| isc_mem_attach(mctx, &zone->mctx); 522| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 523| 2| ZONEDB_INITLOCK(&zone->dblock); ------------------ | | 118| 2|#define ZONEDB_INITLOCK(l) isc_rwlock_init(l) ------------------ 524| | 525| 2| isc_refcount_init(&zone->references, 1); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 526| 2| isc_refcount_init(&zone->irefs, 0); ------------------ | | 44| 2|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 527| 2| dns_name_init(&zone->origin); 528| | 529| 2| zone->primaries = r; 530| 2| zone->parentals = r; 531| 2| zone->alsonotify = r; 532| 2| zone->cds_endpoints = r; 533| 2| zone->defaultkasp = NULL; 534| 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] | | ------------------ ------------------ 535| | 536| 2| dns_notifyctx_init(&zone->notifysoa, dns_rdatatype_soa); ------------------ | | 121| 2|#define dns_rdatatype_soa ((dns_rdatatype_t)dns_rdatatype_soa) ------------------ 537| 2| dns_notifyctx_init(&zone->notifycds, dns_rdatatype_cds); ------------------ | | 173| 2|#define dns_rdatatype_cds ((dns_rdatatype_t)dns_rdatatype_cds) ------------------ 538| | 539| 2| isc_stats_create(mctx, &zone->gluecachestats, 540| 2| dns_gluecachestatscounter_max); 541| | 542| 2| zone->magic = ZONE_MAGIC; ------------------ | | 40| 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)) | | ------------------ ------------------ 543| | 544| | /* Must be after magic is set. */ 545| 2| dns_zone_setdbtype(zone, dbargc_default, dbargv_default); 546| | 547| 2| *zonep = zone; 548| 2|} dns__zone_inline_secure: 729| 10|dns__zone_inline_secure(dns_zone_t *zone) { 730| 10| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 10, False: 0] | | | | | Branch (41:11): [True: 10, False: 0] | | | | ------------------ | | | | 42| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 731| 10| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 10, False: 0] | | | | ------------------ | | | | 42| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 732| 10| if (zone->raw != NULL) { ------------------ | Branch (732:6): [True: 0, False: 10] ------------------ 733| 0| return true; 734| 0| } 735| 10| return false; 736| 10|} dns__zone_inline_raw: 743| 6|dns__zone_inline_raw(dns_zone_t *zone) { 744| 6| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 745| 6| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 746| 6| if (zone->secure != NULL) { ------------------ | Branch (746:6): [True: 0, False: 6] ------------------ 747| 0| return true; 748| 0| } 749| 6| return false; 750| 6|} dns__zone_freedbargs: 829| 2|dns__zone_freedbargs(dns_zone_t *zone) { 830| 2| unsigned int i; 831| | 832| | /* Free the old database argument list. */ 833| 2| if (zone->db_argv != NULL) { ------------------ | Branch (833:6): [True: 0, False: 2] ------------------ 834| 0| for (i = 0; i < zone->db_argc; i++) { ------------------ | Branch (834:15): [True: 0, False: 0] ------------------ 835| 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] | | ------------------ ------------------ 836| 0| } 837| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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] | | ------------------ ------------------ 838| 0| sizeof(*zone->db_argv)); 839| 0| } 840| 2| zone->db_argc = 0; 841| | zone->db_argv = NULL; 842| 2|} dns__zone_setview_helper: 845| 2|dns__zone_setview_helper(dns_zone_t *zone, dns_view_t *view) { 846| 2| dns__viewname_set(&zone->viewname, zone->mctx, view->name); 847| 2| if (zone->prev_view == NULL && zone->view != NULL) { ------------------ | Branch (847:6): [True: 2, False: 0] | Branch (847:33): [True: 0, False: 2] ------------------ 848| 0| dns_view_weakattach(zone->view, &zone->prev_view); 849| 0| } 850| | 851| 2| INSIST(zone != zone->raw); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 852| 2| if (zone->view != NULL) { ------------------ | Branch (852:6): [True: 0, False: 2] ------------------ 853| 0| dns_view_sfd_del(zone->view, &zone->origin); 854| 0| dns_view_weakdetach(&zone->view); 855| 0| } 856| 2| dns_view_weakattach(view, &zone->view); 857| 2| dns_view_sfd_add(view, &zone->origin); 858| | 859| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (859:6): [True: 0, False: 2] ------------------ 860| 0| dns_zone_setview(zone->raw, view); 861| 0| } 862| 2|} dns_zone_isdynamic: 907| 6|dns_zone_isdynamic(dns_zone_t *zone, bool ignore_freeze) { 908| 6| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 909| | 910| 6| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (910:6): [True: 0, False: 6] | Branch (910:42): [True: 0, False: 6] ------------------ 911| 6| zone->type == dns_zone_stub || zone->type == dns_zone_key || ------------------ | Branch (911:6): [True: 0, False: 6] | Branch (911:37): [True: 0, False: 6] ------------------ 912| 6| (zone->type == dns_zone_redirect && ------------------ | Branch (912:7): [True: 0, False: 6] ------------------ 913| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (913:7): [True: 0, False: 0] ------------------ 914| 0| { 915| 0| return true; 916| 0| } 917| | 918| | /* Inline zones are always dynamic. */ 919| 6| if (zone->type == dns_zone_primary && zone->raw != NULL) { ------------------ | Branch (919:6): [True: 6, False: 0] | Branch (919:40): [True: 0, False: 6] ------------------ 920| 0| return true; 921| 0| } 922| | 923| | /* If !ignore_freeze, we need check whether updates are disabled. */ 924| 6| if (zone->type == dns_zone_primary && ------------------ | Branch (924:6): [True: 6, False: 0] ------------------ 925| 6| (!zone->update_disabled || ignore_freeze) && ------------------ | Branch (925:7): [True: 6, False: 0] | Branch (925:33): [True: 0, False: 0] ------------------ 926| 6| ((zone->ssutable != NULL) || ------------------ | Branch (926:7): [True: 0, False: 6] ------------------ 927| 6| (zone->update_acl != NULL && !dns_acl_isnone(zone->update_acl)))) ------------------ | Branch (927:8): [True: 0, False: 6] | Branch (927:36): [True: 0, False: 0] ------------------ 928| 0| { 929| 0| return true; 930| 0| } 931| | 932| 6| return false; 933| 6|} dns_zone_rpz_enable_db: 967| 2|dns_zone_rpz_enable_db(dns_zone_t *zone, dns_db_t *db) { 968| 2| if (zone->rpz_num == DNS_RPZ_INVALID_NUM) { ------------------ | | 91| 2|#define DNS_RPZ_INVALID_NUM DNS_RPZ_MAX_ZONES | | ------------------ | | | | 82| 2|#define DNS_RPZ_MAX_ZONES 64 | | ------------------ ------------------ | Branch (968:6): [True: 2, False: 0] ------------------ 969| 2| return; 970| 2| } 971| 0| REQUIRE(zone->rpzs != NULL); ------------------ | | 198| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 0, False: 0] | | | | ------------------ | | | | 42| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 972| 0| dns_rpz_dbupdate_register(db, zone->rpzs->zones[zone->rpz_num]); 973| 0|} dns_zone_catz_enable_db: 988| 2|dns_zone_catz_enable_db(dns_zone_t *zone, dns_db_t *db) { 989| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 990| 2| REQUIRE(db != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 991| | 992| 2| if (zone->catzs != NULL) { ------------------ | Branch (992:6): [True: 0, False: 2] ------------------ 993| 0| dns_catz_dbupdate_register(db, zone->catzs); 994| 0| } 995| 2|} dns_zone_load: 1456| 2|dns_zone_load(dns_zone_t *zone, bool newonly) { 1457| 2| return zone_load(zone, newonly ? DNS_ZONELOADFLAG_NOSTAT : 0, false); ------------------ | Branch (1457:25): [True: 0, False: 2] ------------------ 1458| 2|} dns_zone_logv: 13614| 14| const char *prefix, const char *fmt, va_list ap) { 13615| 14| char message[4096]; 13616| 14| char namebuf[1024]; 13617| 14| const char *zstr; 13618| | 13619| 14| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 13620| | 13621| 14| if (!isc_log_wouldlog(level)) { ------------------ | Branch (13621:6): [True: 12, False: 2] ------------------ 13622| 12| return; 13623| 12| } 13624| | 13625| 2| zone_namerd_tostr(zone, namebuf, sizeof(namebuf)); 13626| 2| vsnprintf(message, sizeof(message), fmt, ap); 13627| | 13628| 2| switch (zone->type) { 13629| 0| case dns_zone_key: ------------------ | Branch (13629:2): [True: 0, False: 2] ------------------ 13630| 0| zstr = "managed-keys-zone"; 13631| 0| break; 13632| 0| case dns_zone_redirect: ------------------ | Branch (13632:2): [True: 0, False: 2] ------------------ 13633| 0| zstr = "redirect-zone"; 13634| 0| break; 13635| 2| default: ------------------ | Branch (13635:2): [True: 2, False: 0] ------------------ 13636| 2| zstr = "zone "; 13637| 2| } 13638| | 13639| 2| isc_log_write(category, DNS_LOGMODULE_ZONE, level, "%s%s%s%s: %s", 13640| 2| prefix != NULL ? prefix : "", prefix != NULL ? ": " : "", ------------------ | Branch (13640:9): [True: 0, False: 2] | Branch (13640:39): [True: 0, False: 2] ------------------ 13641| 2| zstr, namebuf, message); 13642| 2|} dns_zone_logc: 13646| 10| const char *fmt, ...) { 13647| 10| va_list ap; 13648| | 13649| 10| va_start(ap, fmt); 13650| 10| dns_zone_logv(zone, category, level, NULL, fmt, ap); 13651| | va_end(ap); 13652| 10|} dns_zonetype_name: 13710| 2|dns_zonetype_name(dns_zonetype_t type) { 13711| 2| switch (type) { 13712| 0| case dns_zone_none: ------------------ | Branch (13712:2): [True: 0, False: 2] ------------------ 13713| 0| return "none"; 13714| 2| case dns_zone_primary: ------------------ | Branch (13714:2): [True: 2, False: 0] ------------------ 13715| 2| return "primary"; 13716| 0| case dns_zone_secondary: ------------------ | Branch (13716:2): [True: 0, False: 2] ------------------ 13717| 0| return "secondary"; 13718| 0| case dns_zone_mirror: ------------------ | Branch (13718:2): [True: 0, False: 2] ------------------ 13719| 0| return "mirror"; 13720| 0| case dns_zone_stub: ------------------ | Branch (13720:2): [True: 0, False: 2] ------------------ 13721| 0| return "stub"; 13722| 0| case dns_zone_staticstub: ------------------ | Branch (13722:2): [True: 0, False: 2] ------------------ 13723| 0| return "static-stub"; 13724| 0| case dns_zone_key: ------------------ | Branch (13724:2): [True: 0, False: 2] ------------------ 13725| 0| return "key"; 13726| 0| case dns_zone_dlz: ------------------ | Branch (13726:2): [True: 0, False: 2] ------------------ 13727| 0| return "dlz"; 13728| 0| case dns_zone_redirect: ------------------ | Branch (13728:2): [True: 0, False: 2] ------------------ 13729| 0| return "redirect"; 13730| 0| default: ------------------ | Branch (13730:2): [True: 0, False: 2] ------------------ 13731| 0| return "unknown"; 13732| 2| } 13733| 2|} dns__zone_keymgmt_initialize: 16173| 2|dns__zone_keymgmt_initialize(void) { 16174| 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 (16174:23): [True: 2.04k, False: 2] ------------------ 16175| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2.04k| } | | ------------------ ------------------ 16176| 2.04k| } 16177| 2|} dns_zone_cdscheck: 19481| 2|dns_zone_cdscheck(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *version) { 19482| 2| isc_result_t result; 19483| 2| dns_dbnode_t *node = NULL; 19484| 2| dns_rdataset_t dnskey, cds, cdnskey; 19485| 2| unsigned char algorithms[DST_MAX_ALGS]; 19486| 2| unsigned int i; 19487| 2| bool empty = false; 19488| | 19489| 2| enum { notexpected = 0, expected = 1, found = 2 }; 19490| | 19491| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 19492| | 19493| 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| } ------------------ 19494| | 19495| 2| dns_rdataset_init(&cds); 19496| 2| dns_rdataset_init(&dnskey); 19497| 2| dns_rdataset_init(&cdnskey); 19498| | 19499| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_cds, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 19500| 2| dns_rdatatype_none, 0, &cds, NULL); 19501| 2| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (19501:6): [True: 0, False: 2] ------------------ 19502| 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| } ------------------ 19503| 0| } 19504| | 19505| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_cdnskey, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 19506| 2| dns_rdatatype_none, 0, &cdnskey, NULL); 19507| 2| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (19507:6): [True: 0, False: 2] ------------------ 19508| 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| } ------------------ 19509| 0| } 19510| | 19511| 2| if (!dns_rdataset_isassociated(&cds) && ------------------ | Branch (19511:6): [True: 2, False: 0] ------------------ 19512| 2| !dns_rdataset_isassociated(&cdnskey)) ------------------ | Branch (19512:6): [True: 2, False: 0] ------------------ 19513| 2| { 19514| 2| result = ISC_R_SUCCESS; 19515| 2| goto cleanup; 19516| 2| } 19517| | 19518| 0| result = dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, ------------------ | | 1125| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 0| sigrdataset DNS__DB_FILELINE) ------------------ 19519| 0| dns_rdatatype_none, 0, &dnskey, NULL); 19520| 0| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (19520:6): [True: 0, False: 0] ------------------ 19521| 0| empty = true; 19522| 0| } else { 19523| 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| } ------------------ 19524| 0| } 19525| | 19526| | /* 19527| | * For each DNSSEC algorithm in the CDS RRset there must be 19528| | * a matching DNSKEY record with the exception of a CDS deletion 19529| | * record which must be by itself. 19530| | */ 19531| 0| if (dns_rdataset_isassociated(&cds)) { ------------------ | Branch (19531:6): [True: 0, False: 0] ------------------ 19532| 0| bool logged_digest_type[DNS_DSDIGEST_MAX + 1] = { 0 }; 19533| 0| bool delete = false; 19534| 0| memset(algorithms, notexpected, sizeof(algorithms)); 19535| 0| DNS_RDATASET_FOREACH(&cds) { ------------------ | | 267| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19536| 0| dns_rdata_t crdata = DNS_RDATA_INIT; ------------------ | | 149| 0| { \ | | 150| 0| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 0| } ------------------ 19537| 0| dns_rdata_cds_t structcds; 19538| | 19539| 0| dns_rdataset_current(&cds, &crdata); 19540| | /* 19541| | * CDS deletion record has this form "0 0 0 00" which 19542| | * is 5 zero octets. 19543| | */ 19544| 0| if (crdata.length == 5U && ------------------ | Branch (19544:8): [True: 0, False: 0] ------------------ 19545| 0| memcmp(crdata.data, ------------------ | Branch (19545:8): [True: 0, False: 0] ------------------ 19546| 0| (unsigned char[5]){ 0, 0, 0, 0, 0 }, 5) == 0) 19547| 0| { 19548| 0| delete = true; 19549| 0| continue; 19550| 0| } 19551| | 19552| 0| if (empty) { ------------------ | Branch (19552:8): [True: 0, False: 0] ------------------ 19553| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19554| 0| } 19555| | 19556| 0| CHECK(dns_rdata_tostruct(&crdata, &structcds)); ------------------ | | 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| } ------------------ 19557| | 19558| | /* 19559| | * Log deprecated CDS digest types. 19560| | */ 19561| 0| switch (structcds.digest_type) { ------------------ | Branch (19561:12): [True: 0, False: 0] ------------------ 19562| 0| case DNS_DSDIGEST_SHA1: ------------------ | | 19| 0|#define DNS_DSDIGEST_SHA1 (1) ------------------ | Branch (19562:4): [True: 0, False: 0] ------------------ 19563| 0| case DNS_DSDIGEST_GOST: ------------------ | | 21| 0|#define DNS_DSDIGEST_GOST (3) ------------------ | Branch (19563:4): [True: 0, False: 0] ------------------ 19564| 0| if (!logged_digest_type[structcds.digest_type]) ------------------ | Branch (19564:9): [True: 0, False: 0] ------------------ 19565| 0| { 19566| 0| char algbuf[DNS_DSDIGEST_FORMATSIZE]; 19567| 0| dns_dsdigest_format( 19568| 0| structcds.digest_type, algbuf, 19569| 0| sizeof(algbuf)); 19570| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 19571| 0| "deprecated CDS digest type " 19572| 0| "%u (%s)", 19573| 0| structcds.digest_type, 19574| 0| algbuf); 19575| 0| logged_digest_type[structcds.digest_type] = 19576| 0| true; 19577| 0| } 19578| 0| break; 19579| 0| } 19580| | 19581| 0| if (structcds.algorithm != DNS_KEYALG_PRIVATEDNS && ------------------ | Branch (19581:8): [True: 0, False: 0] ------------------ 19582| 0| structcds.algorithm != DNS_KEYALG_PRIVATEOID) ------------------ | Branch (19582:8): [True: 0, False: 0] ------------------ 19583| 0| { 19584| 0| if (algorithms[structcds.algorithm] == 0) { ------------------ | Branch (19584:9): [True: 0, False: 0] ------------------ 19585| 0| algorithms[structcds.algorithm] = 19586| 0| expected; 19587| 0| } 19588| 0| DNS_RDATASET_FOREACH(&dnskey) { ------------------ | | 267| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19589| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 0| { \ | | 150| 0| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 0| } ------------------ 19590| 0| dns_rdata_dnskey_t structdnskey; 19591| | 19592| 0| dns_rdataset_current(&dnskey, &rdata); 19593| 0| dns_rdata_tostruct(&rdata, 19594| 0| &structdnskey); 19595| | 19596| 0| if (structdnskey.algorithm == ------------------ | Branch (19596:10): [True: 0, False: 0] ------------------ 19597| 0| structcds.algorithm) 19598| 0| { 19599| 0| algorithms[structcds.algorithm] = 19600| 0| found; 19601| 0| } 19602| 0| } 19603| 0| } else { 19604| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 0| { \ | | 150| 0| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 0| } ------------------ 19605| 0| dns_rdata_dnskey_t structdnskey; 19606| 0| dst_algorithm_t dnskeyalg; 19607| | 19608| | /* Convert CDS to DS */ 19609| 0| crdata.type = dns_rdatatype_ds; ------------------ | | 158| 0|#define dns_rdatatype_ds ((dns_rdatatype_t)dns_rdatatype_ds) ------------------ 19610| 0| result = dns_dnssec_matchdskey(&zone->origin, 19611| 0| &crdata, &dnskey, 19612| 0| &rdata); 19613| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (19613:9): [True: 0, False: 0] ------------------ 19614| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19615| 0| } 19616| 0| CHECK(dns_rdata_tostruct(&rdata, ------------------ | | 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| } ------------------ 19617| 0| &structdnskey)); 19618| 0| dnskeyalg = dst_algorithm_fromdata( 19619| 0| structdnskey.algorithm, 19620| 0| structdnskey.data, 19621| 0| structdnskey.datalen); 19622| 0| algorithms[dnskeyalg] = found; 19623| 0| } 19624| 0| } 19625| 0| for (i = 0; i < sizeof(algorithms); i++) { ------------------ | Branch (19625:15): [True: 0, False: 0] ------------------ 19626| 0| if (delete) { ------------------ | Branch (19626:8): [True: 0, False: 0] ------------------ 19627| 0| if (algorithms[i] != notexpected) { ------------------ | Branch (19627:9): [True: 0, False: 0] ------------------ 19628| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19629| 0| } 19630| 0| } else if (algorithms[i] == expected) { ------------------ | Branch (19630:15): [True: 0, False: 0] ------------------ 19631| 0| CLEANUP(DNS_R_BADCDS); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19632| 0| } 19633| 0| } 19634| 0| } 19635| | 19636| | /* 19637| | * For each DNSSEC algorithm in the CDNSKEY RRset there must be 19638| | * a matching DNSKEY record with the exception of a CDNSKEY deletion 19639| | * record which must be by itself. 19640| | */ 19641| 0| if (dns_rdataset_isassociated(&cdnskey)) { ------------------ | Branch (19641:6): [True: 0, False: 0] ------------------ 19642| 0| bool delete = false; 19643| 0| memset(algorithms, notexpected, sizeof(algorithms)); 19644| 0| DNS_RDATASET_FOREACH(&cdnskey) { ------------------ | | 267| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19645| 0| dns_rdata_t crdata = DNS_RDATA_INIT; ------------------ | | 149| 0| { \ | | 150| 0| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 0| } ------------------ 19646| 0| dns_rdata_cdnskey_t structcdnskey; 19647| 0| dst_algorithm_t cdnskeyalg; 19648| | 19649| 0| dns_rdataset_current(&cdnskey, &crdata); 19650| | /* 19651| | * CDNSKEY deletion record has this form 19652| | * "0 3 0 AA==" which is 2 zero octets, a 3, 19653| | * and 2 zero octets. 19654| | */ 19655| 0| if (crdata.length == 5U && ------------------ | Branch (19655:8): [True: 0, False: 0] ------------------ 19656| 0| memcmp(crdata.data, ------------------ | Branch (19656:8): [True: 0, False: 0] ------------------ 19657| 0| (unsigned char[5]){ 0, 0, 3, 0, 0 }, 5) == 0) 19658| 0| { 19659| 0| delete = true; 19660| 0| continue; 19661| 0| } 19662| | 19663| 0| if (empty) { ------------------ | Branch (19663:8): [True: 0, False: 0] ------------------ 19664| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19665| 0| } 19666| | 19667| 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| } ------------------ 19668| 0| cdnskeyalg = dst_algorithm_fromdata( 19669| 0| structcdnskey.algorithm, structcdnskey.data, 19670| 0| structcdnskey.datalen); 19671| 0| if (algorithms[cdnskeyalg] == 0) { ------------------ | Branch (19671:8): [True: 0, False: 0] ------------------ 19672| 0| algorithms[cdnskeyalg] = expected; 19673| 0| } 19674| 0| DNS_RDATASET_FOREACH(&dnskey) { ------------------ | | 267| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 19675| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 0| { \ | | 150| 0| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 0| } ------------------ 19676| 0| dns_rdata_dnskey_t structdnskey; 19677| 0| dst_algorithm_t dnskeyalg; 19678| | 19679| 0| dns_rdataset_current(&dnskey, &rdata); 19680| 0| CHECK(dns_rdata_tostruct(&rdata, ------------------ | | 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| } ------------------ 19681| 0| &structdnskey)); 19682| 0| dnskeyalg = dst_algorithm_fromdata( 19683| 0| structdnskey.algorithm, 19684| 0| structdnskey.data, 19685| 0| structdnskey.datalen); 19686| | 19687| 0| if (dnskeyalg == cdnskeyalg) { ------------------ | Branch (19687:9): [True: 0, False: 0] ------------------ 19688| 0| algorithms[cdnskeyalg] = found; 19689| 0| } 19690| 0| } 19691| 0| } 19692| 0| for (i = 0; i < sizeof(algorithms); i++) { ------------------ | Branch (19692:15): [True: 0, False: 0] ------------------ 19693| 0| if (delete) { ------------------ | Branch (19693:8): [True: 0, False: 0] ------------------ 19694| 0| if (algorithms[i] != notexpected) { ------------------ | Branch (19694:9): [True: 0, False: 0] ------------------ 19695| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19696| 0| } 19697| 0| } else if (algorithms[i] == expected) { ------------------ | Branch (19697:15): [True: 0, False: 0] ------------------ 19698| 0| CLEANUP(DNS_R_BADCDNSKEY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 19699| 0| } 19700| 0| } 19701| 0| } 19702| 0| result = ISC_R_SUCCESS; 19703| | 19704| 2|cleanup: 19705| 2| dns_rdataset_cleanup(&cds); ------------------ | | 302| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 2, Folded] | | | Branch (302:26): [True: 0, False: 2] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 19706| 2| dns_rdataset_cleanup(&dnskey); ------------------ | | 302| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 2, Folded] | | | Branch (302:26): [True: 0, False: 2] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 19707| 2| dns_rdataset_cleanup(&cdnskey); ------------------ | | 302| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 2, Folded] | | | Branch (302:26): [True: 0, False: 2] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 19708| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 19709| 2| return result; 19710| 0|} dns_zone_makedb: 20862| 2|dns_zone_makedb(dns_zone_t *zone, dns_db_t **dbp) { 20863| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 20864| 2| REQUIRE(dbp != NULL && *dbp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 20865| | 20866| 2| dns_db_t *db = NULL; 20867| | 20868| 2| isc_result_t result = dns_db_create( 20869| 2| zone->mctx, zone->db_argv[0], &zone->origin, 20870| 2| (zone->type == dns_zone_stub) ? dns_dbtype_stub ------------------ | Branch (20870:3): [True: 0, False: 2] ------------------ 20871| 2| : dns_dbtype_zone, 20872| 2| zone->rdclass, zone->db_argc - 1, zone->db_argv + 1, &db); 20873| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20873:6): [True: 0, False: 2] ------------------ 20874| 0| return result; 20875| 0| } 20876| | 20877| 2| switch (zone->type) { 20878| 2| case dns_zone_primary: ------------------ | Branch (20878:2): [True: 2, False: 0] ------------------ 20879| 2| case dns_zone_secondary: ------------------ | Branch (20879:2): [True: 0, False: 2] ------------------ 20880| 2| case dns_zone_mirror: ------------------ | Branch (20880:2): [True: 0, False: 2] ------------------ 20881| 2| result = dns_db_setgluecachestats(db, zone->gluecachestats); 20882| 2| if (result == ISC_R_NOTIMPLEMENTED) { ------------------ | Branch (20882:7): [True: 0, False: 2] ------------------ 20883| 0| result = ISC_R_SUCCESS; 20884| 0| } 20885| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (20885:7): [True: 0, False: 2] ------------------ 20886| 0| dns_db_detach(&db); 20887| 0| return result; 20888| 0| } 20889| 2| break; 20890| 2| default: ------------------ | Branch (20890:2): [True: 0, False: 2] ------------------ 20891| 0| break; 20892| 2| } 20893| | 20894| 2| dns_db_setmaxrrperset(db, zone->maxrrperset); 20895| 2| dns_db_setmaxtypepername(db, zone->maxtypepername); 20896| | 20897| 2| *dbp = db; 20898| | 20899| 2| return ISC_R_SUCCESS; 20900| 2|} zone.c:zone_load: 1150| 2|zone_load(dns_zone_t *zone, unsigned int flags, bool locked) { 1151| 2| isc_result_t result; 1152| 2| isc_time_t now; 1153| 2| isc_time_t loadtime; 1154| 2| dns_db_t *db = NULL; 1155| 2| bool rbt, hasraw, is_dynamic; 1156| | 1157| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1158| | 1159| 2| if (!locked) { ------------------ | Branch (1159:6): [True: 2, False: 0] ------------------ 1160| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 1161| 2| } 1162| | 1163| 2| INSIST(zone != zone->raw); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1164| 2| hasraw = dns__zone_inline_secure(zone); 1165| 2| if (hasraw) { ------------------ | Branch (1165:6): [True: 0, False: 2] ------------------ 1166| | /* 1167| | * We are trying to load an inline-signed zone. First call 1168| | * self recursively to try loading the raw version of the zone. 1169| | * Assuming the raw zone file is readable, there are two 1170| | * possibilities: 1171| | * 1172| | * a) the raw zone was not yet loaded and thus it will be 1173| | * loaded now, synchronously; if this succeeds, a 1174| | * subsequent attempt to load the signed zone file will 1175| | * take place and thus zone_postload() will be called 1176| | * twice: first for the raw zone and then for the secure 1177| | * zone; the latter call will be followed by scheduling 1178| | * secure maintenance to sync against the raw version, 1179| | * 1180| | * b) the raw zone was already loaded and we are trying to 1181| | * reload it, which will happen asynchronously; this means 1182| | * zone_postload() will only be called for the raw zone 1183| | * because "result" returned by the zone_load() call below 1184| | * will not be ISC_R_SUCCESS but rather DNS_R_CONTINUE; 1185| | * zone_postload() called for the raw zone will schedule 1186| | * secure maintenance to sync against the raw version. 1187| | */ 1188| 0| result = zone_load(zone->raw, flags, false); 1189| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1189:7): [True: 0, False: 0] ------------------ 1190| 0| if (!locked) { ------------------ | Branch (1190:8): [True: 0, False: 0] ------------------ 1191| 0| UNLOCK_ZONE(zone); ------------------ | | 94| 0| do { \ | | 95| 0| INSIST((z)->locked); \ | | ------------------ | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 0| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 0| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 0] | | ------------------ ------------------ 1192| 0| } 1193| 0| return result; 1194| 0| } 1195| 0| } 1196| | 1197| 2| now = isc_time_now(); 1198| | 1199| 2| INSIST(zone->type != dns_zone_none); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1200| | 1201| | /* load was already in progress */ 1202| 2| if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADING)) { ------------------ | | 126| 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 (126:32): [True: 0, False: 2] | | ------------------ ------------------ 1203| 0| if ((flags & DNS_ZONELOADFLAG_THAW) != 0) { ------------------ | Branch (1203:7): [True: 0, False: 0] ------------------ 1204| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_THAW); ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1205| 0| } 1206| 0| CLEANUP(ISC_R_LOADING); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1207| 0| } 1208| | 1209| 2| INSIST(zone->db_argc >= 1); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1210| | 1211| 2| rbt = strcmp(zone->db_argv[0], ZONEDB_DEFAULT) == 0; ------------------ | | 178| 2|#define ZONEDB_DEFAULT "qpzone" ------------------ 1212| | 1213| 2| if (zone->db != NULL && zone->masterfile == NULL && rbt) { ------------------ | Branch (1213:6): [True: 0, False: 2] | Branch (1213:26): [True: 0, False: 0] | Branch (1213:54): [True: 0, False: 0] ------------------ 1214| | /* 1215| | * The zone has no master file configured. 1216| | */ 1217| 0| result = ISC_R_SUCCESS; 1218| 0| goto cleanup; 1219| 0| } 1220| | 1221| 2| is_dynamic = dns_zone_isdynamic(zone, false); 1222| 2| if (zone->db != NULL && is_dynamic) { ------------------ | Branch (1222:6): [True: 0, False: 2] | Branch (1222:26): [True: 0, False: 0] ------------------ 1223| | /* 1224| | * This is a secondary, stub, or dynamically updated zone 1225| | * being reloaded. Do nothing - the database we already 1226| | * have is guaranteed to be up-to-date. 1227| | */ 1228| 0| if (zone->type == dns_zone_primary && !hasraw) { ------------------ | Branch (1228:7): [True: 0, False: 0] | Branch (1228:41): [True: 0, False: 0] ------------------ 1229| 0| result = DNS_R_DYNAMIC; 1230| 0| } else { 1231| 0| result = ISC_R_SUCCESS; 1232| 0| } 1233| 0| goto cleanup; 1234| 0| } 1235| | 1236| | /* 1237| | * Store the current time before the zone is loaded, so that if the 1238| | * file changes between the time of the load and the time that 1239| | * zone->loadtime is set, then the file will still be reloaded 1240| | * the next time dns_zone_load is called. 1241| | */ 1242| 2| loadtime = isc_time_now(); 1243| | 1244| | /* 1245| | * Don't do the load if the file that stores the zone is older 1246| | * than the last time the zone was loaded. If the zone has not 1247| | * been loaded yet, zone->loadtime will be the epoch. 1248| | */ 1249| 2| if (zone->masterfile != NULL) { ------------------ | Branch (1249:6): [True: 2, False: 0] ------------------ 1250| 2| isc_time_t filetime; 1251| | 1252| | /* 1253| | * The file is already loaded. If we are just doing a 1254| | * "rndc reconfig", we are done. 1255| | */ 1256| 2| if (!isc_time_isepoch(&zone->loadtime) && ------------------ | Branch (1256:7): [True: 0, False: 2] ------------------ 1257| 0| (flags & DNS_ZONELOADFLAG_NOSTAT) != 0) ------------------ | Branch (1257:7): [True: 0, False: 0] ------------------ 1258| 0| { 1259| 0| result = ISC_R_SUCCESS; 1260| 0| goto cleanup; 1261| 0| } 1262| | 1263| 2| if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) && ------------------ | | 126| 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 (126:32): [True: 0, False: 2] | | ------------------ ------------------ 1264| 0| !zone_touched(zone)) ------------------ | Branch (1264:7): [True: 0, False: 0] ------------------ 1265| 0| { 1266| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1267| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1268| 0| "skipping load: master file " 1269| 0| "older than last load"); 1270| 0| CLEANUP(DNS_R_UPTODATE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1271| 0| } 1272| | 1273| | /* 1274| | * If the file modification time is in the past 1275| | * set loadtime to that value. 1276| | */ 1277| 2| result = isc_file_getmodtime(zone->masterfile, &filetime); 1278| 2| if (result == ISC_R_SUCCESS && ------------------ | Branch (1278:7): [True: 2, False: 0] ------------------ 1279| 2| isc_time_compare(&loadtime, &filetime) > 0) ------------------ | Branch (1279:7): [True: 1, False: 1] ------------------ 1280| 1| { 1281| 1| loadtime = filetime; 1282| 1| } 1283| 2| } 1284| | 1285| | /* 1286| | * Built in zones (with the exception of empty zones) don't need 1287| | * to be reloaded. 1288| | */ 1289| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (1289:6): [True: 2, False: 0] ------------------ 1290| 2| strcmp(zone->db_argv[0], "_builtin") == 0 && ------------------ | Branch (1290:6): [True: 0, False: 2] ------------------ 1291| 0| (zone->db_argc < 2 || strcmp(zone->db_argv[1], "empty") != 0) && ------------------ | Branch (1291:7): [True: 0, False: 0] | Branch (1291:28): [True: 0, False: 0] ------------------ 1292| 0| DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) ------------------ | | 126| 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 (126:32): [True: 0, False: 0] | | ------------------ ------------------ 1293| 0| { 1294| 0| result = ISC_R_SUCCESS; 1295| 0| goto cleanup; 1296| 0| } 1297| | 1298| | /* 1299| | * Zones associated with a DLZ don't need to be loaded either, 1300| | * but we need to associate the database with the zone object. 1301| | */ 1302| 2| if (strcmp(zone->db_argv[0], "dlz") == 0) { ------------------ | Branch (1302:6): [True: 0, False: 2] ------------------ 1303| 0| dns_dlzdb_t *dlzdb = NULL; 1304| 0| dns_dlzfindzone_t findzone; 1305| | 1306| 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] | | ------------------ ------------------ 1307| 0| INSIST(DNS_DLZ_VALID(d)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 0, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1308| 0| if (strcmp(zone->db_argv[1], d->dlzname) == 0) { ------------------ | Branch (1308:8): [True: 0, False: 0] ------------------ 1309| 0| dlzdb = d; 1310| 0| break; 1311| 0| } 1312| 0| } 1313| | 1314| 0| if (dlzdb == NULL) { ------------------ | Branch (1314:7): [True: 0, False: 0] ------------------ 1315| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1316| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1317| 0| "DLZ %s does not exist or is set " 1318| 0| "to 'search yes;'", 1319| 0| zone->db_argv[1]); 1320| 0| CLEANUP(ISC_R_NOTFOUND); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 1321| 0| } 1322| | 1323| 0| ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 120| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 1324| | /* ask SDLZ driver if the zone is supported */ 1325| 0| findzone = dlzdb->implementation->methods->findzone; 1326| 0| result = (*findzone)(dlzdb->implementation->driverarg, 1327| 0| dlzdb->dbdata, dlzdb->mctx, 1328| 0| zone->view->rdclass, &zone->origin, NULL, 1329| 0| NULL, &db); 1330| 0| if (result != ISC_R_NOTFOUND) { ------------------ | Branch (1330:7): [True: 0, False: 0] ------------------ 1331| 0| if (zone->db != NULL) { ------------------ | Branch (1331:8): [True: 0, False: 0] ------------------ 1332| 0| zone_detachdb(zone); 1333| 0| } 1334| 0| zone_attachdb(zone, db); 1335| 0| dns_db_detach(&db); 1336| 0| result = ISC_R_SUCCESS; 1337| 0| } 1338| 0| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 121| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ ------------------ 1339| | 1340| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (1340:7): [True: 0, False: 0] ------------------ 1341| 0| if (dlzdb->configure_callback == NULL) { ------------------ | Branch (1341:8): [True: 0, False: 0] ------------------ 1342| 0| goto cleanup; 1343| 0| } 1344| | 1345| 0| result = (*dlzdb->configure_callback)(zone->view, dlzdb, 1346| 0| zone); 1347| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1347:8): [True: 0, False: 0] ------------------ 1348| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1349| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1350| 0| "DLZ configuration callback: %s", 1351| 0| isc_result_totext(result)); 1352| 0| } 1353| 0| } 1354| 0| goto cleanup; 1355| 0| } 1356| | 1357| 2| if ((zone->type == dns_zone_secondary || ------------------ | Branch (1357:7): [True: 0, False: 2] ------------------ 1358| 2| zone->type == dns_zone_mirror || zone->type == dns_zone_stub || ------------------ | Branch (1358:7): [True: 0, False: 2] | Branch (1358:40): [True: 0, False: 2] ------------------ 1359| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (1359:8): [True: 0, False: 2] ------------------ 1360| 0| dns_remote_addresses(&zone->primaries) != NULL)) && ------------------ | Branch (1360:8): [True: 0, False: 0] ------------------ 1361| 0| rbt) ------------------ | Branch (1361:6): [True: 0, False: 0] ------------------ 1362| 0| { 1363| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIRSTREFRESH); ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1364| | 1365| 0| if (zone->stream == NULL && ------------------ | Branch (1365:7): [True: 0, False: 0] ------------------ 1366| 0| (zone->masterfile == NULL || ------------------ | Branch (1366:8): [True: 0, False: 0] ------------------ 1367| 0| !isc_file_exists(zone->masterfile))) ------------------ | Branch (1367:8): [True: 0, False: 0] ------------------ 1368| 0| { 1369| 0| if (zone->masterfile != NULL) { ------------------ | Branch (1369:8): [True: 0, False: 0] ------------------ 1370| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1371| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 1372| 0| "no master file"); 1373| 0| } 1374| 0| zone->refreshtime = now; 1375| 0| if (zone->loop != NULL) { ------------------ | Branch (1375:8): [True: 0, False: 0] ------------------ 1376| 0| dns__zone_settimer(zone, now); 1377| 0| } 1378| 0| result = ISC_R_SUCCESS; 1379| 0| goto cleanup; 1380| 0| } 1381| 0| } 1382| | 1383| 2| if (zone->type == dns_zone_primary && zone->masterfile != NULL && ------------------ | Branch (1383:6): [True: 2, False: 0] | Branch (1383:40): [True: 2, False: 0] ------------------ 1384| 2| !isc_file_exists(zone->masterfile) && zone->initfile != NULL) ------------------ | Branch (1384:6): [True: 0, False: 2] | Branch (1384:44): [True: 0, False: 0] ------------------ 1385| 0| { 1386| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 1387| 0| "zone file %s not found; copying initial " 1388| 0| "file %s", 1389| 0| zone->masterfile, zone->initfile); 1390| 0| result = copy_initfile(zone); 1391| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1391:7): [True: 0, False: 0] ------------------ 1392| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1393| 0| ISC_LOG_ERROR, "copy from %s failed: %s", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1394| 0| zone->initfile, 1395| 0| isc_result_totext(result)); 1396| 0| } 1397| 0| } 1398| | 1399| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 1400| 2| "starting load"); 1401| | 1402| 2| result = dns_zone_makedb(zone, &db); 1403| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (1403:6): [True: 0, False: 2] ------------------ 1404| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1405| 0| "loading zone: creating database: %s", 1406| 0| isc_result_totext(result)); 1407| 0| goto cleanup; 1408| 0| } 1409| | 1410| 2| if (!dns_db_ispersistent(db)) { ------------------ | Branch (1410:6): [True: 2, False: 0] ------------------ 1411| 2| if (zone->masterfile != NULL || zone->stream != NULL) { ------------------ | Branch (1411:7): [True: 2, False: 0] | Branch (1411:35): [True: 0, False: 0] ------------------ 1412| 2| result = zone_startload(db, zone, loadtime); 1413| 2| } else { 1414| 0| result = DNS_R_NOMASTERFILE; 1415| 0| if (zone->type == dns_zone_primary || ------------------ | Branch (1415:8): [True: 0, False: 0] ------------------ 1416| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (1416:9): [True: 0, False: 0] ------------------ 1417| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (1417:9): [True: 0, False: 0] ------------------ 1418| 0| { 1419| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1420| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 1421| 0| "loading zone: " 1422| 0| "no master file configured"); 1423| 0| goto cleanup; 1424| 0| } 1425| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 1426| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 1427| 0| "loading zone: " 1428| 0| "no master file configured: continuing"); 1429| 0| } 1430| 2| } 1431| | 1432| 2| if (result == DNS_R_CONTINUE) { ------------------ | Branch (1432:6): [True: 0, False: 2] ------------------ 1433| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADING); ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1434| 0| if ((flags & DNS_ZONELOADFLAG_THAW) != 0) { ------------------ | Branch (1434:7): [True: 0, False: 0] ------------------ 1435| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_THAW); ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 1436| 0| } 1437| 0| goto cleanup; 1438| 0| } 1439| | 1440| 2| result = zone_postload(zone, db, loadtime, result); 1441| 2| if (hasraw && result == ISC_R_SUCCESS) { ------------------ | Branch (1441:6): [True: 0, False: 2] | Branch (1441:16): [True: 0, False: 0] ------------------ 1442| 0| zone_schedule_inline_sync(zone, inline_sync_incremental); 1443| 0| } 1444| | 1445| 2|cleanup: 1446| 2| if (!locked) { ------------------ | Branch (1446:6): [True: 2, False: 0] ------------------ 1447| 2| UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 1448| 2| } 1449| 2| if (db != NULL) { ------------------ | Branch (1449:6): [True: 2, False: 0] ------------------ 1450| 2| dns_db_detach(&db); 1451| 2| } 1452| 2| return result; 1453| 2|} zone.c:zone_attachdb: 15438| 2|zone_attachdb(dns_zone_t *zone, dns_db_t *db) { 15439| 2| REQUIRE(zone->db == NULL && db != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 15440| | 15441| 2| dns_db_attach(db, &zone->db); 15442| 2|} zone.c:zone_startload: 1689| 2|zone_startload(dns_db_t *db, dns_zone_t *zone, isc_time_t loadtime) { 1690| 2| isc_result_t result; 1691| 2| isc_result_t tresult; 1692| 2| unsigned int options; 1693| 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) ------------------ 1694| | 1695| 2| ENTER; ------------------ | | 353| 2|#define ENTER zone_debuglog(zone, __func__, 1, "enter") ------------------ 1696| | 1697| 2| *load = (dns_load_t){ 1698| 2| .loadtime = loadtime, 1699| 2| }; 1700| | 1701| 2| dns_zone_rpz_enable_db(zone, db); 1702| 2| dns_zone_catz_enable_db(zone, db); 1703| | 1704| 2| options = get_primary_options(zone); 1705| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_MANYERRORS)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1706| 0| options |= DNS_MASTER_MANYERRORS; ------------------ | | 32| 0| 0x00000002 /*%< Continue processing on errors. \ ------------------ 1707| 0| } 1708| | 1709| 2| zone_iattach(zone, &load->zone); 1710| 2| dns_db_attach(db, &load->db); 1711| | 1712| 2| dns_rdatacallbacks_init(&load->callbacks); 1713| 2| load->callbacks.rawdata = zone_setrawdata; 1714| 2| zone_iattach(zone, &load->callbacks.zone); 1715| | 1716| 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| } ------------------ 1717| | 1718| 2| if (zone->loop != NULL && zone->db != NULL) { ------------------ | Branch (1718:6): [True: 0, False: 2] | Branch (1718:28): [True: 0, False: 0] ------------------ 1719| 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| } ------------------ 1720| 0| zone->masterfile, dns_db_origin(db), dns_db_origin(db), 1721| 0| zone->rdclass, options, 0, &load->callbacks, zone->loop, 1722| 0| zone_loaddone, load, &zone->loadctx, 1723| 0| zone_registerinclude, zone, zone->mctx, 1724| 0| zone->masterformat, zone->maxttl)); 1725| | 1726| 0| return DNS_R_CONTINUE; 1727| 2| } else if (zone->stream != NULL) { ------------------ | Branch (1727:13): [True: 0, False: 2] ------------------ 1728| 0| FILE *stream = UNCONST(zone->stream); ------------------ | | 96| 0|#define UNCONST(ptr) ((void *)(uintptr_t)(ptr)) ------------------ 1729| 0| result = dns_master_loadstream( 1730| 0| stream, &zone->origin, &zone->origin, zone->rdclass, 1731| 0| options, &load->callbacks, zone->mctx); 1732| 2| } else { 1733| 2| result = dns_master_loadfile( 1734| 2| zone->masterfile, &zone->origin, &zone->origin, 1735| 2| zone->rdclass, options, 0, &load->callbacks, 1736| 2| zone_registerinclude, zone, zone->mctx, 1737| 2| zone->masterformat, zone->maxttl); 1738| 2| } 1739| | 1740| 2|cleanup: 1741| 2| if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE) { ------------------ | Branch (1741:6): [True: 0, False: 2] | Branch (1741:33): [True: 0, False: 0] ------------------ 1742| 0| dns_zone_rpz_disable_db(zone, load->db); 1743| 0| dns_zone_catz_disable_db(zone, load->db); 1744| 0| } 1745| | 1746| 2| tresult = dns_db_endload(db, &load->callbacks); 1747| 2| if (result == ISC_R_SUCCESS || result == DNS_R_SEENINCLUDE) { ------------------ | Branch (1747:6): [True: 2, False: 0] | Branch (1747:33): [True: 0, False: 0] ------------------ 1748| 2| result = tresult; 1749| 2| } 1750| | 1751| 2| zone_idetach(&load->callbacks.zone); 1752| 2| dns_db_detach(&load->db); 1753| 2| zone_idetach(&load->zone); 1754| | 1755| | 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] | | ------------------ ------------------ 1756| 2| return result; 1757| 2|} zone.c:zone_debuglog: 13676| 4| ...) { 13677| 4| int level = ISC_LOG_DEBUG(debuglevel); ------------------ | | 36| 4|#define ISC_LOG_DEBUG(level) (level) ------------------ 13678| 4| va_list ap; 13679| | 13680| 4| va_start(ap, fmt); 13681| 4| dns_zone_logv(zone, DNS_LOGCATEGORY_GENERAL, level, me, fmt, ap); 13682| | va_end(ap); 13683| 4|} zone.c:get_primary_options: 1568| 2|get_primary_options(dns_zone_t *zone) { 1569| 2| unsigned int options; 1570| | 1571| 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 ------------------ 1572| 2| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (1572:6): [True: 0, False: 2] | Branch (1572:42): [True: 0, False: 2] ------------------ 1573| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (1573:7): [True: 0, False: 2] ------------------ 1574| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (1574:7): [True: 0, False: 0] ------------------ 1575| 0| { 1576| 0| options |= DNS_MASTER_SECONDARY; ------------------ | | 36| 0|#define DNS_MASTER_SECONDARY 0x00000020 /*%< Secondary master file. */ ------------------ 1577| 0| } 1578| 2| if (zone->type == dns_zone_key) { ------------------ | Branch (1578:6): [True: 0, False: 2] ------------------ 1579| 0| options |= DNS_MASTER_KEY; ------------------ | | 56| 0|#define DNS_MASTER_KEY 0x00004000 /*%< Loading a key zone master file. */ ------------------ 1580| 0| } 1581| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNS)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1582| 0| options |= DNS_MASTER_CHECKNS; ------------------ | | 38| 0| 0x00000040 /*%< \ ------------------ 1583| 0| } 1584| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_FATALNS)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1585| 0| options |= DNS_MASTER_FATALNS; ------------------ | | 43| 0| 0x00000080 /*%< \ ------------------ 1586| 0| } 1587| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMES)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1588| 0| options |= DNS_MASTER_CHECKNAMES; ------------------ | | 47| 0|#define DNS_MASTER_CHECKNAMES 0x00000100 ------------------ 1589| 0| } 1590| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKNAMESFAIL)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1591| 0| options |= DNS_MASTER_CHECKNAMESFAIL; ------------------ | | 48| 0|#define DNS_MASTER_CHECKNAMESFAIL 0x00000200 ------------------ 1592| 0| } 1593| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKMX)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1594| 0| options |= DNS_MASTER_CHECKMX; ------------------ | | 52| 0|#define DNS_MASTER_CHECKMX 0x00000800 ------------------ 1595| 0| } 1596| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKMXFAIL)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1597| 0| options |= DNS_MASTER_CHECKMXFAIL; ------------------ | | 53| 0|#define DNS_MASTER_CHECKMXFAIL 0x00001000 ------------------ 1598| 0| } 1599| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKWILDCARD)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1600| 0| options |= DNS_MASTER_CHECKWILDCARD; ------------------ | | 50| 0| 0x00000400 /* Check for internal wildcards. \ ------------------ 1601| 0| } 1602| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKTTL)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1603| 0| options |= DNS_MASTER_CHECKTTL; ------------------ | | 58| 0|#define DNS_MASTER_CHECKTTL 0x00010000 /*%< Check max-zone-ttl */ ------------------ 1604| 0| } 1605| 2| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKSVCB)) { ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 1606| 0| options |= DNS_MASTER_CHECKSVCB; ------------------ | | 59| 0|#define DNS_MASTER_CHECKSVCB 0x00020000 /*%< Check SVBC records */ ------------------ 1607| 0| } 1608| | 1609| 2| return options; 1610| 2|} zone.c:zone_get_from_db: 4825| 2| uint32_t *minimum, unsigned int *errors) { 4826| 2| isc_result_t result; 4827| 2| isc_result_t answer = ISC_R_SUCCESS; 4828| 2| dns_dbversion_t *version = NULL; 4829| 2| dns_dbnode_t *node; 4830| | 4831| 2| REQUIRE(db != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4832| 2| REQUIRE(zone != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4833| | 4834| 2| dns_db_currentversion(db, &version); 4835| | 4836| 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| } ------------------ 4837| 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| } ------------------ 4838| 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| } ------------------ 4839| 2| CLR_SOA_VALUES(); ------------------ | | 4764| 2| { \ | | 4765| 2| SET_SOA_VALUES(0, 0, 0, 0, 0, 0); \ | | ------------------ | | | | 4754| 2| { \ | | | | 4755| 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| } | | | | ------------------ | | | | 4756| 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| } | | | | ------------------ | | | | 4757| 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| } | | | | ------------------ | | | | 4758| 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| } | | | | ------------------ | | | | 4759| 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| } | | | | ------------------ | | | | 4760| 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| } | | | | ------------------ | | | | 4761| 2| } | | ------------------ | | 4766| 2| } ------------------ 4840| | 4841| 2| node = NULL; 4842| 2| result = dns_db_findnode(db, &zone->origin, false, &node); ------------------ | | 771| 2| dns__db_findnode(db, DNS_NAME__RO_ARG(name), create, NULL, NULL, \ | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | 772| 2| nodep DNS__DB_FILELINE) ------------------ 4843| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4843:6): [True: 0, False: 2] ------------------ 4844| 0| answer = result; 4845| 0| goto closeversion; 4846| 0| } 4847| | 4848| 2| if (nscount != NULL || errors != NULL) { ------------------ | Branch (4848:6): [True: 2, False: 0] | Branch (4848:25): [True: 0, False: 0] ------------------ 4849| 2| result = zone_count_ns_rr(zone, db, node, version, nscount, 4850| 2| errors, true); 4851| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4851:7): [True: 0, False: 2] ------------------ 4852| 0| answer = result; 4853| 0| } 4854| 2| } 4855| | 4856| 2| if (soacount != NULL || soattl != NULL || serial != NULL || ------------------ | Branch (4856:6): [True: 2, False: 0] | Branch (4856:26): [True: 0, False: 0] | Branch (4856:44): [True: 0, False: 0] ------------------ 4857| 0| refresh != NULL || retry != NULL || expire != NULL || ------------------ | Branch (4857:6): [True: 0, False: 0] | Branch (4857:25): [True: 0, False: 0] | Branch (4857:42): [True: 0, False: 0] ------------------ 4858| 0| minimum != NULL) ------------------ | Branch (4858:6): [True: 0, False: 0] ------------------ 4859| 2| { 4860| 2| result = zone_load_soa_rr(db, node, version, soacount, soattl, 4861| 2| serial, refresh, retry, expire, 4862| 2| minimum); 4863| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4863:7): [True: 0, False: 2] ------------------ 4864| 0| answer = result; 4865| 0| } 4866| 2| } 4867| | 4868| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 4869| 2|closeversion: 4870| 2| dns_db_closeversion(db, &version, false); ------------------ | | 734| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 4871| | 4872| 2| return answer; 4873| 2|} zone.c:zone_load_soa_rr: 4772| 2| uint32_t *minimum) { 4773| 2| isc_result_t result; 4774| 2| unsigned int count = 0; 4775| 2| dns_rdataset_t rdataset; 4776| | 4777| 2| dns_rdataset_init(&rdataset); 4778| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_soa, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 4779| 2| dns_rdatatype_none, 0, &rdataset, NULL); 4780| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (4780:6): [True: 0, False: 2] ------------------ 4781| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4782| 0| result = ISC_R_SUCCESS; 4783| 0| goto invalidate_rdataset; 4784| 0| } 4785| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4785:6): [True: 0, False: 2] ------------------ 4786| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4787| 0| goto invalidate_rdataset; 4788| 0| } 4789| | 4790| 2| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 267| 2| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 2| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 4| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 2, False: 2] | | | | ------------------ | | ------------------ ------------------ 4791| 2| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 2| { \ | | 150| 2| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 2| } ------------------ 4792| 2| dns_rdataset_current(&rdataset, &rdata); 4793| | 4794| 2| count++; 4795| 2| if (count == 1) { ------------------ | Branch (4795:7): [True: 2, False: 0] ------------------ 4796| 2| dns_rdata_soa_t soa; 4797| 2| result = dns_rdata_tostruct(&rdata, &soa); 4798| 2| SET_SOA_VALUES(rdataset.ttl, soa.serial, soa.refresh, ------------------ | | 4754| 2| { \ | | 4755| 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| } | | ------------------ | | 4756| 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| } | | ------------------ | | 4757| 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| } | | ------------------ | | 4758| 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| } | | ------------------ | | 4759| 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| } | | ------------------ | | 4760| 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| } | | ------------------ | | 4761| 2| } ------------------ 4799| 2| soa.retry, soa.expire, soa.minimum); 4800| 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] | | ------------------ ------------------ 4801| 2| } 4802| 2| } 4803| 2| dns_rdataset_disassociate(&rdataset); ------------------ | | 306| 2| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4804| | 4805| 2| result = ISC_R_SUCCESS; 4806| | 4807| 2|invalidate_rdataset: 4808| 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| } ------------------ 4809| 2| if (count == 0) { ------------------ | Branch (4809:6): [True: 0, False: 2] ------------------ 4810| 0| CLR_SOA_VALUES(); ------------------ | | 4764| 0| { \ | | 4765| 0| SET_SOA_VALUES(0, 0, 0, 0, 0, 0); \ | | ------------------ | | | | 4754| 0| { \ | | | | 4755| 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| } | | | | ------------------ | | | | 4756| 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| } | | | | ------------------ | | | | 4757| 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| } | | | | ------------------ | | | | 4758| 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| } | | | | ------------------ | | | | 4759| 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| } | | | | ------------------ | | | | 4760| 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| } | | | | ------------------ | | | | 4761| 0| } | | ------------------ | | 4766| 0| } ------------------ 4811| 0| } 4812| | 4813| 2| dns_rdataset_invalidate(&rdataset); 4814| | 4815| 2| return result; 4816| 2|} zone.c:zone_iattach: 4906| 4|zone_iattach(dns_zone_t *source, dns_zone_t **target) { 4907| 4| REQUIRE(DNS_ZONE_VALID(source)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4908| 4| REQUIRE(LOCKED_ZONE(source)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4909| 4| REQUIRE(target != NULL && *target == NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4910| 4| INSIST(isc_refcount_increment0(&source->irefs) + ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | | Branch (53:11): [True: 4, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4911| 4| isc_refcount_current(&source->references) > 4912| 4| 0); 4913| 4| *target = source; 4914| 4|} zone.c:zone_idetach: 4931| 4|zone_idetach(dns_zone_t **zonep) { 4932| 4| dns_zone_t *zone; 4933| | 4934| | /* 4935| | * 'zone' locked by caller. 4936| | */ 4937| 4| REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4938| 4| REQUIRE(LOCKED_ZONE(*zonep)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 4939| | 4940| 4| zone = *zonep; 4941| 4| *zonep = NULL; 4942| | 4943| 4| INSIST(isc_refcount_decrement(&zone->irefs) - 1 + ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | | Branch (53:11): [True: 4, False: 0] | | | | | Branch (53:11): [True: 0, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4944| 4| isc_refcount_current(&zone->references) > 4945| 4| 0); 4946| 4|} zone.c:check_nsec3param: 3190| 2|check_nsec3param(dns_zone_t *zone, dns_db_t *db) { 3191| 2| bool ok = false; 3192| 2| dns_dbnode_t *node = NULL; 3193| 2| dns_dbversion_t *version = NULL; 3194| 2| dns_rdata_nsec3param_t nsec3param; 3195| 2| dns_rdataset_t rdataset; 3196| 2| isc_result_t result; 3197| 2| bool dynamic = (zone->type == dns_zone_primary) ------------------ | Branch (3197:17): [True: 2, False: 0] ------------------ 3198| 2| ? dns_zone_isdynamic(zone, false) 3199| 2| : false; 3200| | 3201| 2| dns_rdataset_init(&rdataset); 3202| 2| result = dns_db_findnode(db, &zone->origin, false, &node); ------------------ | | 771| 2| dns__db_findnode(db, DNS_NAME__RO_ARG(name), create, NULL, NULL, \ | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | 772| 2| nodep DNS__DB_FILELINE) ------------------ 3203| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3203:6): [True: 0, False: 2] ------------------ 3204| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3205| 0| "nsec3param lookup failure: %s", 3206| 0| isc_result_totext(result)); 3207| 0| return result; 3208| 0| } 3209| 2| dns_db_currentversion(db, &version); 3210| | 3211| 2| result = dns_db_findrdataset(db, node, version, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 3212| 2| dns_rdatatype_nsec3param, 3213| 2| dns_rdatatype_none, 0, &rdataset, NULL); 3214| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (3214:6): [True: 2, False: 0] ------------------ 3215| 2| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 3216| 2| result = ISC_R_SUCCESS; 3217| 2| goto cleanup; 3218| 2| } 3219| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (3219:6): [True: 0, False: 0] ------------------ 3220| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 3221| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3222| 0| "nsec3param lookup failure: %s", 3223| 0| isc_result_totext(result)); 3224| 0| goto cleanup; 3225| 0| } 3226| | 3227| 0| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 267| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 3228| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 0| { \ | | 150| 0| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 0| } ------------------ 3229| | 3230| 0| dns_rdataset_current(&rdataset, &rdata); 3231| 0| result = dns_rdata_tostruct(&rdata, &nsec3param); 3232| 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] | | ------------------ ------------------ 3233| | 3234| | /* 3235| | * For dynamic zones we must support every algorithm so we 3236| | * can regenerate all the NSEC3 chains. 3237| | * For non-dynamic zones we only need to find a supported 3238| | * algorithm. 3239| | */ 3240| 0| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NSEC3TESTZONE) && ------------------ | | 182| 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 (182:31): [True: 0, False: 0] | | ------------------ ------------------ 3241| 0| nsec3param.hash == DNS_NSEC3_UNKNOWNALG && !dynamic) ------------------ | | 49| 0|#define DNS_NSEC3_UNKNOWNALG ((dns_hash_t)245U) ------------------ | Branch (3241:7): [True: 0, False: 0] | Branch (3241:50): [True: 0, False: 0] ------------------ 3242| 0| { 3243| 0| dns_zone_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3244| 0| "nsec3 test \"unknown\" hash algorithm " 3245| 0| "found: %u", 3246| 0| nsec3param.hash); 3247| 0| ok = true; 3248| 0| } else if (!dns_nsec3_supportedhash(nsec3param.hash)) { ------------------ | Branch (3248:14): [True: 0, False: 0] ------------------ 3249| 0| if (dynamic) { ------------------ | Branch (3249:8): [True: 0, False: 0] ------------------ 3250| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3251| 0| "unsupported nsec3 hash algorithm" 3252| 0| " in dynamic zone: %u", 3253| 0| nsec3param.hash); 3254| 0| result = DNS_R_BADZONE; 3255| | /* Stop second error message. */ 3256| 0| ok = true; 3257| 0| break; 3258| 0| } else { 3259| 0| dns_zone_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3260| 0| "unsupported nsec3 hash " 3261| 0| "algorithm: %u", 3262| 0| nsec3param.hash); 3263| 0| } 3264| 0| } else { 3265| 0| ok = true; 3266| 0| } 3267| | 3268| | /* 3269| | * Warn if the zone has excessive NSEC3 iterations. 3270| | */ 3271| 0| if (nsec3param.iterations > dns_nsec3_maxiterations()) { ------------------ | Branch (3271:7): [True: 0, False: 0] ------------------ 3272| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 3273| 0| "excessive NSEC3PARAM iterations %u > %u", 3274| 0| nsec3param.iterations, 3275| 0| dns_nsec3_maxiterations()); 3276| 0| } 3277| 0| } 3278| | 3279| 0| if (!ok) { ------------------ | Branch (3279:6): [True: 0, False: 0] ------------------ 3280| 0| result = DNS_R_BADZONE; 3281| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 3282| 0| "no supported nsec3 hash algorithm"); 3283| 0| } 3284| | 3285| 2|cleanup: 3286| 2| dns_rdataset_cleanup(&rdataset); ------------------ | | 302| 2| if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { \ | | ------------------ | | | Branch (302:6): [True: 2, Folded] | | | Branch (302:26): [True: 0, False: 2] | | ------------------ | | 303| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE); \ | | 304| 0| } ------------------ 3287| 2| dns_db_closeversion(db, &version, false); ------------------ | | 734| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 3288| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 3289| 2| return result; 3290| 0|} zone.c:zone_namerd_tostr: 16257| 2|zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length) { 16258| 2| isc_result_t result = ISC_R_FAILURE; 16259| 2| isc_buffer_t buffer; 16260| | 16261| 2| REQUIRE(buf != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 16262| 2| REQUIRE(length > 1U); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 16263| | 16264| | /* 16265| | * Leave space for terminating '\0'. 16266| | */ 16267| 2| isc_buffer_init(&buffer, buf, (unsigned int)length - 1); 16268| 2| if (zone->type != dns_zone_redirect && zone->type != dns_zone_key) { ------------------ | Branch (16268:6): [True: 2, False: 0] | Branch (16268:41): [True: 2, False: 0] ------------------ 16269| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | | 1553| 2|#define dns_name_dynamic(name) dns_name__dynamic(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1553:32): [True: 2, False: 0] | | ------------------ ------------------ 16270| 2| result = dns_name_totext( ------------------ | | 1551| 2| dns_name__totext(DNS_NAME__RO_ARG(name), options, target) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 16271| 2| &zone->origin, DNS_NAME_OMITFINALDOT, &buffer); 16272| 2| } 16273| 2| if (result != ISC_R_SUCCESS && ------------------ | Branch (16273:7): [True: 0, False: 2] ------------------ 16274| 0| isc_buffer_availablelength(&buffer) >= ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16274:7): [True: 0, False: 0] ------------------ 16275| 0| (sizeof("") - 1)) 16276| 0| { 16277| 0| isc_buffer_putstr(&buffer, ""); 16278| 0| } 16279| | 16280| 2| if (isc_buffer_availablelength(&buffer) > 0) { ------------------ | | 162| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16280:7): [True: 2, False: 0] ------------------ 16281| 2| isc_buffer_putstr(&buffer, "/"); 16282| 2| } 16283| 2| (void)dns_rdataclass_totext(zone->rdclass, &buffer); 16284| 2| } 16285| | 16286| 2| const char *viewname = dns__viewname_display(&zone->viewname); 16287| 2| if (viewname != NULL && ------------------ | Branch (16287:6): [True: 0, False: 2] ------------------ 16288| 0| strlen(viewname) < isc_buffer_availablelength(&buffer)) ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16288:6): [True: 0, False: 0] ------------------ 16289| 0| { 16290| 0| isc_buffer_putstr(&buffer, "/"); 16291| 0| isc_buffer_putstr(&buffer, viewname); 16292| 0| } 16293| | /* Logging also runs without the zone lock. These configuration 16294| | * fields are changed before publication or with exclusive access. */ 16295| 2| if (zone->raw != NULL && 9U < isc_buffer_availablelength(&buffer)) { ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16295:6): [True: 0, False: 2] | Branch (16295:27): [True: 0, False: 0] ------------------ 16296| 0| isc_buffer_putstr(&buffer, " (signed)"); 16297| 0| } 16298| 2| if (zone->secure != NULL && 11U < isc_buffer_availablelength(&buffer)) { ------------------ | | 162| 0|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (16298:6): [True: 0, False: 2] | Branch (16298:30): [True: 0, False: 0] ------------------ 16299| 0| isc_buffer_putstr(&buffer, " (unsigned)"); 16300| 0| } 16301| | 16302| 2| buf[isc_buffer_usedlength(&buffer)] = '\0'; ------------------ | | 158| 2|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ 16303| 2|} zone.c:zone_count_ns_rr: 4700| 2| unsigned int *errors, bool logit) { 4701| 2| isc_result_t result; 4702| 2| unsigned int count = 0; 4703| 2| unsigned int ecount = 0; 4704| 2| dns_rdataset_t rdataset; 4705| 2| dns_rdata_ns_t ns; 4706| | 4707| 2| dns_rdataset_init(&rdataset); 4708| 2| result = dns_db_findrdataset(db, node, version, dns_rdatatype_ns, ------------------ | | 1125| 2| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 2| sigrdataset DNS__DB_FILELINE) ------------------ 4709| 2| dns_rdatatype_none, 0, &rdataset, NULL); 4710| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (4710:6): [True: 0, False: 2] ------------------ 4711| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4712| 0| goto success; 4713| 0| } 4714| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4714:6): [True: 0, False: 2] ------------------ 4715| 0| INSIST(!dns_rdataset_isassociated(&rdataset)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4716| 0| goto invalidate_rdataset; 4717| 0| } 4718| | 4719| 2| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 267| 2| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 2| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 4| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 2, False: 2] | | | | ------------------ | | ------------------ ------------------ 4720| 2| if (errors != NULL && zone->rdclass == dns_rdataclass_in && ------------------ | | 24| 4|#define dns_rdataclass_in ((dns_rdataclass_t)dns_rdataclass_in) ------------------ | Branch (4720:7): [True: 2, False: 0] | Branch (4720:25): [True: 2, False: 0] ------------------ 4721| 2| (zone->type == dns_zone_primary || ------------------ | Branch (4721:8): [True: 2, False: 0] ------------------ 4722| 0| zone->type == dns_zone_secondary || ------------------ | Branch (4722:8): [True: 0, False: 0] ------------------ 4723| 0| zone->type == dns_zone_mirror)) ------------------ | Branch (4723:8): [True: 0, False: 0] ------------------ 4724| 2| { 4725| 2| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 2| { \ | | 150| 2| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 2| } ------------------ 4726| 2| dns_rdataset_current(&rdataset, &rdata); 4727| | 4728| 2| result = dns_rdata_tostruct(&rdata, &ns); 4729| 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] | | ------------------ ------------------ 4730| 2| if (dns_name_issubdomain(&ns.name, &zone->origin) && ------------------ | | 1544| 4| dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | dns_name__issubdomain(DNS_NAME__RO_ARG(name1), DNS_NAME__RO_ARG(name2)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1544:2): [True: 0, False: 2] | | ------------------ ------------------ 4731| 0| !zone_check_ns(zone, db, version, &ns.name, logit)) ------------------ | Branch (4731:8): [True: 0, False: 0] ------------------ 4732| 0| { 4733| 0| ecount++; 4734| 0| } 4735| 2| } 4736| 2| count++; 4737| 2| } 4738| 2| dns_rdataset_disassociate(&rdataset); ------------------ | | 306| 2| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4739| | 4740| 2|success: 4741| 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| } ------------------ 4742| 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| } ------------------ 4743| | 4744| 2| result = ISC_R_SUCCESS; 4745| | 4746| 2|invalidate_rdataset: 4747| 2| dns_rdataset_invalidate(&rdataset); 4748| | 4749| 2| return result; 4750| 2|} zone.c:zone_postload: 4012| 2| isc_result_t result) { 4013| 2| unsigned int soacount = 0; 4014| 2| unsigned int nscount = 0; 4015| 2| unsigned int errors = 0; 4016| 2| uint32_t serial, oldserial, refresh, retry, expire, minimum, soattl; 4017| 2| isc_time_t now; 4018| 2| bool needdump = false; 4019| 2| bool fixjournal = false; 4020| 2| bool hasinclude = DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 126| 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) | | ------------------ ------------------ 4021| 2| bool noprimary = false; 4022| 2| bool had_db = false; 4023| 2| bool is_dynamic = false; 4024| | 4025| 2| INSIST(LOCKED_ZONE(zone)); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4026| 2| if (dns__zone_inline_raw(zone)) { ------------------ | Branch (4026:6): [True: 0, False: 2] ------------------ 4027| 0| INSIST(LOCKED_ZONE(zone->secure)); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4028| 0| } 4029| | 4030| 2| now = isc_time_now(); 4031| | 4032| | /* 4033| | * Initiate zone transfer? We may need a error code that 4034| | * indicates that the "permanent" form does not exist. 4035| | * XXX better error feedback to log. 4036| | */ 4037| 2| if (result != ISC_R_SUCCESS && result != DNS_R_SEENINCLUDE) { ------------------ | Branch (4037:6): [True: 0, False: 2] | Branch (4037:33): [True: 0, False: 0] ------------------ 4038| 0| if (zone->type == dns_zone_secondary || ------------------ | Branch (4038:7): [True: 0, False: 0] ------------------ 4039| 0| zone->type == dns_zone_mirror || ------------------ | Branch (4039:7): [True: 0, False: 0] ------------------ 4040| 0| zone->type == dns_zone_stub || ------------------ | Branch (4040:7): [True: 0, False: 0] ------------------ 4041| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (4041:8): [True: 0, False: 0] ------------------ 4042| 0| dns_remote_addresses(&zone->primaries) == NULL)) ------------------ | Branch (4042:8): [True: 0, False: 0] ------------------ 4043| 0| { 4044| 0| if (result == ISC_R_FILENOTFOUND) { ------------------ | Branch (4044:8): [True: 0, False: 0] ------------------ 4045| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4046| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4047| 0| "no master file"); 4048| 0| } else if (result != DNS_R_NOMASTERFILE) { ------------------ | Branch (4048:15): [True: 0, False: 0] ------------------ 4049| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4050| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4051| 0| "loading from master file %s " 4052| 0| "failed: %s", 4053| 0| zone->masterfile, 4054| 0| isc_result_totext(result)); 4055| 0| } 4056| 0| } else if (zone->type == dns_zone_primary && ------------------ | Branch (4056:14): [True: 0, False: 0] ------------------ 4057| 0| dns__zone_inline_secure(zone) && ------------------ | Branch (4057:7): [True: 0, False: 0] ------------------ 4058| 0| result == ISC_R_FILENOTFOUND) ------------------ | Branch (4058:7): [True: 0, False: 0] ------------------ 4059| 0| { 4060| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4061| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4062| 0| "no master file; secure db will be " 4063| 0| "bootstrapped from raw zone"); 4064| 0| } else { 4065| 0| int level = ISC_LOG_ERROR; ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4066| 0| if (zone->type == dns_zone_key && ------------------ | Branch (4066:8): [True: 0, False: 0] ------------------ 4067| 0| result == ISC_R_FILENOTFOUND) ------------------ | Branch (4067:8): [True: 0, False: 0] ------------------ 4068| 0| { 4069| 0| level = ISC_LOG_DEBUG(1); ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4070| 0| } 4071| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, level, 4072| 0| "loading from master file %s failed: %s", 4073| 0| zone->masterfile, 4074| 0| isc_result_totext(result)); 4075| 0| noprimary = true; 4076| 0| } 4077| | 4078| 0| if (zone->type != dns_zone_key) { ------------------ | Branch (4078:7): [True: 0, False: 0] ------------------ 4079| 0| goto cleanup; 4080| 0| } 4081| 0| } 4082| | 4083| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(2), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 4084| 2| "number of nodes in database: %u", dns_db_nodecount(db)); 4085| | 4086| 2| if (result == DNS_R_SEENINCLUDE) { ------------------ | Branch (4086:6): [True: 0, False: 2] ------------------ 4087| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4088| 2| } else { 4089| 2| DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_HASINCLUDE); ------------------ | | 128| 2|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4090| 2| } 4091| | 4092| | /* 4093| | * If there's no master file for a key zone, then the zone is new: 4094| | * create an SOA record. (We do this now, instead of later, so that 4095| | * if there happens to be a journal file, we can roll forward from 4096| | * a sane starting point.) 4097| | */ 4098| 2| if (noprimary && zone->type == dns_zone_key) { ------------------ | Branch (4098:6): [True: 0, False: 2] | Branch (4098:19): [True: 0, False: 0] ------------------ 4099| 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| } ------------------ 4100| 0| } 4101| | 4102| | /* 4103| | * Apply update log, if any, on initial load. 4104| | */ 4105| 2| if (zone->journal != NULL && ------------------ | Branch (4105:6): [True: 2, False: 0] ------------------ 4106| 2| !DNS_ZONE_OPTION(zone, DNS_ZONEOPT_NOMERGE) && ------------------ | | 182| 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 (4106:6): [True: 2, False: 0] ------------------ 4107| 2| !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) ------------------ | | 126| 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 (4107:6): [True: 2, False: 0] ------------------ 4108| 2| { 4109| 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| } ------------------ 4110| 2| &fixjournal)); 4111| 2| } 4112| | 4113| | /* 4114| | * Obtain ns, soa and cname counts for top of zone. 4115| | */ 4116| 2| INSIST(db != NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4117| 2| result = zone_get_from_db(zone, db, &nscount, &soacount, &soattl, 4118| 2| &serial, &refresh, &retry, &expire, &minimum, 4119| 2| &errors); 4120| 2| if (result != ISC_R_SUCCESS && zone->type != dns_zone_key) { ------------------ | Branch (4120:6): [True: 0, False: 2] | Branch (4120:33): [True: 0, False: 0] ------------------ 4121| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4122| 0| "could not find NS and/or SOA records"); 4123| 0| } 4124| | 4125| 2| is_dynamic = dns_zone_isdynamic(zone, true); 4126| | 4127| | /* 4128| | * Check to make sure the journal is up to date, and remove the 4129| | * journal file if it isn't, as we wouldn't be able to apply 4130| | * updates otherwise. 4131| | */ 4132| 2| if (zone->journal != NULL && is_dynamic && ------------------ | Branch (4132:6): [True: 2, False: 0] | Branch (4132:31): [True: 0, False: 2] ------------------ 4133| 0| !DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS)) ------------------ | | 182| 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 (4133:6): [True: 0, False: 0] ------------------ 4134| 0| { 4135| 0| uint32_t jserial; 4136| 0| dns_journal_t *journal = NULL; 4137| 0| bool empty = false; 4138| | 4139| 0| result = dns_journal_open(zone->mctx, zone->journal, 4140| 0| DNS_JOURNAL_READ, &journal); ------------------ | | 44| 0|#define DNS_JOURNAL_READ 0x00000000 /* false */ ------------------ 4141| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4141:7): [True: 0, False: 0] ------------------ 4142| 0| jserial = dns_journal_last_serial(journal); 4143| 0| empty = dns_journal_empty(journal); 4144| 0| dns_journal_destroy(&journal); 4145| 0| } else { 4146| 0| jserial = serial; 4147| 0| result = ISC_R_SUCCESS; 4148| 0| } 4149| | 4150| 0| if (jserial != serial) { ------------------ | Branch (4150:7): [True: 0, False: 0] ------------------ 4151| 0| if (!empty) { ------------------ | Branch (4151:8): [True: 0, False: 0] ------------------ 4152| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4153| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4154| 0| "journal file is out of date: " 4155| 0| "removing journal file"); 4156| 0| } 4157| 0| if (remove(zone->journal) < 0 && errno != ENOENT) { ------------------ | Branch (4157:8): [True: 0, False: 0] | Branch (4157:37): [True: 0, False: 0] ------------------ 4158| 0| char strbuf[ISC_STRERRORSIZE]; 4159| 0| strerror_r(errno, strbuf, sizeof(strbuf)); ------------------ | | 33| 0|#define strerror_r isc_string_strerror_r ------------------ 4160| 0| isc_log_write(DNS_LOGCATEGORY_GENERAL, 4161| 0| DNS_LOGMODULE_ZONE, 4162| 0| ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4163| 0| "unable to remove journal " 4164| 0| "'%s': '%s'", 4165| 0| zone->journal, strbuf); 4166| 0| } 4167| 0| } 4168| 0| } 4169| | 4170| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 4171| 2| "loaded; checking validity"); 4172| | 4173| | /* 4174| | * Primary / Secondary / Mirror / Stub zones require both NS and SOA 4175| | * records at the top of the zone. 4176| | */ 4177| | 4178| 2| switch (zone->type) { 4179| 0| case dns_zone_dlz: ------------------ | Branch (4179:2): [True: 0, False: 2] ------------------ 4180| 2| case dns_zone_primary: ------------------ | Branch (4180:2): [True: 2, False: 0] ------------------ 4181| 2| case dns_zone_secondary: ------------------ | Branch (4181:2): [True: 0, False: 2] ------------------ 4182| 2| case dns_zone_mirror: ------------------ | Branch (4182:2): [True: 0, False: 2] ------------------ 4183| 2| case dns_zone_stub: ------------------ | Branch (4183:2): [True: 0, False: 2] ------------------ 4184| 2| case dns_zone_redirect: ------------------ | Branch (4184:2): [True: 0, False: 2] ------------------ 4185| 2| if (soacount != 1) { ------------------ | Branch (4185:7): [True: 0, False: 2] ------------------ 4186| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4187| 0| ISC_LOG_ERROR, "has %d SOA records", ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4188| 0| soacount); 4189| 0| result = DNS_R_BADZONE; 4190| 0| } 4191| 2| if (nscount == 0) { ------------------ | Branch (4191:7): [True: 0, False: 2] ------------------ 4192| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4193| 0| ISC_LOG_ERROR, "has no NS records"); ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4194| 0| result = DNS_R_BADZONE; 4195| 0| } 4196| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4196:7): [True: 0, False: 2] ------------------ 4197| 0| goto cleanup; 4198| 0| } 4199| 2| if (zone->type == dns_zone_primary && errors != 0) { ------------------ | Branch (4199:7): [True: 2, False: 0] | Branch (4199:41): [True: 0, False: 2] ------------------ 4200| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4201| 0| } 4202| 2| if (zone->type != dns_zone_stub && ------------------ | Branch (4202:7): [True: 2, False: 0] ------------------ 4203| 2| zone->type != dns_zone_redirect) ------------------ | Branch (4203:7): [True: 2, False: 0] ------------------ 4204| 2| { 4205| 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| } ------------------ 4206| 2| } 4207| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4207:7): [True: 2, False: 0] ------------------ 4208| 2| DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKINTEGRITY) && ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 4209| 0| !integrity_checks(zone, db)) ------------------ | Branch (4209:7): [True: 0, False: 0] ------------------ 4210| 0| { 4211| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4212| 0| } 4213| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4213:7): [True: 2, False: 0] ------------------ 4214| 2| DNS_ZONE_OPTION(zone, DNS_ZONEOPT_CHECKDUPRR) && ------------------ | | 182| 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 (182:31): [True: 0, False: 2] | | ------------------ ------------------ 4215| 0| !zone_check_dup(zone, db)) ------------------ | Branch (4215:7): [True: 0, False: 0] ------------------ 4216| 0| { 4217| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4218| 0| } 4219| | 4220| 2| if (zone->type == dns_zone_primary) { ------------------ | Branch (4220:7): [True: 2, False: 0] ------------------ 4221| 2| result = dns_zone_cdscheck(zone, db, NULL); 4222| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4222:8): [True: 0, False: 2] ------------------ 4223| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4224| 0| "CDS/CDNSKEY consistency checks " 4225| 0| "failed"); 4226| 0| goto cleanup; 4227| 0| } 4228| 2| } 4229| | 4230| 2| result = check_reportchannel(zone, db); 4231| 2| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4231:7): [True: 0, False: 2] ------------------ 4232| 0| dns_zone_log(zone, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4233| 0| "'log-report-channel' is set, but no " 4234| 0| "'*._er/TXT' wildcard found"); 4235| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4236| 0| } 4237| | 4238| 2| if (zone->type == dns_zone_mirror) { ------------------ | Branch (4238:7): [True: 0, False: 2] ------------------ 4239| 0| CHECK(dns_zone_verifydb(zone->view, db, 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| } ------------------ 4240| 0| } 4241| | 4242| 2| if (zone->db != NULL) { ------------------ | Branch (4242:7): [True: 0, False: 2] ------------------ 4243| 0| unsigned int oldsoacount; 4244| | 4245| | /* 4246| | * This is checked in zone_replacedb() for 4247| | * secondary zones as they don't reload from disk. 4248| | */ 4249| 0| result = zone_get_from_db( 4250| 0| zone, zone->db, NULL, &oldsoacount, NULL, 4251| 0| &oldserial, NULL, NULL, NULL, NULL, NULL); 4252| 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] | | ------------------ ------------------ 4253| 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] | | ------------------ ------------------ 4254| 0| if (DNS_ZONE_OPTION(zone, DNS_ZONEOPT_IXFRFROMDIFFS) && ------------------ | | 182| 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 (182:31): [True: 0, False: 0] | | ------------------ ------------------ 4255| 0| !isc_serial_gt(serial, oldserial)) ------------------ | Branch (4255:8): [True: 0, False: 0] ------------------ 4256| 0| { 4257| 0| uint32_t serialmin, serialmax; 4258| | 4259| 0| INSIST(zone->type == dns_zone_primary); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4260| 0| INSIST(zone->raw == NULL); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 4261| | 4262| 0| if (serial == oldserial && ------------------ | Branch (4262:9): [True: 0, False: 0] ------------------ 4263| 0| zone_unchanged(zone->db, db, zone->mctx)) ------------------ | Branch (4263:9): [True: 0, False: 0] ------------------ 4264| 0| { 4265| 0| dns_zone_logc(zone, 4266| 0| DNS_LOGCATEGORY_ZONELOAD, 4267| 0| ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4268| 0| "ixfr-from-differences: " 4269| 0| "unchanged"); 4270| 0| zone->loadtime = loadtime; 4271| 0| goto done; 4272| 0| } 4273| | 4274| 0| serialmin = (oldserial + 1) & 0xffffffffU; 4275| 0| serialmax = (oldserial + 0x7fffffffU) & 4276| 0| 0xffffffffU; 4277| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4278| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4279| 0| "ixfr-from-differences: " 4280| 0| "new serial (%u) out of range " 4281| 0| "[%u - %u]", 4282| 0| serial, serialmin, serialmax); 4283| 0| CLEANUP(DNS_R_BADZONE); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4284| 0| } else if (!isc_serial_ge(serial, oldserial)) { ------------------ | Branch (4284:15): [True: 0, False: 0] ------------------ 4285| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4286| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4287| 0| "zone serial (%u/%u) has gone " 4288| 0| "backwards", 4289| 0| serial, oldserial); 4290| 0| } else if (serial == oldserial && !hasinclude && ------------------ | Branch (4290:15): [True: 0, False: 0] | Branch (4290:38): [True: 0, False: 0] ------------------ 4291| 0| strcmp(zone->db_argv[0], "_builtin") != 0) ------------------ | Branch (4291:8): [True: 0, False: 0] ------------------ 4292| 0| { 4293| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4294| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4295| 0| "zone serial (%u) unchanged. " 4296| 0| "zone may fail to transfer " 4297| 0| "to secondaries.", 4298| 0| serial); 4299| 0| } 4300| 0| } 4301| | 4302| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (4302:7): [True: 2, False: 0] ------------------ 4303| 2| (zone->update_acl != NULL || zone->ssutable != NULL) && ------------------ | Branch (4303:8): [True: 0, False: 2] | Branch (4303:36): [True: 0, False: 2] ------------------ 4304| 0| dns_zone_getsigresigninginterval(zone) < (3 * refresh) && ------------------ | Branch (4304:7): [True: 0, False: 0] ------------------ 4305| 0| dns_db_issecure(db)) ------------------ | Branch (4305:7): [True: 0, False: 0] ------------------ 4306| 0| { 4307| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4308| 0| ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4309| 0| "sig-re-signing-interval less than " 4310| 0| "3 * refresh."); 4311| 0| } 4312| | 4313| 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] | | ------------------ ------------------ 4314| 2| zone->maxrefresh); 4315| 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] | | ------------------ ------------------ 4316| 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] | | ------------------ ------------------ 4317| 2| DNS_MAX_EXPIRE); 4318| 2| zone->soattl = soattl; 4319| 2| zone->minimum = minimum; 4320| 2| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_HAVETIMERS); ------------------ | | 127| 2|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4321| | 4322| 2| if (zone->type == dns_zone_secondary || ------------------ | Branch (4322:7): [True: 0, False: 2] ------------------ 4323| 2| zone->type == dns_zone_mirror || ------------------ | Branch (4323:7): [True: 0, False: 2] ------------------ 4324| 2| zone->type == dns_zone_stub || ------------------ | Branch (4324:7): [True: 0, False: 2] ------------------ 4325| 2| (zone->type == dns_zone_redirect && ------------------ | Branch (4325:8): [True: 0, False: 2] ------------------ 4326| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (4326:8): [True: 0, False: 0] ------------------ 4327| 0| { 4328| 0| isc_time_t t; 4329| 0| uint32_t delay; 4330| | 4331| 0| result = isc_file_getmodtime(zone->journal, &t); 4332| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4332:8): [True: 0, False: 0] ------------------ 4333| 0| result = isc_file_getmodtime(zone->masterfile, 4334| 0| &t); 4335| 0| } 4336| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4336:8): [True: 0, False: 0] ------------------ 4337| 0| DNS_ZONE_TIME_ADD(&t, zone->expire, ------------------ | | 375| 0| do { \ | | 376| 0| isc_interval_t _i; \ | | ------------------ | | | | 64| 0|#define isc_interval_t isc_time_t | | ------------------ | | 377| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 67| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 378| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (378:7): [True: 0, False: 0] | | ------------------ | | 379| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 380| 0| "epoch approaching: upgrade required: " \ | | 381| 0| "now + %s failed", \ | | 382| 0| #b); \ | | 383| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 67| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 384| 0| (void)isc_time_add((a), &_i, (c)); \ | | 385| 0| } \ | | 386| 0| } while (0) | | ------------------ | | | Branch (386:11): [Folded, False: 0] | | ------------------ ------------------ 4338| 0| &zone->expiretime); 4339| 0| } else { 4340| 0| DNS_ZONE_TIME_ADD(&now, zone->retry, ------------------ | | 375| 0| do { \ | | 376| 0| isc_interval_t _i; \ | | ------------------ | | | | 64| 0|#define isc_interval_t isc_time_t | | ------------------ | | 377| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 67| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 378| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (378:7): [True: 0, False: 0] | | ------------------ | | 379| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 380| 0| "epoch approaching: upgrade required: " \ | | 381| 0| "now + %s failed", \ | | 382| 0| #b); \ | | 383| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 67| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 384| 0| (void)isc_time_add((a), &_i, (c)); \ | | 385| 0| } \ | | 386| 0| } while (0) | | ------------------ | | | Branch (386:11): [Folded, False: 0] | | ------------------ ------------------ 4341| 0| &zone->expiretime); 4342| 0| } 4343| | 4344| 0| delay = (zone->retry - 4345| 0| isc_random_uniform((zone->retry * 3) / 4)); 4346| 0| DNS_ZONE_TIME_ADD(&now, delay, &zone->refreshtime); ------------------ | | 375| 0| do { \ | | 376| 0| isc_interval_t _i; \ | | ------------------ | | | | 64| 0|#define isc_interval_t isc_time_t | | ------------------ | | 377| 0| isc_interval_set(&_i, (b), 0); \ | | ------------------ | | | | 67| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 378| 0| if (isc_time_add((a), &_i, (c)) != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (378:7): [True: 0, False: 0] | | ------------------ | | 379| 0| dns_zone_log(zone, ISC_LOG_WARNING, \ | | ------------------ | | | | 44| 0|#define ISC_LOG_WARNING (-3) | | ------------------ | | 380| 0| "epoch approaching: upgrade required: " \ | | 381| 0| "now + %s failed", \ | | 382| 0| #b); \ | | 383| 0| isc_interval_set(&_i, (b) / 2, 0); \ | | ------------------ | | | | 67| 0| isc_time_set((isc_time_t *)i, seconds, nanoseconds) | | ------------------ | | 384| 0| (void)isc_time_add((a), &_i, (c)); \ | | 385| 0| } \ | | 386| 0| } while (0) | | ------------------ | | | Branch (386:11): [Folded, False: 0] | | ------------------ ------------------ 4347| 0| if (isc_time_compare(&zone->refreshtime, ------------------ | Branch (4347:8): [True: 0, False: 0] ------------------ 4348| 0| &zone->expiretime) >= 0) 4349| 0| { 4350| 0| DNS_ZONE_SETFLAG(zone, ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4351| 0| DNS_ZONEFLG_FIRSTREFRESH); 4352| 0| zone->refreshtime = now; 4353| 0| } else { 4354| | /* The zone is up to date. */ 4355| 0| DNS_ZONE_CLRFLAG(zone, ------------------ | | 128| 0|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4356| 0| DNS_ZONEFLG_FIRSTREFRESH); 4357| 0| } 4358| 0| } 4359| | 4360| 2| break; 4361| | 4362| 0| case dns_zone_key: ------------------ | Branch (4362:2): [True: 0, False: 2] ------------------ 4363| | /* Nothing needs to be done now */ 4364| 0| break; 4365| | 4366| 0| default: ------------------ | Branch (4366:2): [True: 0, False: 2] ------------------ 4367| 0| UNEXPECTED_ERROR("unexpected zone type %d", zone->type); ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 4368| 0| CLEANUP(ISC_R_UNEXPECTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 4369| 2| } 4370| | 4371| | /* 4372| | * Check for weak DNSKEY's. 4373| | */ 4374| 2| if (zone->type == dns_zone_primary) { ------------------ | Branch (4374:6): [True: 2, False: 0] ------------------ 4375| 2| zone_check_dnskeys(zone, db); 4376| 2| } 4377| | 4378| | /* 4379| | * Schedule DNSSEC key refresh. 4380| | */ 4381| 2| if (zone->type == dns_zone_primary && zone->kasp != NULL) { ------------------ | Branch (4381:6): [True: 2, False: 0] | Branch (4381:40): [True: 0, False: 2] ------------------ 4382| 0| zone->refreshkeytime = now; 4383| 0| } 4384| | 4385| 2| ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 120| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 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| } | | ------------------ ------------------ 4386| 2| if (zone->db != NULL) { ------------------ | Branch (4386:6): [True: 0, False: 2] ------------------ 4387| 0| had_db = true; 4388| 0| result = zone_replacedb(zone, db, false); 4389| 0| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 121| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 0| } \ | | | | | | 293| 0| } | | | | ------------------ | | | | 42| 0| } | | ------------------ ------------------ 4390| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4390:7): [True: 0, False: 0] ------------------ 4391| 0| goto cleanup; 4392| 0| } 4393| 2| } else { 4394| 2| zone_attachdb(zone, db); 4395| 2| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write); ------------------ | | 121| 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() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 2| } \ | | | | | | 293| 2| } | | | | ------------------ | | | | 42| 2| } | | ------------------ ------------------ 4396| 2| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADED | ------------------ | | 127| 2|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4397| 2| DNS_ZONEFLG_NEEDSTARTUPNOTIFY); 4398| 2| if (dns__zone_inline_raw(zone)) { ------------------ | Branch (4398:7): [True: 0, False: 2] ------------------ 4399| 0| zone_schedule_inline_sync(zone->secure, 4400| 0| inline_sync_incremental); 4401| 0| } 4402| 2| } 4403| | 4404| 2| result = ISC_R_SUCCESS; 4405| | 4406| 2| if (fixjournal) { ------------------ | Branch (4406:6): [True: 0, False: 2] ------------------ 4407| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIXJOURNAL); ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4408| 0| zone_journal_compact(zone, zone->db, 0); 4409| 0| } 4410| 2| if (needdump) { ------------------ | Branch (4410:6): [True: 0, False: 2] ------------------ 4411| 0| if (zone->type == dns_zone_key) { ------------------ | Branch (4411:7): [True: 0, False: 0] ------------------ 4412| 0| zone_needdump(zone, 30); 4413| 0| } else { 4414| 0| zone_needdump(zone, DNS_DUMP_DELAY); ------------------ | | 71| 0|#define DNS_DUMP_DELAY 900 /*%< 15 minutes */ ------------------ 4415| 0| } 4416| 0| } 4417| | 4418| 2| if (zone->loop != NULL) { ------------------ | Branch (4418:6): [True: 0, False: 2] ------------------ 4419| 0| if (zone->type == dns_zone_primary) { ------------------ | Branch (4419:7): [True: 0, False: 0] ------------------ 4420| 0| dns__zone_set_resigntime(zone); 4421| 0| resume_signingwithkey(zone); 4422| 0| resume_addnsec3chain(zone); 4423| 0| } 4424| | 4425| 0| is_dynamic = dns_zone_isdynamic(zone, false); 4426| 0| if (zone->type == dns_zone_primary && is_dynamic && ------------------ | Branch (4426:7): [True: 0, False: 0] | Branch (4426:41): [True: 0, False: 0] ------------------ 4427| 0| dns_db_issecure(db) && !dns__zone_inline_raw(zone)) ------------------ | Branch (4427:7): [True: 0, False: 0] | Branch (4427:30): [True: 0, False: 0] ------------------ 4428| 0| { 4429| 0| isc_stdtime_t resign; 4430| 0| dns_name_t *name; 4431| 0| dns_fixedname_t fixed; 4432| 0| dns_typepair_t typepair; 4433| | 4434| 0| name = dns_fixedname_initname(&fixed); 4435| | 4436| 0| result = dns_db_getsigningtime(db, &resign, name, 4437| 0| &typepair); 4438| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (4438:8): [True: 0, False: 0] ------------------ 4439| 0| isc_stdtime_t timenow = isc_stdtime_now(); 4440| 0| char namebuf[DNS_NAME_FORMATSIZE]; 4441| 0| char typebuf[DNS_RDATATYPE_FORMATSIZE]; 4442| | 4443| 0| dns_name_format(name, namebuf, sizeof(namebuf)); ------------------ | | 1556| 0| dns_name__format(DNS_NAME__RO_ARG(name), cp, size) | | ------------------ | | | | 1507| 0| _Generic((arg), \ | | | | 1508| 0| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 0| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 0| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 0| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 0| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 0| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 4444| 0| dns_rdatatype_format( 4445| 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| }) ------------------ 4446| 0| sizeof(typebuf)); 4447| 0| dnssec_log( 4448| 0| zone, ISC_LOG_DEBUG(3), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 4449| 0| "next resign: %s/%s " 4450| 0| "in %d seconds", 4451| 0| namebuf, typebuf, 4452| 0| resign - timenow - 4453| 0| dns_zone_getsigresigninginterval( 4454| 0| zone)); 4455| 0| } else { 4456| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 4457| 0| "signed dynamic zone has no " 4458| 0| "resign event scheduled"); 4459| 0| } 4460| 0| } 4461| | 4462| 0| dns__zone_settimer(zone, now); 4463| 0| } 4464| | 4465| | /* 4466| | * Clear old include list. 4467| | */ 4468| 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] | | ------------------ ------------------ 4469| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4470| 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] | | ------------------ ------------------ 4471| 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] | | ------------------ ------------------ 4472| 0| } 4473| | 4474| | /* 4475| | * Transfer new include list. 4476| | */ 4477| 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] | | ------------------ ------------------ 4478| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4479| 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] | | ------------------ ------------------ 4480| 0| } 4481| | 4482| 2| if (!dns_db_ispersistent(db)) { ------------------ | Branch (4482:6): [True: 2, False: 0] ------------------ 4483| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 2|#define ISC_LOG_INFO (-1) ------------------ 4484| 2| "loaded serial %u%s", serial, 4485| 2| dns_db_issecure(db) ? " (DNSSEC signed)" : ""); ------------------ | Branch (4485:10): [True: 0, False: 2] ------------------ 4486| 2| } 4487| | 4488| 2| if (!had_db && zone->type == dns_zone_mirror) { ------------------ | Branch (4488:6): [True: 2, False: 0] | Branch (4488:17): [True: 0, False: 2] ------------------ 4489| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_INFO, ------------------ | | 42| 0|#define ISC_LOG_INFO (-1) ------------------ 4490| 0| "mirror zone is now in use"); 4491| 0| } 4492| | 4493| 2| zone->loadtime = loadtime; 4494| 2| goto done; 4495| | 4496| 0|cleanup: 4497| 0| if (result != ISC_R_SUCCESS) { ------------------ | Branch (4497:6): [True: 0, False: 0] ------------------ 4498| 0| dns_zone_rpz_disable_db(zone, db); 4499| 0| dns_zone_catz_disable_db(zone, db); 4500| 0| } 4501| | 4502| 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] | | ------------------ ------------------ 4503| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 0| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 135| 0| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 0] | | | | ------------------ | | ------------------ ------------------ 4504| 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] | | ------------------ ------------------ 4505| 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] | | ------------------ ------------------ 4506| 0| } 4507| 0| if (zone->type == dns_zone_secondary || zone->type == dns_zone_mirror || ------------------ | Branch (4507:6): [True: 0, False: 0] | Branch (4507:42): [True: 0, False: 0] ------------------ 4508| 0| zone->type == dns_zone_stub || zone->type == dns_zone_key || ------------------ | Branch (4508:6): [True: 0, False: 0] | Branch (4508:37): [True: 0, False: 0] ------------------ 4509| 0| (zone->type == dns_zone_redirect && ------------------ | Branch (4509:7): [True: 0, False: 0] ------------------ 4510| 0| dns_remote_addresses(&zone->primaries) != NULL)) ------------------ | Branch (4510:7): [True: 0, False: 0] ------------------ 4511| 0| { 4512| 0| DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FIRSTREFRESH); ------------------ | | 127| 0|#define DNS_ZONE_SETFLAG(z, f) atomic_fetch_or(&(z)->flags, (f)) ------------------ 4513| | 4514| 0| if (zone->journal != NULL) { ------------------ | Branch (4514:7): [True: 0, False: 0] ------------------ 4515| 0| zone_saveunique(zone, zone->journal, "jn-XXXXXXXX"); 4516| 0| } 4517| 0| if (zone->masterfile != NULL) { ------------------ | Branch (4517:7): [True: 0, False: 0] ------------------ 4518| 0| zone_saveunique(zone, zone->masterfile, "db-XXXXXXXX"); 4519| 0| } 4520| | 4521| | /* Mark the zone for immediate refresh. */ 4522| 0| zone->refreshtime = now; 4523| 0| if (zone->loop != NULL) { ------------------ | Branch (4523:7): [True: 0, False: 0] ------------------ 4524| 0| dns__zone_settimer(zone, now); 4525| 0| } 4526| 0| result = ISC_R_SUCCESS; 4527| 0| } else if (zone->type == dns_zone_primary || ------------------ | Branch (4527:13): [True: 0, False: 0] ------------------ 4528| 0| zone->type == dns_zone_redirect) ------------------ | Branch (4528:6): [True: 0, False: 0] ------------------ 4529| 0| { 4530| 0| if (!(dns__zone_inline_secure(zone) && ------------------ | Branch (4530:9): [True: 0, False: 0] ------------------ 4531| 0| result == ISC_R_FILENOTFOUND)) ------------------ | Branch (4531:9): [True: 0, False: 0] ------------------ 4532| 0| { 4533| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 4534| 0| ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 4535| 0| "not loaded due to errors."); 4536| 0| } else if (zone->type == dns_zone_primary) { ------------------ | Branch (4536:14): [True: 0, False: 0] ------------------ 4537| 0| result = ISC_R_SUCCESS; 4538| 0| } 4539| 0| } 4540| | 4541| 2|done: 4542| 2| DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_LOADPENDING); ------------------ | | 128| 2|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4543| | /* 4544| | * If this is an inline-signed zone and we were called for the raw 4545| | * zone, we need to clear DNS_ZONEFLG_LOADPENDING for the secure zone 4546| | * as well, but only if this is a reload, not an initial zone load: in 4547| | * the former case, zone_postload() will not be run for the secure 4548| | * zone; in the latter case, it will be. Check which case we are 4549| | * dealing with by consulting the DNS_ZONEFLG_LOADED flag for the 4550| | * secure zone: if it is set, this must be a reload. 4551| | */ 4552| 2| if (dns__zone_inline_raw(zone) && ------------------ | Branch (4552:6): [True: 0, False: 2] ------------------ 4553| 0| DNS_ZONE_FLAG(zone->secure, DNS_ZONEFLG_LOADED)) ------------------ | | 126| 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 (126:32): [True: 0, False: 0] | | ------------------ ------------------ 4554| 0| { 4555| 0| DNS_ZONE_CLRFLAG(zone->secure, DNS_ZONEFLG_LOADPENDING); ------------------ | | 128| 0|#define DNS_ZONE_CLRFLAG(z, f) atomic_fetch_and(&(z)->flags, ~(f)) ------------------ 4556| | /* 4557| | * Re-start zone maintenance if it had been stalled 4558| | * due to DNS_ZONEFLG_LOADPENDING being set when 4559| | * zone_maintenance was called. 4560| | */ 4561| 0| if (zone->secure->loop != NULL) { ------------------ | Branch (4561:7): [True: 0, False: 0] ------------------ 4562| 0| dns__zone_settimer(zone->secure, now); 4563| 0| } 4564| 0| } 4565| | 4566| 2| zone_debuglog(zone, __func__, 99, "done"); 4567| | 4568| 2| return result; 4569| 0|} zone.c:zone_journal_rollforward: 10361| 2| bool *fixjournal) { 10362| 2| dns_journal_t *journal = NULL; 10363| 2| unsigned int options; 10364| 2| isc_result_t result; 10365| | 10366| 2| if (zone->type == dns_zone_primary && ------------------ | Branch (10366:6): [True: 2, False: 0] ------------------ 10367| 2| (dns__zone_inline_secure(zone) || ------------------ | Branch (10367:7): [True: 0, False: 2] ------------------ 10368| 2| (zone->update_acl != NULL || zone->ssutable != NULL))) ------------------ | Branch (10368:8): [True: 0, False: 2] | Branch (10368:36): [True: 0, False: 2] ------------------ 10369| 0| { 10370| 0| options = DNS_JOURNALOPT_RESIGN; ------------------ | | 42| 0|#define DNS_JOURNALOPT_RESIGN 0x00000001 ------------------ 10371| 2| } else { 10372| 2| options = 0; 10373| 2| } 10374| | 10375| 2| result = dns_journal_open(zone->mctx, zone->journal, DNS_JOURNAL_READ, ------------------ | | 44| 2|#define DNS_JOURNAL_READ 0x00000000 /* false */ ------------------ 10376| 2| &journal); 10377| 2| if (result == ISC_R_NOTFOUND) { ------------------ | Branch (10377:6): [True: 2, False: 0] ------------------ 10378| 2| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(3), ------------------ | | 36| 2|#define ISC_LOG_DEBUG(level) (level) ------------------ 10379| 2| "no journal file, but that's OK "); 10380| 2| return ISC_R_SUCCESS; 10381| 2| } else if (result != ISC_R_SUCCESS) { ------------------ | Branch (10381:13): [True: 0, False: 0] ------------------ 10382| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10383| 0| "journal open failed: %s", 10384| 0| isc_result_totext(result)); 10385| 0| return result; 10386| 0| } 10387| | 10388| 0| if (dns_journal_empty(journal)) { ------------------ | Branch (10388:6): [True: 0, False: 0] ------------------ 10389| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10390| 0| "journal empty"); 10391| 0| dns_journal_destroy(&journal); 10392| 0| return ISC_R_SUCCESS; 10393| 0| } 10394| | 10395| 0| result = dns_journal_rollforward(journal, db, options); 10396| 0| switch (result) { 10397| 0| case ISC_R_SUCCESS: ------------------ | Branch (10397:2): [True: 0, False: 0] ------------------ 10398| 0| *needdump = true; 10399| 0| FALLTHROUGH; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 10400| 0| case DNS_R_UPTODATE: ------------------ | Branch (10400:2): [True: 0, False: 0] ------------------ 10401| 0| if (dns_journal_recovered(journal)) { ------------------ | Branch (10401:7): [True: 0, False: 0] ------------------ 10402| 0| *fixjournal = true; 10403| 0| dns_zone_logc( 10404| 0| zone, DNS_LOGCATEGORY_ZONELOAD, 10405| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10406| 0| "journal rollforward completed successfully " 10407| 0| "using old journal format: %s", 10408| 0| isc_result_totext(result)); 10409| 0| } else { 10410| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, 10411| 0| ISC_LOG_DEBUG(1), ------------------ | | 36| 0|#define ISC_LOG_DEBUG(level) (level) ------------------ 10412| 0| "journal rollforward completed " 10413| 0| "successfully: %s", 10414| 0| isc_result_totext(result)); 10415| 0| } 10416| | 10417| 0| dns_journal_destroy(&journal); 10418| 0| return ISC_R_SUCCESS; 10419| 0| case ISC_R_NOTFOUND: ------------------ | Branch (10419:2): [True: 0, False: 0] ------------------ 10420| 0| case ISC_R_RANGE: ------------------ | Branch (10420:2): [True: 0, False: 0] ------------------ 10421| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10422| 0| "journal rollforward failed: journal out of sync " 10423| 0| "with zone"); 10424| 0| dns_journal_destroy(&journal); 10425| 0| return result; 10426| 0| default: ------------------ | Branch (10426:2): [True: 0, False: 0] ------------------ 10427| 0| dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, ISC_LOG_ERROR, ------------------ | | 45| 0|#define ISC_LOG_ERROR (-4) ------------------ 10428| 0| "journal rollforward failed: %s", 10429| 0| isc_result_totext(result)); 10430| 0| dns_journal_destroy(&journal); 10431| 0| return result; 10432| 0| } 10433| 0|} zone.c:check_reportchannel: 3970| 2|check_reportchannel(dns_zone_t *zone, dns_db_t *db) { 3971| 2| isc_result_t result; 3972| 2| dns_rdataset_t rdataset = DNS_RDATASET_INIT; ------------------ | | 249| 2| { \ | | 250| 2| .magic = DNS_RDATASET_MAGIC, \ | | ------------------ | | | | 91| 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)) | | | | ------------------ | | ------------------ | | 251| 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| } | | | | ------------------ | | ------------------ | | 252| 2| } ------------------ 3973| 2| dns_dbnode_t *node = NULL; 3974| 2| dns_dbversion_t *version = NULL; 3975| 2| dns_fixedname_t fixed; 3976| 2| dns_name_t *name = NULL; 3977| | 3978| | /* 3979| | * If this zone isn't logging reports, it's fine. 3980| | */ 3981| 2| if (!DNS_ZONE_OPTION(zone, DNS_ZONEOPT_LOGREPORTS)) { ------------------ | | 182| 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 (3981:6): [True: 2, False: 0] ------------------ 3982| 2| return ISC_R_SUCCESS; 3983| 2| } 3984| | 3985| | /* 3986| | * Otherwise, we need a '*._er' wildcard with a TXT rdataset. 3987| | */ 3988| 0| name = dns_fixedname_initname(&fixed); 3989| 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| } ------------------ 3990| 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| } ------------------ 3991| | 3992| 0| dns_db_currentversion(db, &version); 3993| | 3994| 0| result = dns_db_findrdataset(db, node, version, dns_rdatatype_txt, ------------------ | | 1125| 0| dns__db_findrdataset(db, node, version, type, covers, now, rdataset, \ | | 1126| 0| sigrdataset DNS__DB_FILELINE) ------------------ 3995| 0| dns_rdatatype_none, 0, &rdataset, NULL); 3996| 0| dns_db_closeversion(db, &version, false); ------------------ | | 734| 0| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 3997| 0| dns_db_detachnode(&node); ------------------ | | 1024| 0|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 3998| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (3998:6): [True: 0, False: 0] ------------------ 3999| 0| dns_rdataset_disassociate(&rdataset); ------------------ | | 306| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 4000| 0| } 4001| | 4002| 0|cleanup: 4003| 0| return result; 4004| 0|} zone.c:zone_check_dnskeys: 2689| 2|zone_check_dnskeys(dns_zone_t *zone, dns_db_t *db) { 2690| 2| dns_dbnode_t *node = NULL; 2691| 2| dns_dbversion_t *version = NULL; 2692| 2| dns_rdata_dnskey_t dnskey; 2693| 2| dns_rdataset_t rdataset; 2694| 2| isc_result_t result; 2695| 2| bool logged_algorithm[DST_MAX_ALGS] = { 0 }; 2696| 2| bool alldeprecated = true; 2697| | 2698| 2| CHECK(dns_db_findnode(db, &zone->origin, false, &node)); ------------------ | | 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| } ------------------ 2699| | 2700| 2| dns_db_currentversion(db, &version); 2701| 2| dns_rdataset_init(&rdataset); 2702| 2| CHECK(dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, ------------------ | | 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| } ------------------ 2703| 2| dns_rdatatype_none, 0, &rdataset, NULL)); 2704| | 2705| 0| DNS_RDATASET_FOREACH(&rdataset) { ------------------ | | 267| 0| DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) | | ------------------ | | | | 264| 0| for (isc_result_t res = dns_rdataset_first((rds)); \ | | | | 265| 0| res == ISC_R_SUCCESS; res = dns_rdataset_next((rds))) | | | | ------------------ | | | | | Branch (265:7): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 2706| 0| char algbuf[DNS_SECALG_FORMATSIZE]; 2707| 0| dns_rdata_t rdata = DNS_RDATA_INIT; ------------------ | | 149| 0| { \ | | 150| 0| .data = NULL, \ | | 151| 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| } | | | | ------------------ | | ------------------ | | 152| 0| } ------------------ 2708| 0| dns_rdataset_current(&rdataset, &rdata); 2709| 0| result = dns_rdata_tostruct(&rdata, &dnskey); 2710| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 2711| | 2712| | /* 2713| | * RFC 3110, section 4: Performance Considerations: 2714| | * 2715| | * A public exponent of 3 minimizes the effort needed to verify 2716| | * a signature. Use of 3 as the public exponent is weak for 2717| | * confidentiality uses since, if the same data can be collected 2718| | * encrypted under three different keys with an exponent of 3 2719| | * then, using the Chinese Remainder Theorem [NETSEC], the 2720| | * original plain text can be easily recovered. If a key is 2721| | * known to be used only for authentication, as is the case with 2722| | * DNSSEC, then an exponent of 3 is acceptable. However other 2723| | * applications in the future may wish to leverage DNS 2724| | * distributed keys for applications that do require 2725| | * confidentiality. For keys which might have such other uses, 2726| | * a more conservative choice would be 65537 (F4, the fourth 2727| | * fermat number). 2728| | */ 2729| 0| if (dnskey.datalen > 1 && dnskey.data[0] == 1 && ------------------ | Branch (2729:7): [True: 0, False: 0] | Branch (2729:29): [True: 0, False: 0] ------------------ 2730| 0| dnskey.data[1] == 3 && ------------------ | Branch (2730:7): [True: 0, False: 0] ------------------ 2731| 0| (dnskey.algorithm == DNS_KEYALG_RSAMD5 || ------------------ | Branch (2731:8): [True: 0, False: 0] ------------------ 2732| 0| dnskey.algorithm == DNS_KEYALG_RSASHA1 || ------------------ | Branch (2732:8): [True: 0, False: 0] ------------------ 2733| 0| dnskey.algorithm == DNS_KEYALG_NSEC3RSASHA1 || ------------------ | Branch (2733:8): [True: 0, False: 0] ------------------ 2734| 0| dnskey.algorithm == DNS_KEYALG_RSASHA256 || ------------------ | Branch (2734:8): [True: 0, False: 0] ------------------ 2735| 0| dnskey.algorithm == DNS_KEYALG_RSASHA512)) ------------------ | Branch (2735:8): [True: 0, False: 0] ------------------ 2736| 0| { 2737| 0| char algorithm[DNS_SECALG_FORMATSIZE]; 2738| 0| isc_region_t r; 2739| | 2740| 0| dns_rdata_toregion(&rdata, &r); 2741| 0| dns_secalg_format(dnskey.algorithm, algorithm, 2742| 0| sizeof(algorithm)); 2743| | 2744| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2745| 0| "weak %s (%u) key found (exponent=3, id=%u)", 2746| 0| algorithm, dnskey.algorithm, 2747| 0| dst_region_computeid(&r)); 2748| 0| } 2749| 0| switch (dnskey.algorithm) { 2750| 0| case DNS_KEYALG_RSAMD5: ------------------ | Branch (2750:3): [True: 0, False: 0] ------------------ 2751| 0| case DNS_KEYALG_DSA: ------------------ | Branch (2751:3): [True: 0, False: 0] ------------------ 2752| 0| case DNS_KEYALG_RSASHA1: ------------------ | Branch (2752:3): [True: 0, False: 0] ------------------ 2753| 0| case DNS_KEYALG_NSEC3DSA: ------------------ | Branch (2753:3): [True: 0, False: 0] ------------------ 2754| 0| case DNS_KEYALG_NSEC3RSASHA1: ------------------ | Branch (2754:3): [True: 0, False: 0] ------------------ 2755| 0| case DNS_KEYALG_ECCGOST: ------------------ | Branch (2755:3): [True: 0, False: 0] ------------------ 2756| 0| if (!logged_algorithm[dnskey.algorithm]) { ------------------ | Branch (2756:8): [True: 0, False: 0] ------------------ 2757| 0| dns_secalg_format(dnskey.algorithm, algbuf, 2758| 0| sizeof(algbuf)); 2759| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2760| 0| "deprecated DNSKEY algorithm found: " 2761| 0| "%u (%s)\n", 2762| 0| dnskey.algorithm, algbuf); 2763| 0| logged_algorithm[dnskey.algorithm] = true; 2764| 0| } 2765| 0| break; 2766| 0| default: ------------------ | Branch (2766:3): [True: 0, False: 0] ------------------ 2767| 0| alldeprecated = false; 2768| 0| break; 2769| 0| } 2770| 0| } 2771| 0| dns_rdataset_disassociate(&rdataset); ------------------ | | 306| 0| dns__rdataset_disassociate(rdataset DNS__DB_FILELINE) ------------------ 2772| | 2773| 0| if (alldeprecated) { ------------------ | Branch (2773:6): [True: 0, False: 0] ------------------ 2774| 0| dnssec_log(zone, ISC_LOG_WARNING, ------------------ | | 44| 0|#define ISC_LOG_WARNING (-3) ------------------ 2775| 0| "all DNSKEY algorithms found are deprecated"); 2776| 0| } 2777| | 2778| 2|cleanup: 2779| 2| if (node != NULL) { ------------------ | Branch (2779:6): [True: 2, False: 0] ------------------ 2780| 2| dns_db_detachnode(&node); ------------------ | | 1024| 2|#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE) ------------------ 2781| 2| } 2782| 2| if (version != NULL) { ------------------ | Branch (2782:6): [True: 2, False: 0] ------------------ 2783| 2| dns_db_closeversion(db, &version, false); ------------------ | | 734| 2| dns__db_closeversion(db, versionp, commit DNS__DB_FILELINE) ------------------ 2784| 2| } 2785| 2|} dns__viewname_get: 25| 2|dns__viewname_get(const dns_viewname_t *name) { 26| 2| return name->name; 27| 2|} dns__viewname_display: 30| 4|dns__viewname_display(const dns_viewname_t *name) { 31| 4| if (name->name == default_view || name->name == bind_view) { ------------------ | Branch (31:6): [True: 0, False: 4] | Branch (31:36): [True: 0, False: 4] ------------------ 32| 0| return NULL; 33| 0| } 34| 4| return name->name; 35| 4|} dns__viewname_free: 38| 2|dns__viewname_free(dns_viewname_t *name, isc_mem_t *mctx) { 39| 2| if (dns__viewname_display(name) != NULL) { ------------------ | Branch (39:6): [True: 0, False: 2] ------------------ 40| 0| char *value = (char *)name->name; 41| 0| isc_mem_free(mctx, value); ------------------ | | 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] | | ------------------ ------------------ 42| 0| } 43| | name->name = NULL; 44| 2|} dns__viewname_set: 47| 2|dns__viewname_set(dns_viewname_t *name, isc_mem_t *mctx, const char *value) { 48| 2| REQUIRE(value != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 49| | 50| | /* Reattaching a view of the same name leaves logging storage intact. */ 51| 2| if (name->name != NULL && strcmp(name->name, value) == 0) { ------------------ | Branch (51:6): [True: 0, False: 2] | Branch (51:28): [True: 0, False: 0] ------------------ 52| 0| return; 53| 0| } 54| | 55| 2| const char *replacement = NULL; 56| 2| if (value[0] == '_' && strcmp(value, default_view) == 0) { ------------------ | Branch (56:6): [True: 0, False: 2] | Branch (56:25): [True: 0, False: 0] ------------------ 57| 0| replacement = default_view; 58| 2| } else if (value[0] == '_' && strcmp(value, bind_view) == 0) { ------------------ | Branch (58:13): [True: 0, False: 2] | Branch (58:32): [True: 0, False: 0] ------------------ 59| 0| replacement = bind_view; 60| 2| } else { 61| 2| replacement = isc_mem_strdup(mctx, value); ------------------ | | 167| 2|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 62| 2| } 63| 2| dns__viewname_free(name, mctx); 64| 2| name->name = replacement; 65| 2|} dns_zone_setclass: 49| 2|dns_zone_setclass(dns_zone_t *zone, dns_rdataclass_t rdclass) { 50| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 51| 2| REQUIRE(rdclass != dns_rdataclass_none); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 52| | 53| | /* 54| | * Test and set. 55| | */ 56| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 57| 2| INSIST(zone != zone->raw); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 58| 2| REQUIRE(zone->rdclass == dns_rdataclass_none || ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 59| 2| zone->rdclass == rdclass); 60| 2| zone->rdclass = rdclass; 61| | 62| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (62:6): [True: 0, False: 2] ------------------ 63| 0| dns_zone_setclass(zone->raw, rdclass); 64| 0| } 65| | UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 66| 2|} dns_zone_settype: 109| 2|dns_zone_settype(dns_zone_t *zone, dns_zonetype_t type) { 110| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 111| 2| REQUIRE(type != dns_zone_none); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 112| | 113| | /* 114| | * Test and set. 115| | */ 116| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 117| 2| REQUIRE(zone->type == dns_zone_none || zone->type == type); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 118| 2| zone->type = type; 119| | 120| | UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 121| 2|} dns_zone_setdbtype: 157| 2| const char *const *dbargv) { 158| 2| char **argv = NULL; 159| 2| unsigned int i; 160| | 161| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 162| 2| REQUIRE(dbargc >= 1); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 163| 2| REQUIRE(dbargv != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 164| | 165| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 166| | 167| | /* Set up a new database argument list. */ 168| 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) | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| _c; \ | | | | 37| 2| }) | | ------------------ | | 147| 2| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 2|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 169| 4| for (i = 0; i < dbargc; i++) { ------------------ | Branch (169:14): [True: 2, False: 2] ------------------ 170| 2| argv[i] = NULL; 171| 2| } 172| 4| for (i = 0; i < dbargc; i++) { ------------------ | Branch (172:14): [True: 2, False: 2] ------------------ 173| 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) ------------------ 174| 2| } 175| | 176| | /* Free the old list. */ 177| 2| dns__zone_freedbargs(zone); 178| | 179| 2| zone->db_argc = dbargc; 180| 2| zone->db_argv = argv; 181| | 182| | UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 183| 2|} dns_zone_setview: 186| 2|dns_zone_setview(dns_zone_t *zone, dns_view_t *view) { 187| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 188| | 189| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 190| 2| dns__zone_setview_helper(zone, view); 191| | UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 192| 2|} dns_zone_setorigin: 202| 2|dns_zone_setorigin(dns_zone_t *zone, const dns_name_t *origin) { 203| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 204| 2| REQUIRE(origin != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 205| | 206| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 207| 2| INSIST(zone != zone->raw); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 208| 2| if (dns_name_dynamic(&zone->origin)) { ------------------ | | 1553| 2|#define dns_name_dynamic(name) dns_name__dynamic(DNS_NAME__RO_ARG(name)) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ | | | Branch (1553:32): [True: 0, False: 2] | | ------------------ ------------------ 209| 0| dns_name_free(&zone->origin, zone->mctx); 210| 0| dns_name_init(&zone->origin); 211| 0| } 212| 2| dns_name_dup(origin, zone->mctx, &zone->origin); ------------------ | | 1522| 2| dns_name__dup(DNS_NAME__RO_ARG(source), mctx, target) | | ------------------ | | | | 1507| 2| _Generic((arg), \ | | | | 1508| 2| dns_name_t *: dns_name__readonly_arg, \ | | | | 1509| 2| const dns_name_t *: dns_name__readonly_arg, \ | | | | 1510| 2| dns_linkedname_t *: dns_linkedname_name, \ | | | | 1511| 2| const dns_linkedname_t *: dns_linkedname_name_const, \ | | | | 1512| 2| dns_fixedname_t *: dns_fixedname_name, \ | | | | 1513| 2| const dns_fixedname_t *: dns_fixedname_name_const)(arg) | | ------------------ ------------------ 213| | 214| 2| if (dns__zone_inline_secure(zone)) { ------------------ | Branch (214:6): [True: 0, False: 2] ------------------ 215| 0| dns_zone_setorigin(zone->raw, origin); 216| 0| } 217| | UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 218| 2|} dns_zone_expandzonefile: 400| 2| const char *typename) { 401| 2| isc_result_t result; 402| 2| foundtoken_t founds[ARRAY_SIZE(tokens)]; 403| 2| dns_fixedname_t fz; 404| 2| size_t tags = 0; 405| 2| token_names_t names = { .zonename = dns_fixedname_initname(&fz), 406| 2| .viewname = viewname, 407| 2| .typename = typename }; 408| | 409| 2| REQUIRE(zonename != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 410| 2| REQUIRE(filename != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 411| 2| REQUIRE(typename != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 412| | 413| 2| if (viewname == NULL) { ------------------ | Branch (413:6): [True: 2, False: 0] ------------------ 414| 2| names.viewname = ""; 415| 2| } 416| | 417| 2| if (strpbrk(filename, "$%") == NULL) { ------------------ | Branch (417:6): [True: 2, False: 0] ------------------ 418| 2| putmem(b, filename, strlen(filename)); 419| 2| isc_buffer_putuint8(b, 0); 420| 2| return; 421| 2| } 422| | 423| | /* Normalize the name by converting to lower case */ 424| 0| result = dns_name_downcase(zonename, names.zonename); 425| 0| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 426| | 427| 0| for (size_t i = 0; i < ARRAY_SIZE(tokens); i++) { ------------------ | | 98| 0|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (427:21): [True: 0, False: 0] ------------------ 428| 0| const token_t *token = &tokens[i]; 429| 0| const char *p = strcasestr(filename, token->name); 430| | 431| 0| if (p != NULL) { ------------------ | Branch (431:7): [True: 0, False: 0] ------------------ 432| 0| founds[tags++] = 433| 0| (foundtoken_t){ .pos = p, 434| 0| .len = strlen(token->name), 435| 0| .parse = token->parse }; 436| 0| } 437| 0| } 438| | 439| 0| if (tags == 0) { ------------------ | Branch (439:6): [True: 0, False: 0] ------------------ 440| 0| putmem(b, filename, strlen(filename)); 441| 0| goto cleanup; 442| 0| } 443| | 444| | /* sort the tag offsets in order of occurrence */ 445| 0| qsort(founds, tags, sizeof(foundtoken_t), foundtoken_order); 446| | 447| 0| const char *p = filename; 448| 0| for (size_t i = 0; i < tags; i++) { ------------------ | Branch (448:21): [True: 0, False: 0] ------------------ 449| 0| foundtoken_t *token = &founds[i]; 450| | 451| 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| } ------------------ 452| | 453| 0| p = token->pos; 454| 0| INSIST(p != NULL); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 455| 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| } ------------------ 456| | 457| | /* Advance the input pointer past the token */ 458| 0| p += founds[i].len; 459| 0| } 460| | 461| 0| const char *end = filename + strlen(filename); 462| 0| putmem(b, p, end - p); 463| | 464| 0|cleanup: 465| 0| isc_buffer_putuint8(b, 0); 466| 0|} dns_zone_setfile: 487| 2| dns_masterformat_t format, const dns_master_style_t *style) { 488| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 489| 2| REQUIRE(zone->stream == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 490| | 491| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 492| 2| setfilename(zone, &zone->masterfile, file); 493| 2| setstring(zone, &zone->initfile, initial_file); 494| 2| zone->masterformat = format; 495| 2| if (format == dns_masterformat_text) { ------------------ | Branch (495:6): [True: 2, False: 0] ------------------ 496| 2| zone->masterstyle = style; 497| 2| } 498| 2| default_journal(zone); 499| | UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 500| 2|} dns_zone_getdb: 889| 208|dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) { 890| 208| isc_result_t result = ISC_R_SUCCESS; 891| | 892| 208| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 893| | 894| 208| ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read); ------------------ | | 120| 208|#define ZONEDB_LOCK(l, t) RWLOCK((l), (t)) | | ------------------ | | | | 30| 208| { \ | | | | 31| 208| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCK %p, %d %s %d\n", (lp), \ | | | | 32| 208| (t), __FILE__, __LINE__)); \ | | | | 33| 208| isc_rwlock_lock((lp), (t)); \ | | | | ------------------ | | | | | | 252| 208| { \ | | | | | | 253| 208| switch (type) { \ | | | | | | 254| 208| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (254:3): [True: 208, False: 0] | | | | | | ------------------ | | | | | | 255| 208| isc_rwlock_rdlock(rwl); \ | | | | | | 256| 208| break; \ | | | | | | 257| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (257:3): [True: 0, False: 208] | | | | | | ------------------ | | | | | | 258| 0| isc_rwlock_wrlock(rwl); \ | | | | | | 259| 0| break; \ | | | | | | 260| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (260:3): [True: 0, False: 208] | | | | | | ------------------ | | | | | | 261| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 262| 208| } \ | | | | | | 263| 208| } | | | | ------------------ | | | | 34| 208| ISC_UTIL_TRACE(fprintf(stderr, "RWLOCKED %p, %d %s %d\n", \ | | | | 35| 208| (lp), (t), __FILE__, __LINE__)); \ | | | | 36| 208| } | | ------------------ ------------------ 895| 208| if (zone->db == NULL) { ------------------ | Branch (895:6): [True: 0, False: 208] ------------------ 896| 0| result = DNS_R_NOTLOADED; 897| 208| } else { 898| 208| dns_db_attach(zone->db, dpb); 899| 208| } 900| 208| ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read); ------------------ | | 121| 208|#define ZONEDB_UNLOCK(l, t) RWUNLOCK((l), (t)) | | ------------------ | | | | 38| 208| { \ | | | | 39| 208| ISC_UTIL_TRACE(fprintf(stderr, "RWUNLOCK %p, %d %s %d\n", \ | | | | 40| 208| (lp), (t), __FILE__, __LINE__)); \ | | | | 41| 208| isc_rwlock_unlock((lp), (t)); \ | | | | ------------------ | | | | | | 282| 208| { \ | | | | | | 283| 208| switch (type) { \ | | | | | | 284| 208| case isc_rwlocktype_read: \ | | | | | | ------------------ | | | | | | | Branch (284:3): [True: 208, False: 0] | | | | | | ------------------ | | | | | | 285| 208| isc_rwlock_rdunlock(rwl); \ | | | | | | 286| 208| break; \ | | | | | | 287| 0| case isc_rwlocktype_write: \ | | | | | | ------------------ | | | | | | | Branch (287:3): [True: 0, False: 208] | | | | | | ------------------ | | | | | | 288| 0| isc_rwlock_wrunlock(rwl); \ | | | | | | 289| 0| break; \ | | | | | | 290| 0| default: \ | | | | | | ------------------ | | | | | | | Branch (290:3): [True: 0, False: 208] | | | | | | ------------------ | | | | | | 291| 0| UNREACHABLE(); \ | | | | | | ------------------ | | | | | | | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | | | | | | | ------------------ | | | | | | | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | | | | | | | 66| 0| "unreachable"), \ | | | | | | | | | | 67| 0| __builtin_unreachable()) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 292| 208| } \ | | | | | | 293| 208| } | | | | ------------------ | | | | 42| 208| } | | ------------------ ------------------ 901| | 902| 208| return result; 903| 208|} dns_zone_gettype: 1391| 624|dns_zone_gettype(dns_zone_t *zone) { 1392| 624| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 624|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 624, False: 0] | | | | | Branch (41:11): [True: 624, False: 0] | | | | ------------------ | | | | 42| 624| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1393| | 1394| 624| return zone->type; 1395| 624|} dns_zone_getorigin: 1398| 391|dns_zone_getorigin(dns_zone_t *zone) { 1399| 391| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 391|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 782| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 391, False: 0] | | | | | Branch (41:11): [True: 391, False: 0] | | | | ------------------ | | | | 42| 391| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1400| | 1401| 391| return &zone->origin; 1402| 391|} dns_zone_setkeydirectory: 1642| 2|dns_zone_setkeydirectory(dns_zone_t *zone, const char *directory) { 1643| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1644| | 1645| 2| LOCK_ZONE(zone); ------------------ | | 88| 2| do { \ | | 89| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 90| 2| INSIST(!(z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 91| 2| (z)->locked = true; \ | | 92| 2| } while (0) | | ------------------ | | | Branch (92:11): [Folded, False: 2] | | ------------------ ------------------ 1646| 2| setstring(zone, &zone->keydirectory, directory); 1647| | UNLOCK_ZONE(zone); ------------------ | | 94| 2| do { \ | | 95| 2| INSIST((z)->locked); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 96| 2| (z)->locked = false; \ | | 97| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ | | 98| 2| } while (0) | | ------------------ | | | Branch (98:11): [Folded, False: 2] | | ------------------ ------------------ 1648| 2|} zoneproperties.c:putmem: 262| 2|putmem(isc_buffer_t *b, const char *base, size_t length) { 263| 2| size_t space = isc_buffer_availablelength(b) - 1; ------------------ | | 162| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 264| 2| if (space < length) { ------------------ | Branch (264:6): [True: 0, False: 2] ------------------ 265| 0| isc_buffer_putmem(b, (const unsigned char *)base, space); 266| 0| return ISC_R_NOSPACE; 267| 0| } 268| | 269| 2| isc_buffer_putmem(b, (const unsigned char *)base, length); 270| 2| return ISC_R_SUCCESS; 271| 2|} zoneproperties.c:setfilename: 469| 2|setfilename(dns_zone_t *zone, char **field, const char *value) { 470| 2| char filename[PATH_MAX]; 471| 2| isc_buffer_t b; 472| | 473| 2| if (value == NULL) { ------------------ | Branch (473:6): [True: 0, False: 2] ------------------ 474| 0| *field = NULL; 475| 0| return; 476| 0| } 477| | 478| 2| isc_buffer_init(&b, filename, sizeof(filename)); 479| 2| dns_zone_expandzonefile(&b, value, &zone->origin, 480| 2| dns__viewname_get(&zone->viewname), 481| 2| dns_zonetype_name(zone->type)); 482| 2| setstring(zone, field, filename); 483| 2|} zoneproperties.c:setstring: 221| 8|setstring(dns_zone_t *zone, char **field, const char *value) { 222| 8| char *copy; 223| | 224| 8| if (value != NULL) { ------------------ | Branch (224:6): [True: 6, False: 2] ------------------ 225| 6| copy = isc_mem_strdup(zone->mctx, value); ------------------ | | 167| 6|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 226| 6| } else { 227| 2| copy = NULL; 228| 2| } 229| | 230| 8| if (*field != NULL) { ------------------ | Branch (230:6): [True: 0, False: 8] ------------------ 231| 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] | | ------------------ ------------------ 232| 0| } 233| | 234| 8| *field = copy; 235| 8|} zoneproperties.c:default_journal: 550| 2|default_journal(dns_zone_t *zone) { 551| 2| char *journal; 552| | 553| 2| REQUIRE(DNS_ZONE_VALID(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 554| 2| REQUIRE(LOCKED_ZONE(zone)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 555| | 556| 2| if (zone->masterfile != NULL) { ------------------ | Branch (556:6): [True: 2, False: 0] ------------------ 557| | /* Calculate string length including '\0'. */ 558| 2| int len = strlen(zone->masterfile) + sizeof(".jnl"); 559| 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) ------------------ 560| 2| strlcpy(journal, zone->masterfile, len); 561| 2| strlcat(journal, ".jnl", len); 562| 2| } else { 563| 0| journal = NULL; 564| 0| } 565| 2| setstring(zone, &zone->journal, journal); 566| 2| if (journal != NULL) { ------------------ | Branch (566:6): [True: 2, False: 0] ------------------ 567| | 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] | | ------------------ ------------------ 568| 2| } 569| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 103| 2| REQUIRE(view != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 389| dns_zone_t **zonep) { 171| 389| isc_result_t result; 172| 389| dns_qpread_t qpr; 173| 389| void *pval = NULL; 174| 389| dns_ztfind_t exactmask = DNS_ZTFIND_NOEXACT | DNS_ZTFIND_EXACT; 175| 389| dns_ztfind_t exactopts = options & exactmask; 176| 389| dns_qpchain_t chain; 177| | 178| 389| REQUIRE(VALID_ZT(zt)); ------------------ | | 198| 389|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 778| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 389, False: 0] | | | | | Branch (41:11): [True: 389, False: 0] | | | | ------------------ | | | | 42| 389| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 179| 389| REQUIRE(exactopts != exactmask); ------------------ | | 198| 389|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 389| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 389, False: 0] | | | | ------------------ | | | | 42| 389| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 180| | 181| 389| dns_qpmulti_query(zt->multi, &qpr); 182| | 183| 389| if (exactopts == DNS_ZTFIND_EXACT) { ------------------ | Branch (183:6): [True: 0, False: 389] ------------------ 184| 0| result = dns_qp_getname(&qpr, name, DNS_DBNAMESPACE_NORMAL, 185| 0| &pval, NULL); 186| 389| } else { 187| 389| result = dns_qp_lookup(&qpr, name, DNS_DBNAMESPACE_NORMAL, NULL, 188| 389| &chain, &pval, NULL); 189| 389| if (exactopts == DNS_ZTFIND_NOEXACT && result == ISC_R_SUCCESS) ------------------ | Branch (189:7): [True: 0, False: 389] | 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| 389| } 201| | 202| | /* Keep the zone protected through the checks and attachment. */ 203| 389| if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) { ------------------ | Branch (203:6): [True: 117, False: 272] | Branch (203:33): [True: 91, False: 181] ------------------ 204| 208| 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| 208| if ((options & DNS_ZTFIND_MIRROR) != 0 && ------------------ | Branch (222:7): [True: 208, False: 0] ------------------ 223| 208| dns_zone_gettype(zone) == dns_zone_mirror && ------------------ | Branch (223:7): [True: 0, False: 208] ------------------ 224| 0| !dns_zone_isloaded(zone)) ------------------ | Branch (224:7): [True: 0, False: 0] ------------------ 225| 0| { 226| 0| result = ISC_R_NOTFOUND; 227| 208| } else { 228| 208| dns_zone_attach(zone, zonep); 229| 208| } 230| 208| } 231| 389| dns_qpread_destroy(zt->multi, &qpr); 232| | 233| 389| return result; 234| 389|} 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| 391| uint32_t ival ISC_ATTR_UNUSED) { 79| 391| dns_zone_t *zone = pval; 80| 391| dns_name_t *name = dns_zone_getorigin(zone); 81| 391| return dns_qpkey_fromname(key, name, DNS_DBNAMESPACE_NORMAL); 82| 391|} 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 183| | 184| 2| base64_decode_init(&ctx, length, target); 185| | 186| 2| before = isc_buffer_usedlength(target); ------------------ | | 158| 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); ------------------ | | 158| 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: 252| 12| unsigned int *digestlen) { 253| 12| EVP_MAC_CTX *ctx; 254| 12| size_t maclen; 255| | 256| 12| REQUIRE(type < ISC_MD_MAX); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 257| | 258| 12| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (258:6): [True: 0, False: 12] ------------------ 259| 0| return ISC_R_NOTIMPLEMENTED; 260| 0| } 261| | 262| 12| ctx = EVP_MAC_CTX_new(evp_hmac); 263| 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] | | ------------------ ------------------ 264| | 265| 12| if (EVP_MAC_init(ctx, key, keylen, md_to_hmac_params[type]) != 1) { ------------------ | Branch (265:6): [True: 0, False: 12] ------------------ 266| 0| goto fail; 267| 0| } 268| | 269| 12| if (EVP_MAC_update(ctx, buf, len) != 1) { ------------------ | Branch (269:6): [True: 0, False: 12] ------------------ 270| 0| goto fail; 271| 0| } 272| | 273| 12| maclen = *digestlen; 274| 12| if (EVP_MAC_final(ctx, digest, &maclen, maclen) != 1) { ------------------ | Branch (274:6): [True: 0, False: 12] ------------------ 275| 0| goto fail; 276| 0| } 277| | 278| 12| *digestlen = maclen; 279| | 280| 12| EVP_MAC_CTX_free(ctx); 281| 12| return ISC_R_SUCCESS; 282| | 283| 0|fail: 284| 0| ERR_clear_error(); 285| 0| EVP_MAC_CTX_free(ctx); 286| 0| return ISC_R_CRYPTOFAILURE; 287| 12|} isc_hmac_key_create: 296| 2| isc_mem_t *mctx, isc_hmac_key_t **keyp) { 297| 2| isc_hmac_key_t *key; 298| 2| uint8_t digest[ISC_MAX_MD_SIZE]; 299| 2| unsigned int digest_len = sizeof(digest); 300| 2| size_t key_len; 301| | 302| 2| REQUIRE(keyp != NULL && *keyp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 303| 2| REQUIRE(type < ISC_MD_MAX); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 304| | 305| 2| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (305:6): [True: 0, False: 2] ------------------ 306| 0| return ISC_R_NOTIMPLEMENTED; 307| 0| } 308| | 309| 2| if (len > (size_t)EVP_MD_block_size(isc__crypto_md[type])) { ------------------ | Branch (309:6): [True: 0, False: 2] ------------------ 310| 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| } ------------------ 311| 0| secret = digest; 312| 0| key_len = digest_len; 313| 2| } else { 314| 2| key_len = len; 315| 2| } 316| | 317| 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) ------------------ 318| 2| *key = (isc_hmac_key_t){ 319| 2| .magic = hmac_key_magic, 320| 2| .len = key_len, 321| 2| .params = md_to_hmac_params[type], 322| 2| }; 323| 2| memmove(key->secret, secret, key_len); 324| 2| isc_mem_attach(mctx, &key->mctx); 325| | 326| 2| *keyp = key; 327| | 328| 2| return ISC_R_SUCCESS; 329| 2|} isc_hmac_key_expose: 349| 4|isc_hmac_key_expose(isc_hmac_key_t *key) { 350| 4| REQUIRE(key != NULL && key->magic == hmac_key_magic); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 351| | 352| 4| return (isc_region_t){ .base = key->secret, .length = key->len }; 353| 4|} isc_hmac_new: 372| 29|isc_hmac_new(void) { 373| 29| EVP_MAC_CTX *ctx = EVP_MAC_CTX_new(evp_hmac); 374| 29| RUNTIME_CHECK(ctx != NULL); ------------------ | | 245| 29| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 29, False: 0] | | ------------------ ------------------ 375| 29| return ctx; 376| 29|} isc_hmac_free: 379| 29|isc_hmac_free(isc_hmac_t *hmac) { 380| 29| EVP_MAC_CTX_free(hmac); 381| 29|} isc_hmac_init: 384| 29|isc_hmac_init(isc_hmac_t *hmac, isc_hmac_key_t *key) { 385| 29| REQUIRE(key != NULL && key->magic == hmac_key_magic); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 58| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 29, False: 0] | | | | | Branch (41:11): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 386| 29| REQUIRE(hmac != NULL); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 29| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 387| | 388| 29| if (EVP_MAC_init(hmac, key->secret, key->len, key->params) != 1) { ------------------ | Branch (388:6): [True: 0, False: 29] ------------------ 389| 0| ERR_clear_error(); 390| 0| return ISC_R_CRYPTOFAILURE; 391| 0| } 392| | 393| 29| return ISC_R_SUCCESS; 394| 29|} isc_hmac_update: 397| 209|isc_hmac_update(isc_hmac_t *hmac, const unsigned char *buf, const size_t len) { 398| 209| REQUIRE(hmac != NULL); ------------------ | | 198| 209|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 209| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 209, False: 0] | | | | ------------------ | | | | 42| 209| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 399| | 400| 209| if (buf == NULL || len == 0) { ------------------ | Branch (400:6): [True: 0, False: 209] | Branch (400:21): [True: 0, False: 209] ------------------ 401| 0| return ISC_R_SUCCESS; 402| 0| } 403| | 404| 209| if (EVP_MAC_update(hmac, buf, len) != 1) { ------------------ | Branch (404:6): [True: 0, False: 209] ------------------ 405| 0| ERR_clear_error(); 406| 0| return ISC_R_CRYPTOFAILURE; 407| 0| } 408| | 409| 209| return ISC_R_SUCCESS; 410| 209|} isc_hmac_final: 413| 29|isc_hmac_final(isc_hmac_t *hmac, isc_buffer_t *out) { 414| 29| size_t len; 415| | 416| 29| REQUIRE(hmac != NULL); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 29| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 417| | 418| 29| len = isc_buffer_availablelength(out); ------------------ | | 162| 29|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 419| 29| if (len < EVP_MAC_CTX_get_mac_size(hmac)) { ------------------ | Branch (419:6): [True: 0, False: 29] ------------------ 420| 0| return ISC_R_NOSPACE; 421| 0| } 422| | 423| 29| if (EVP_MAC_final(hmac, isc_buffer_used(out), &len, len) != 1) { ------------------ | | 150| 29| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ | Branch (423:6): [True: 0, False: 29] ------------------ 424| 0| ERR_clear_error(); 425| 0| return ISC_R_CRYPTOFAILURE; 426| 0| } 427| | 428| 29| isc_buffer_add(out, len); 429| | 430| 29| return ISC_R_SUCCESS; 431| 29|} isc_crypto_fips_mode: 921| 2|isc_crypto_fips_mode(void) { 922| | return EVP_default_properties_is_fips_enabled(NULL) != 0; 923| 2|} isc__crypto_initialize: 975| 2|isc__crypto_initialize(void) { 976| | /* 977| | * We call OPENSSL_cleanup() manually, in a correct order, thus disable 978| | * the automatic atexit() handler. 979| | */ 980| 2| uint64_t opts = OPENSSL_INIT_LOAD_CONFIG | OPENSSL_INIT_NO_ATEXIT; 981| | 982| 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] | | ------------------ ------------------ 983| | 984| 2| register_algorithms(); 985| | 986| |#if defined(ENABLE_FIPS_MODE) 987| | if (isc_crypto_fips_enable() != ISC_R_SUCCESS) { 988| | ERR_clear_error(); 989| | FATAL_ERROR("Failed to toggle FIPS mode but is " 990| | "required for this build"); 991| | } 992| |#endif 993| | 994| | /* Protect ourselves against unseeded PRNG */ 995| 2| if (RAND_status() != 1) { ------------------ | Branch (995:6): [True: 0, False: 2] ------------------ 996| 0| isc_ossl_wrap_logged_toresult( ------------------ | | 26| 0| isc__ossl_wrap_logged_toresult(category, module, funcname, fallback, \ | | 27| 0| __FILE__, __LINE__) ------------------ 997| 0| ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_CRYPTO, 998| 0| "RAND_status", ISC_R_CRYPTOFAILURE); 999| 0| FATAL_ERROR("OpenSSL pseudorandom number generator " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1000| 0| "cannot be initialized (see the `PRNG not " 1001| 0| "seeded' message in the OpenSSL FAQ)"); 1002| 0| } 1003| 2|} ossl3.c:register_algorithms: 138| 2|register_algorithms(void) { 139| 2| if (!isc_crypto_fips_mode()) { ------------------ | Branch (139:6): [True: 2, False: 0] ------------------ 140| 2| md_register_algorithm(MD5); ------------------ | | 129| 2| { \ | | 130| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 131| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 132| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (132:7): [True: 0, False: 2] | | ------------------ | | 133| 0| ERR_clear_error(); \ | | 134| 0| } \ | | 135| 2| } ------------------ 141| | 142| 2| INSIST(evp_chacha20poly1305 == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 143| 2| evp_chacha20poly1305 = 144| 2| EVP_CIPHER_fetch(NULL, "ChaCha20-Poly1305", NULL); 145| | 146| 2| INSIST(evp_chacha20 == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 147| 2| evp_chacha20 = EVP_CIPHER_fetch(NULL, "ChaCha20", NULL); 148| 2| } 149| | 150| 2| md_register_algorithm(SHA1); ------------------ | | 129| 2| { \ | | 130| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 131| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 132| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (132:7): [True: 0, False: 2] | | ------------------ | | 133| 0| ERR_clear_error(); \ | | 134| 0| } \ | | 135| 2| } ------------------ 151| 2| md_register_algorithm(SHA224); ------------------ | | 129| 2| { \ | | 130| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 131| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 132| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (132:7): [True: 0, False: 2] | | ------------------ | | 133| 0| ERR_clear_error(); \ | | 134| 0| } \ | | 135| 2| } ------------------ 152| 2| md_register_algorithm(SHA256); ------------------ | | 129| 2| { \ | | 130| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 131| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 132| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (132:7): [True: 0, False: 2] | | ------------------ | | 133| 0| ERR_clear_error(); \ | | 134| 0| } \ | | 135| 2| } ------------------ 153| 2| md_register_algorithm(SHA384); ------------------ | | 129| 2| { \ | | 130| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 131| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 132| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (132:7): [True: 0, False: 2] | | ------------------ | | 133| 0| ERR_clear_error(); \ | | 134| 0| } \ | | 135| 2| } ------------------ 154| 2| md_register_algorithm(SHA512); ------------------ | | 129| 2| { \ | | 130| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 131| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 132| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (132:7): [True: 0, False: 2] | | ------------------ | | 133| 0| ERR_clear_error(); \ | | 134| 0| } \ | | 135| 2| } ------------------ 155| | 156| 2| INSIST(evp_aes_128_gcm == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 157| 2| evp_aes_128_gcm = EVP_CIPHER_fetch(NULL, "AES-128-GCM", NULL); 158| | 159| 2| INSIST(evp_aes_256_gcm == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 160| 2| evp_aes_256_gcm = EVP_CIPHER_fetch(NULL, "AES-256-GCM", NULL); 161| | 162| 2| INSIST(evp_aes_128_ctr == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 163| 2| evp_aes_128_ctr = EVP_CIPHER_fetch(NULL, "AES-128-CTR", NULL); 164| | 165| 2| INSIST(evp_aes_256_ctr == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 166| 2| evp_aes_256_ctr = EVP_CIPHER_fetch(NULL, "AES-256-CTR", NULL); 167| | 168| | /* We _must_ have HMAC */ 169| 2| evp_hmac = EVP_MAC_fetch(NULL, "HMAC", NULL); 170| 2| if (evp_hmac == NULL) { ------------------ | Branch (170:6): [True: 0, False: 2] ------------------ 171| 0| FATAL_ERROR("OpenSSL failed to find an HMAC implementation. " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 172| 0| "Please make sure the default provider has an " 173| 0| "EVP_MAC-HMAC implementation"); 174| 0| } 175| | 176| 2| evp_tls_1_3_kdf = EVP_KDF_fetch(NULL, OSSL_KDF_NAME_TLS1_3_KDF, NULL); 177| 2| if (evp_tls_1_3_kdf == NULL) { ------------------ | Branch (177:6): [True: 0, False: 2] ------------------ 178| 0| FATAL_ERROR( ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 179| 0| "OpenSSL failed to find an TLS 1.3 KDF implementation." 180| 0| "Please make sure the default provider has an " 181| 0| "EVP_KDF-TLS13_KDF implementation"); 182| 0| } 183| | 184| 2| evp_hkdf = EVP_KDF_fetch(NULL, OSSL_KDF_NAME_HKDF, NULL); 185| 2| if (evp_hkdf == NULL) { ------------------ | Branch (185:6): [True: 0, False: 2] ------------------ 186| 0| FATAL_ERROR("OpenSSL failed to find an HKDF implementation. " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 187| 0| "Please make sure the default provider has an " 188| 0| "EVP_KDF-HKDF implementation"); 189| 0| } 190| | 191| 2| ERR_clear_error(); 192| | 193| 2| return ISC_R_SUCCESS; 194| 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: 155| 2|isc_file_getmodtime(const char *file, isc_time_t *modtime) { 156| 2| isc_result_t result; 157| 2| struct stat stats; 158| | 159| 2| REQUIRE(file != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 160| 2| REQUIRE(modtime != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 161| | 162| 2| result = file_stats(file, &stats); 163| | 164| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (164:6): [True: 2, False: 0] ------------------ 165| 2|#if defined(HAVE_STAT_NSEC) 166| 2| isc_time_set(modtime, stats.st_mtime, stats.st_mtim.tv_nsec); 167| |#else /* if defined(HAVE_STAT_NSEC) */ 168| | isc_time_set(modtime, stats.st_mtime, 0); 169| |#endif /* if defined(HAVE_STAT_NSEC) */ 170| 2| } 171| | 172| 2| return result; 173| 2|} isc_file_exists: 431| 6|isc_file_exists(const char *pathname) { 432| 6| struct stat stats; 433| | 434| 6| REQUIRE(pathname != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 435| | 436| 6| return file_stats(pathname, &stats) == ISC_R_SUCCESS; 437| 6|} isc_file_sanitize: 721| 2| char *path, size_t length) { 722| 2| REQUIRE(base != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 723| 2| REQUIRE(path != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 724| | 725| 2| isc_result_t result = ISC_R_SUCCESS; 726| 2| char *buf = NULL; 727| 2| unsigned char digest[ISC_MAX_MD_SIZE]; 728| 2| char hash[ISC_MAX_MD_SIZE * 2 + 1]; 729| 2| isc_buffer_t b, h; 730| 2| isc_region_t r = { .base = digest }; 731| | 732| | /* Calculate the full-length SHA256 hash first */ 733| 2| isc_buffer_init(&h, hash, sizeof(hash)); 734| 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| } ------------------ 735| 2| r.base, &r.length)); 736| 2| RETERR(isc_hex_totextlower(&r, 0, "", &h)); ------------------ | | 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| } ------------------ 737| 2| INSIST(isc_buffer_availablelength(&h) > 0); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 738| 2| isc_buffer_putuint8(&h, '\0'); 739| | 740| | /* Check whether the full-length SHA256 hash filename exists */ 741| 2| isc_buffer_initnull(&b); 742| 2| isc_buffer_setmctx(&b, isc_g_mctx); 743| | 744| 2| CHECK(path_join(&b, dir, hash, ext, length)); ------------------ | | 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| } ------------------ 745| | 746| 2| buf = isc_buffer_base(&b); ------------------ | | 144| 2|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 747| 2| if (isc_file_exists(buf)) { ------------------ | Branch (747:6): [True: 0, False: 2] ------------------ 748| 0| strlcpy(path, buf, length); 749| 0| goto cleanup; 750| 0| } 751| | 752| | /* Check for a truncated SHA256 hash filename */ 753| 2| hash[16] = '\0'; 754| 2| CHECK(path_join(&b, dir, hash, ext, length)); ------------------ | | 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| } ------------------ 755| | 756| 2| buf = isc_buffer_base(&b); ------------------ | | 144| 2|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 757| 2| if (isc_file_exists(buf)) { ------------------ | Branch (757:6): [True: 0, False: 2] ------------------ 758| 0| strlcpy(path, buf, length); 759| 0| goto cleanup; 760| 0| } 761| | 762| | /* 763| | * If neither hash filename already exists, then we'll use 764| | * the original base name if it has no disallowed characters, 765| | * or the truncated hash name if it does. 766| | */ 767| 2| if (strpbrk(base, DISALLOW) != NULL) { ------------------ | | 691| 2|#define DISALLOW "\\/ABCDEFGHIJKLMNOPQRSTUVWXYZ" ------------------ | Branch (767:6): [True: 0, False: 2] ------------------ 768| 0| strlcpy(path, buf, length); 769| 0| goto cleanup; 770| 0| } 771| | 772| 2| CHECK(path_join(&b, dir, base, ext, length)); ------------------ | | 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| } ------------------ 773| | 774| 2| buf = isc_buffer_base(&b); ------------------ | | 144| 2|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 775| 2| strlcpy(path, buf, length); 776| | 777| 2|cleanup: 778| 2| isc_buffer_clearmctx(&b); 779| 2| return result; 780| 2|} file.c:file_stats: 83| 8|file_stats(const char *file, struct stat *stats) { 84| 8| isc_result_t result = ISC_R_SUCCESS; 85| | 86| 8| REQUIRE(file != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 87| 8| REQUIRE(stats != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 88| | 89| 8| if (stat(file, stats) != 0) { ------------------ | Branch (89:6): [True: 4, False: 4] ------------------ 90| 4| result = isc__errno2result(errno); ------------------ | | 25| 4|#define isc__errno2result(x) isc___errno2result(x, true, __FILE__, __LINE__) ------------------ 91| 4| } 92| | 93| 8| return result; 94| 8|} file.c:path_join: 695| 6| size_t length) { 696| 6| isc_buffer_clear(b); 697| | 698| 6| if (dir != NULL) { ------------------ | Branch (698:6): [True: 0, False: 6] ------------------ 699| 0| isc_buffer_putstr(b, dir); 700| 0| isc_buffer_putuint8(b, '/'); 701| 0| } 702| | 703| 6| isc_buffer_putstr(b, base); 704| | 705| 6| if (ext != NULL) { ------------------ | Branch (705:6): [True: 6, False: 0] ------------------ 706| 6| isc_buffer_putuint8(b, '.'); 707| 6| isc_buffer_putstr(b, ext); 708| 6| } 709| | 710| 6| isc_buffer_putuint8(b, '\0'); 711| | 712| 6| if (isc_buffer_usedlength(b) > length) { ------------------ | | 158| 6|#define isc_buffer_usedlength(b) ((b)->used) /* d-a */ ------------------ | Branch (712:6): [True: 0, False: 6] ------------------ 713| 0| return ISC_R_NOSPACE; 714| 0| } 715| | 716| 6| return ISC_R_SUCCESS; 717| 6|} 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| 590|isc_hash32_init(isc_hash32_t *restrict state) { 58| 590| isc_halfsiphash13_init(state, isc_hash_key); 59| 590|} isc_hash32_hash: 63| 590| const size_t length, const bool case_sensitive) { 64| 590| REQUIRE(length == 0 || data != NULL); ------------------ | | 198| 590|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 590] | | | | | Branch (41:11): [True: 590, False: 0] | | | | ------------------ | | | | 42| 590| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 65| | 66| 590| isc_halfsiphash13_hash(state, data, length, case_sensitive); 67| 590|} isc_hash32_finalize: 70| 590|isc_hash32_finalize(isc_hash32_t *restrict state) { 71| 590| uint32_t hval; 72| | 73| 590| isc_halfsiphash13_finalize(state, (uint8_t *)&hval); 74| | 75| 590| return hval; 76| 590|} 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) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 213| 8| REQUIRE(mctx != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 214| 8| REQUIRE(bits >= HASHMAP_MIN_BITS && bits <= HASHMAP_MAX_BITS); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 588| isc_hashmap_match_fn match, const void *key, void **valuep) { 295| 588| REQUIRE(ISC_HASHMAP_VALID(hashmap)); ------------------ | | 198| 588|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 588, False: 0] | | | | | Branch (41:11): [True: 588, False: 0] | | | | ------------------ | | | | 42| 588| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 296| 588| REQUIRE(valuep == NULL || *valuep == NULL); ------------------ | | 198| 588|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.17k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 588] | | | | | Branch (41:11): [True: 588, False: 0] | | | | ------------------ | | | | 42| 588| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 297| | 298| 588| uint8_t idx = hashmap->hindex; 299| 588| hashmap_node_t *node = hashmap_find(hashmap, hashval, match, key, 300| 588| &(uint32_t){ 0 }, &idx); 301| 588| if (node == NULL) { ------------------ | Branch (301:6): [True: 333, False: 255] ------------------ 302| 333| return ISC_R_NOTFOUND; 303| 333| } 304| | 305| 255| INSIST(node->key != NULL); ------------------ | | 202| 255|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 255| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 255, False: 0] | | | | ------------------ | | | | 54| 255| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 306| | SET_IF_NOT_NULL(valuep, node->value); ------------------ | | 104| 255| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 255, False: 0] | | ------------------ | | 105| 255| *(obj) = (val); \ | | 106| 255| } ------------------ 307| 255| return ISC_R_SUCCESS; 308| 588|} isc_hashmap_add: 568| 2| void **foundp) { 569| 2| REQUIRE(ISC_HASHMAP_VALID(hashmap)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 570| 2| REQUIRE(key != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 170| 8| REQUIRE(hashmap->tables[idx].table == NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 171| 8| REQUIRE(bits >= HASHMAP_MIN_BITS); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 172| 8| REQUIRE(bits <= HASHMAP_MAX_BITS); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | | | | | ------------------ | | | | | | | | 53| 8| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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| 588| uint8_t *idxp) { 254| 588| uint32_t hash; 255| 588| uint32_t psl; 256| 588| uint8_t idx = *idxp; 257| 588| uint32_t pos; 258| | 259| 588|nexttable: 260| 588| psl = 0; 261| 588| hash = isc_hash_bits32(hashval, hashmap->tables[idx].hashbits); 262| | 263| 588| while (true) { ------------------ | Branch (263:9): [True: 588, Folded] ------------------ 264| 588| hashmap_node_t *node = NULL; 265| | 266| 588| pos = (hash + psl) & hashmap->tables[idx].hashmask; 267| | 268| 588| node = &hashmap->tables[idx].table[pos]; 269| | 270| 588| if (node->key == NULL || psl > node->psl) { ------------------ | Branch (270:7): [True: 333, False: 255] | Branch (270:28): [True: 0, False: 255] ------------------ 271| 333| break; 272| 333| } 273| | 274| 255| if (node->hashval == hashval) { ------------------ | Branch (274:7): [True: 255, False: 0] ------------------ 275| 255| if (match(node->value, key)) { ------------------ | Branch (275:8): [True: 255, False: 0] ------------------ 276| 255| *pslp = psl; 277| 255| *idxp = idx; 278| 255| return node; 279| 255| } 280| 255| } 281| | 282| 0| psl++; 283| 0| } 284| 333| if (try_nexttable(hashmap, idx)) { ------------------ | Branch (284:6): [True: 0, False: 333] ------------------ 285| 0| idx = hashmap_nexttable(idx); 286| 0| goto nexttable; 287| 0| } 288| | 289| 333| return NULL; 290| 333|} hashmap.c:try_nexttable: 129| 333|try_nexttable(const isc_hashmap_t *hashmap, uint8_t idx) { 130| 333| return idx == hashmap->hindex && rehashing_in_progress(hashmap); ------------------ | Branch (130:9): [True: 333, False: 0] | Branch (130:35): [True: 0, False: 333] ------------------ 131| 333|} hashmap.c:rehashing_in_progress: 123| 337|rehashing_in_progress(const isc_hashmap_t *hashmap) { 124| 337| return hashmap->tables[hashmap_nexttable(hashmap->hindex)].table != 125| | NULL; 126| 337|} 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| 337|hashmap_nexttable(uint8_t idx) { 119| 337| return (idx == 0) ? 1 : 0; ------------------ | Branch (119:9): [True: 337, False: 0] ------------------ 120| 337|} 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 88| 2| REQUIRE(compare != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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|} isc_hex_totextlower: 88| 2| isc_buffer_t *target) { 89| 2| return hex_totext(source, wordlength, wordbreak, lowerhex, target); 90| 2|} hex.c:hex_totext: 55| 2| const char *hex, isc_buffer_t *target) { 56| 2| char buf[3]; 57| 2| unsigned int loops = 0; 58| | 59| 2| if (wordlength < 2) { ------------------ | Branch (59:6): [True: 2, False: 0] ------------------ 60| 2| wordlength = 2; 61| 2| } 62| | 63| 2| memset(buf, 0, sizeof(buf)); 64| 66| while (source->length > 0) { ------------------ | Branch (64:9): [True: 64, False: 2] ------------------ 65| 64| buf[0] = hex[(source->base[0] >> 4) & 0xf]; 66| 64| buf[1] = hex[(source->base[0]) & 0xf]; 67| 64| RETERR(str_totext(buf, target)); ------------------ | | 276| 64| { \ | | 277| 64| isc_result_t _r = (x); \ | | 278| 64| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 64] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 64| } ------------------ 68| 64| isc_region_consume(source, 1); ------------------ | | 51| 64| do { \ | | 52| 64| isc_region_t *_r = (r); \ | | 53| 64| unsigned int _l = (l); \ | | 54| 64| INSIST(_r->length >= _l); \ | | ------------------ | | | | 202| 64|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 64| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 64, False: 0] | | | | | | ------------------ | | | | | | 54| 64| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 55| 64| _r->base += _l; \ | | 56| 64| _r->length -= _l; \ | | 57| 64| } while (0) | | ------------------ | | | Branch (57:11): [Folded, False: 64] | | ------------------ ------------------ 69| | 70| 64| loops++; 71| 64| if (source->length != 0 && (int)((loops + 1) * 2) >= wordlength) ------------------ | Branch (71:7): [True: 62, False: 2] | Branch (71:30): [True: 62, False: 0] ------------------ 72| 62| { 73| 62| loops = 0; 74| 62| RETERR(str_totext(wordbreak, target)); ------------------ | | 276| 62| { \ | | 277| 62| isc_result_t _r = (x); \ | | 278| 62| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 62] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 62| } ------------------ 75| 62| } 76| 64| } 77| 2| return ISC_R_SUCCESS; 78| 2|} hex.c:str_totext: 198| 126|str_totext(const char *source, isc_buffer_t *target) { 199| 126| unsigned int l; 200| 126| isc_region_t region; 201| | 202| 126| isc_buffer_availableregion(target, ®ion); 203| 126| l = strlen(source); 204| | 205| 126| if (l > region.length) { ------------------ | Branch (205:6): [True: 0, False: 126] ------------------ 206| 0| return ISC_R_NOSPACE; 207| 0| } 208| | 209| 126| memmove(region.base, source, l); 210| 126| isc_buffer_add(target, l); 211| 126| return ISC_R_SUCCESS; 212| 126|} name.c:isc_ascii_lowercmp: 171| 26|isc_ascii_lowercmp(const uint8_t *a, const uint8_t *b, unsigned int len) { 172| 26| uint64_t a8 = 0, b8 = 0; 173| 26| while (len >= 8) { ------------------ | Branch (173:9): [True: 0, False: 26] ------------------ 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| 110| while (len-- > 0) { ------------------ | Branch (183:9): [True: 84, False: 26] ------------------ 184| 84| a8 = isc_ascii_tolower(*a++); ------------------ | | 31| 84|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 185| 84| b8 = isc_ascii_tolower(*b++); ------------------ | | 31| 84|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 186| 84| if (a8 != b8) { ------------------ | Branch (186:7): [True: 0, False: 84] ------------------ 187| 0| goto ret; 188| 0| } 189| 84| } 190| 26|ret: 191| 26| if (a8 < b8) { ------------------ | Branch (191:6): [True: 0, False: 26] ------------------ 192| 0| return -1; 193| 0| } 194| 26| if (a8 > b8) { ------------------ | Branch (194:6): [True: 0, False: 26] ------------------ 195| 0| return +1; 196| 0| } 197| 26| return 0; 198| 26|} name.c:isc_ascii_tolower8: 71| 3.64k|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.64k| 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.64k| 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.64k| 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.64k| uint64_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes; 91| | /* 92| | * Add one for greater-than-or-equal comparison 93| | */ 94| 3.64k| 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.64k| 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.64k| return octets | (is_upper >> 2); 104| 3.64k|} name.c:isc__ascii_load8: 124| 3.64k|isc__ascii_load8(const uint8_t *ptr) { 125| 3.64k| uint64_t bytes = 0; 126| 3.64k| memmove(&bytes, ptr, sizeof(bytes)); 127| 3.64k| return bytes; 128| 3.64k|} name.c:isc_ascii_lowerequal: 135| 1.02k| unsigned int len) { 136| 1.02k| uint64_t a8 = 0, b8 = 0; 137| 1.02k| if (len >= 8) { ------------------ | Branch (137:6): [True: 1.02k, False: 0] ------------------ 138| 1.02k| const uint8_t *a_tail = a + len - 8; 139| 1.02k| const uint8_t *b_tail = b + len - 8; 140| 1.82k| while (len >= 8) { ------------------ | Branch (140:10): [True: 1.04k, False: 783] ------------------ 141| 1.04k| a8 = isc_ascii_tolower8(isc__ascii_load8(a)); 142| 1.04k| b8 = isc_ascii_tolower8(isc__ascii_load8(b)); 143| 1.04k| if (a8 != b8) { ------------------ | Branch (143:8): [True: 242, False: 799] ------------------ 144| 242| return false; 145| 242| } 146| 799| len -= 8; 147| 799| a += 8; 148| 799| b += 8; 149| 799| } 150| | 151| 783| a8 = isc_ascii_tolower8(isc__ascii_load8(a_tail)); 152| 783| b8 = isc_ascii_tolower8(isc__ascii_load8(b_tail)); 153| 783| return a8 == b8; 154| 1.02k| } 155| | 156| 0| while (len-- > 0) { ------------------ | Branch (156:9): [True: 0, False: 0] ------------------ 157| 0| if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ | Branch (157:7): [True: 0, False: 0] ------------------ 158| 0| return false; 159| 0| } 160| 0| } 161| 0| return true; 162| 0|} name.c:isc_ascii_lowercopy: 47| 304|isc_ascii_lowercopy(uint8_t *dst, const uint8_t *src, unsigned int len) { 48| 3.34k| while (len-- > 0) { ------------------ | Branch (48:9): [True: 3.04k, False: 304] ------------------ 49| 3.04k| *dst++ = isc__ascii_tolower1(*src++); 50| 3.04k| } 51| 304|} name.c:isc__ascii_tolower1: 39| 3.04k|isc__ascii_tolower1(uint8_t c) { 40| 3.04k| return c + ('a' - 'A') * ('A' <= c && c <= 'Z'); ------------------ | Branch (40:28): [True: 2.12k, False: 912] | Branch (40:40): [True: 0, False: 2.12k] ------------------ 41| 3.04k|} hash.c:isc__ascii_tolower1: 39| 1.18k|isc__ascii_tolower1(uint8_t c) { 40| 1.18k| return c + ('a' - 'A') * ('A' <= c && c <= 'Z'); ------------------ | Branch (40:28): [True: 590, False: 590] | Branch (40:40): [True: 0, False: 590] ------------------ 41| 1.18k|} hash.c:isc_ascii_tolower4: 110| 1.18k|isc_ascii_tolower4(uint32_t octets) { 111| 1.18k| uint32_t all_bytes = 0x01010101; 112| 1.18k| uint32_t heptets = octets & (0x7F * all_bytes); 113| 1.18k| uint32_t is_ascii = ~octets & (0x80 * all_bytes); 114| 1.18k| uint32_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes; 115| 1.18k| uint32_t is_ge_A = heptets + (0x80 - 'A') * all_bytes; 116| 1.18k| uint32_t is_upper = (is_ge_A ^ is_gt_Z) & is_ascii; 117| 1.18k| return octets | (is_upper >> 2); 118| 1.18k|} hash.c:isc_rotate_left32: 82| 21.2k|isc_rotate_left32(const uint32_t x, uint32_t n) { 83| 21.2k| return (x << n) | (x >> (32 - n)); 84| 21.2k|} dns_message_checksig.c:isc_buffer_putuint8: 889| 2.21k|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 890| 2.21k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 2.21k| { \ | | 878| 2.21k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 2.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 4.42k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 2.21k, False: 0] | | | | | | | Branch (41:11): [True: 2.21k, False: 0] | | | | | | ------------------ | | | | | | 42| 2.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 2.21k| \ | | 880| 2.21k| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 2.21k] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 2.21k| \ | | 885| 2.21k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 2.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2.21k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2.21k, False: 0] | | | | | | ------------------ | | | | | | 42| 2.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 2.21k| } ------------------ 891| | 892| 2.21k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 2.21k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 893| 2.21k| b->used += sizeof(val); 894| 2.21k| cp[0] = val; 895| 2.21k|} dns_message_checksig.c:isc_buffer_init: 584| 1.82k| const unsigned int length) { 585| 1.82k| REQUIRE(b != NULL); ------------------ | | 198| 1.82k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.82k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.82k, False: 0] | | | | ------------------ | | | | 42| 1.82k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 1.82k| *b = (isc_buffer_t){ 588| 1.82k| .base = base, 589| 1.82k| .length = length, 590| 1.82k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 1.82k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 1.82k| { \ | | | | 27| 1.82k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 1.82k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 1.82k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 1.82k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 1.82k| } | | ------------------ ------------------ 591| 1.82k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 1.82k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 1.82k| }; 593| 1.82k|} dns_message_checksig.c:isc_buffer_putmem: 985| 2.98k| const unsigned int length) { 986| 2.98k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.98k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.96k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.98k, False: 0] | | | | | Branch (41:11): [True: 2.98k, False: 0] | | | | ------------------ | | | | 42| 2.98k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 987| | 988| 2.98k| if (b->mctx) { ------------------ | Branch (988:6): [True: 0, False: 2.98k] ------------------ 989| 0| isc_result_t result = isc_buffer_reserve(b, length); 990| 0| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 0, False: 0] | | | | ------------------ | | | | 42| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 991| 0| } 992| | 993| 2.98k| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 198| 2.98k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.98k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.98k, False: 0] | | | | ------------------ | | | | 42| 2.98k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 994| | 995| 2.98k| if (length > 0U) { ------------------ | Branch (995:6): [True: 2.96k, False: 18] ------------------ 996| 2.96k| memmove(isc_buffer_used(b), base, length); ------------------ | | 150| 2.96k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 997| 2.96k| b->used += length; 998| 2.96k| } 999| 2.98k|} dns_message_checksig.c:isc_buffer_putuint16: 917| 18.7k|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 918| 18.7k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 18.7k| { \ | | 878| 18.7k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 18.7k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 37.5k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 18.7k, False: 0] | | | | | | | Branch (41:11): [True: 18.7k, False: 0] | | | | | | ------------------ | | | | | | 42| 18.7k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 18.7k| \ | | 880| 18.7k| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 18.7k] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 18.7k| \ | | 885| 18.7k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 18.7k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 18.7k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 18.7k, False: 0] | | | | | | ------------------ | | | | | | 42| 18.7k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 18.7k| } ------------------ 919| | 920| 18.7k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 18.7k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 921| 18.7k| b->used += sizeof(val); 922| 18.7k| ISC_U16TO8_BE(cp, val); ------------------ | | 223| 18.7k| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 18.7k| (p)[1] = (uint8_t)((v)); ------------------ 923| 18.7k|} dns_message_checksig.c:isc_buffer_putuint32: 945| 1.80k|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 946| 1.80k| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 1.80k| { \ | | 878| 1.80k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 1.80k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 3.61k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 1.80k, False: 0] | | | | | | | Branch (41:11): [True: 1.80k, False: 0] | | | | | | ------------------ | | | | | | 42| 1.80k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 1.80k| \ | | 880| 1.80k| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 1.80k] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 1.80k| \ | | 885| 1.80k| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 1.80k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 1.80k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 1.80k, False: 0] | | | | | | ------------------ | | | | | | 42| 1.80k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 1.80k| } ------------------ 947| | 948| 1.80k| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 1.80k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 949| 1.80k| b->used += sizeof(val); 950| | 951| 1.80k| ISC_U32TO8_BE(cp, val); ------------------ | | 229| 1.80k| (p)[0] = (uint8_t)((v) >> 24); \ | | 230| 1.80k| (p)[1] = (uint8_t)((v) >> 16); \ | | 231| 1.80k| (p)[2] = (uint8_t)((v) >> 8); \ | | 232| 1.80k| (p)[3] = (uint8_t)((v)); ------------------ 952| 1.80k|} fixedname.c:isc_buffer_init: 584| 4.24k| const unsigned int length) { 585| 4.24k| REQUIRE(b != NULL); ------------------ | | 198| 4.24k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.24k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4.24k, False: 0] | | | | ------------------ | | | | 42| 4.24k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 4.24k| *b = (isc_buffer_t){ 588| 4.24k| .base = base, 589| 4.24k| .length = length, 590| 4.24k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 4.24k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 4.24k| { \ | | | | 27| 4.24k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.24k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 4.24k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 4.24k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 4.24k| } | | ------------------ ------------------ 591| 4.24k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 4.24k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 4.24k| }; 593| 4.24k|} message.c:isc_buffer_allocate: 1097| 2.19k| const unsigned int length) { 1098| 2.19k| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1099| | 1100| 2.19k| isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length); ------------------ | | 144| 2.19k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1101| 2.19k| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1102| | 1103| 2.19k| isc_buffer_init(dbuf, bdata, length); 1104| 2.19k| dbuf->extra = length; 1105| 2.19k| isc_buffer_setmctx(dbuf, mctx); 1106| | 1107| 2.19k| *dbufp = dbuf; 1108| 2.19k|} message.c:isc_buffer_setmctx: 1111| 2.19k|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1112| 2.19k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1113| | 1114| 2.19k| b->mctx = mctx; 1115| 2.19k|} message.c:isc_buffer_free: 1174| 2.19k|isc_buffer_free(isc_buffer_t **restrict dbufp) { 1175| 2.19k| REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp)); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8.77k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1176| 2.19k| REQUIRE((*dbufp)->mctx != NULL); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1177| | 1178| 2.19k| isc_buffer_t *dbuf = *dbufp; 1179| 2.19k| isc_mem_t *mctx = dbuf->mctx; 1180| 2.19k| unsigned int extra = dbuf->extra; 1181| | 1182| 2.19k| *dbufp = NULL; /* destroy external reference */ 1183| | 1184| 2.19k| isc_buffer_clearmctx(dbuf); 1185| | 1186| 2.19k| isc_buffer_invalidate(dbuf); 1187| | isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra); ------------------ | | 171| 2.19k| do { \ | | 172| 2.19k| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 2.19k| (p) = NULL; \ | | 174| 2.19k| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 2.19k] | | ------------------ ------------------ 1188| 2.19k|} message.c:isc_buffer_clearmctx: 1118| 2.19k|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1119| 2.19k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1120| | 1121| 2.19k| if (b->dynamic) { ------------------ | Branch (1121:6): [True: 0, False: 2.19k] ------------------ 1122| 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] | | ------------------ ------------------ 1123| 0| b->dynamic = false; 1124| 0| } 1125| | 1126| | b->mctx = NULL; 1127| 2.19k|} message.c:isc_buffer_invalidate: 633| 2.19k|isc_buffer_invalidate(isc_buffer_t *restrict b) { 634| 2.19k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | | Branch (41:11): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 635| 2.19k| REQUIRE(!ISC_LINK_LINKED(b, link)); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 636| 2.19k| REQUIRE(b->mctx == NULL); ------------------ | | 198| 2.19k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.19k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.19k, False: 0] | | | | ------------------ | | | | 42| 2.19k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 637| | 638| 2.19k| *b = (isc_buffer_t){ 639| 2.19k| .magic = 0, 640| 2.19k| }; 641| 2.19k|} message.c:isc_buffer_usedregion: 672| 2.07k| isc_region_t *restrict r) { 673| 2.07k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.07k, False: 0] | | | | | Branch (41:11): [True: 2.07k, False: 0] | | | | ------------------ | | | | 42| 2.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 674| 2.07k| REQUIRE(r != NULL); ------------------ | | 198| 2.07k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.07k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.07k, False: 0] | | | | ------------------ | | | | 42| 2.07k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 675| | 676| 2.07k| r->base = b->base; 677| 2.07k| r->length = b->used; 678| 2.07k|} message.c:isc_buffer_remainingregion: 768| 8.91k|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 769| 8.91k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 8.91k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 17.8k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8.91k, False: 0] | | | | | Branch (41:11): [True: 8.91k, False: 0] | | | | ------------------ | | | | 42| 8.91k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 770| 8.91k| REQUIRE(r != NULL); ------------------ | | 198| 8.91k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8.91k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8.91k, False: 0] | | | | ------------------ | | | | 42| 8.91k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 771| | 772| 8.91k| r->base = isc_buffer_current(b); ------------------ | | 146| 8.91k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 773| 8.91k| r->length = isc_buffer_remaininglength(b); ------------------ | | 160| 8.91k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 774| 8.91k|} message.c:isc_buffer_getuint16: 908| 17.2k|isc_buffer_getuint16(isc_buffer_t *restrict b) { 909| 17.2k| uint16_t val = 0; 910| 17.2k| isc_result_t result = isc_buffer_peekuint16(b, &val); 911| 17.2k| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 17.2k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 17.2k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 17.2k, False: 0] | | | | ------------------ | | | | 48| 17.2k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 912| 17.2k| b->current += sizeof(val); 913| 17.2k| return val; 914| 17.2k|} message.c:isc_buffer_peekuint16: 898| 17.2k|isc_buffer_peekuint16(const isc_buffer_t *restrict b, uint16_t *valp) { 899| 17.2k| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 851| 17.2k| { \ | | 852| 17.2k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 17.2k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 34.5k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 17.2k, False: 0] | | | | | | | Branch (41:11): [True: 17.2k, False: 0] | | | | | | ------------------ | | | | | | 42| 17.2k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 853| 17.2k| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (853:7): [True: 0, False: 17.2k] | | ------------------ | | 854| 0| return (ISC_R_NOMORE); \ | | 855| 0| } \ | | 856| 17.2k| } ------------------ 900| | 901| 17.2k| uint8_t *cp = isc_buffer_current(b); ------------------ | | 146| 17.2k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 902| | 903| | SET_IF_NOT_NULL(valp, ISC_U8TO16_BE(cp)); ------------------ | | 104| 17.2k| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 17.2k, False: 0] | | ------------------ | | 105| 17.2k| *(obj) = (val); \ | | 106| 17.2k| } ------------------ 904| 17.2k| return ISC_R_SUCCESS; 905| 17.2k|} message.c:isc_buffer_add: 699| 1.01k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 1.01k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 1.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.03k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.01k, False: 0] | | | | | Branch (41:11): [True: 1.01k, False: 0] | | | | ------------------ | | | | 42| 1.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 1.01k| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 1.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 1.01k, False: 0] | | | | ------------------ | | | | 42| 1.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 1.01k| b->used += n; 704| 1.01k|} message.c:isc_buffer_reserve: 1130| 249|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1131| 249| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1132| | 1133| 249| size_t len; 1134| | 1135| 249| len = dbuf->length; 1136| 249| if ((len - dbuf->used) >= size) { ------------------ | Branch (1136:6): [True: 249, False: 0] ------------------ 1137| 249| return ISC_R_SUCCESS; 1138| 249| } 1139| | 1140| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1140:6): [True: 0, False: 0] ------------------ 1141| 0| return ISC_R_NOSPACE; 1142| 0| } 1143| | 1144| | /* Round to nearest buffer size increment */ 1145| 0| len = size + dbuf->used; 1146| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 296| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1147| | 1148| | /* Cap at UINT_MAX */ 1149| 0| if (len > UINT_MAX) { ------------------ | Branch (1149:6): [True: 0, False: 0] ------------------ 1150| 0| len = UINT_MAX; 1151| 0| } 1152| | 1153| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1153:6): [True: 0, False: 0] ------------------ 1154| 0| return ISC_R_NOMEMORY; 1155| 0| } 1156| | 1157| 0| if (!dbuf->dynamic) { ------------------ | Branch (1157:6): [True: 0, False: 0] ------------------ 1158| 0| void *old_base = dbuf->base; 1159| 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) ------------------ 1160| 0| if (old_base != NULL) { ------------------ | Branch (1160:7): [True: 0, False: 0] ------------------ 1161| 0| memmove(dbuf->base, old_base, dbuf->used); 1162| 0| } 1163| 0| dbuf->dynamic = true; 1164| 0| } else { 1165| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1166| 0| dbuf->length, len, sizeof(char)); 1167| 0| } 1168| 0| dbuf->length = (unsigned int)len; 1169| | 1170| 0| return ISC_R_SUCCESS; 1171| 0|} message.c:isc_buffer_init: 584| 3.21k| const unsigned int length) { 585| 3.21k| REQUIRE(b != NULL); ------------------ | | 198| 3.21k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.21k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.21k, False: 0] | | | | ------------------ | | | | 42| 3.21k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 3.21k| *b = (isc_buffer_t){ 588| 3.21k| .base = base, 589| 3.21k| .length = length, 590| 3.21k| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 3.21k|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 3.21k| { \ | | | | 27| 3.21k| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.21k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 3.21k| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 3.21k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 3.21k| } | | ------------------ ------------------ 591| 3.21k| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 3.21k|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 3.21k| }; 593| 3.21k|} message.c:isc_buffer_putmem: 985| 249| const unsigned int length) { 986| 249| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 498| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 249, False: 0] | | | | | Branch (41:11): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 987| | 988| 249| if (b->mctx) { ------------------ | Branch (988:6): [True: 249, False: 0] ------------------ 989| 249| isc_result_t result = isc_buffer_reserve(b, length); 990| 249| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 249| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 991| 249| } 992| | 993| 249| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 198| 249|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 249| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 249, False: 0] | | | | ------------------ | | | | 42| 249| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 994| | 995| 249| if (length > 0U) { ------------------ | Branch (995:6): [True: 249, False: 0] ------------------ 996| 249| memmove(isc_buffer_used(b), base, length); ------------------ | | 150| 249| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 997| 249| b->used += length; 998| 249| } 999| 249|} message.c:isc_buffer_getuint32: 936| 1.55k|isc_buffer_getuint32(isc_buffer_t *restrict b) { 937| 1.55k| uint32_t val = 0; 938| 1.55k| isc_result_t result = isc_buffer_peekuint32(b, &val); 939| 1.55k| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 1.55k|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 1.55k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 1.55k, False: 0] | | | | ------------------ | | | | 48| 1.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 940| 1.55k| b->current += sizeof(val); 941| 1.55k| return val; 942| 1.55k|} message.c:isc_buffer_peekuint32: 926| 1.55k|isc_buffer_peekuint32(const isc_buffer_t *restrict b, uint32_t *valp) { 927| 1.55k| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 851| 1.55k| { \ | | 852| 1.55k| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 1.55k|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 3.10k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 1.55k, False: 0] | | | | | | | Branch (41:11): [True: 1.55k, False: 0] | | | | | | ------------------ | | | | | | 42| 1.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 853| 1.55k| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (853:7): [True: 0, False: 1.55k] | | ------------------ | | 854| 0| return (ISC_R_NOMORE); \ | | 855| 0| } \ | | 856| 1.55k| } ------------------ 928| | 929| 1.55k| uint8_t *cp = isc_buffer_current(b); ------------------ | | 146| 1.55k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 930| | 931| | SET_IF_NOT_NULL(valp, ISC_U8TO32_BE(cp)); ------------------ | | 104| 1.55k| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 1.55k, False: 0] | | ------------------ | | 105| 1.55k| *(obj) = (val); \ | | 106| 1.55k| } ------------------ 932| 1.55k| return ISC_R_SUCCESS; 933| 1.55k|} message.c:isc_buffer_setactive: 809| 4.67k|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 810| 4.67k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 4.67k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 9.35k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4.67k, False: 0] | | | | | Branch (41:11): [True: 4.67k, False: 0] | | | | ------------------ | | | | 42| 4.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 811| 4.67k| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 4.67k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.67k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4.67k, False: 0] | | | | ------------------ | | | | 42| 4.67k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 812| | 813| 4.67k| b->active = b->current + n; 814| 4.67k|} name.c:isc_buffer_clear: 732| 3.84k|isc_buffer_clear(isc_buffer_t *restrict b) { 733| 3.84k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 3.84k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 7.68k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.84k, False: 0] | | | | | Branch (41:11): [True: 3.84k, False: 0] | | | | ------------------ | | | | 42| 3.84k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 734| | 735| 3.84k| b->used = 0; 736| 3.84k| b->current = 0; 737| 3.84k| b->active = 0; 738| 3.84k|} name.c:isc_buffer_availableregion: 690| 4|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 691| 4| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 692| 4| REQUIRE(r != NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 693| | 694| 4| r->base = isc_buffer_used(b); ------------------ | | 150| 4| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 695| 4| r->length = isc_buffer_availablelength(b); ------------------ | | 162| 4|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 696| 4|} name.c:isc_buffer_add: 699| 5.68k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 5.68k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 5.68k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 11.3k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 5.68k, False: 0] | | | | | Branch (41:11): [True: 5.68k, False: 0] | | | | ------------------ | | | | 42| 5.68k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 5.68k| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 5.68k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.68k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 5.68k, False: 0] | | | | ------------------ | | | | 42| 5.68k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 5.68k| b->used += n; 704| 5.68k|} name.c:isc_buffer_reserve: 1130| 14|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1131| 14| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1132| | 1133| 14| size_t len; 1134| | 1135| 14| len = dbuf->length; 1136| 14| if ((len - dbuf->used) >= size) { ------------------ | Branch (1136:6): [True: 14, False: 0] ------------------ 1137| 14| return ISC_R_SUCCESS; 1138| 14| } 1139| | 1140| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1140:6): [True: 0, False: 0] ------------------ 1141| 0| return ISC_R_NOSPACE; 1142| 0| } 1143| | 1144| | /* Round to nearest buffer size increment */ 1145| 0| len = size + dbuf->used; 1146| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 296| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1147| | 1148| | /* Cap at UINT_MAX */ 1149| 0| if (len > UINT_MAX) { ------------------ | Branch (1149:6): [True: 0, False: 0] ------------------ 1150| 0| len = UINT_MAX; 1151| 0| } 1152| | 1153| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1153:6): [True: 0, False: 0] ------------------ 1154| 0| return ISC_R_NOMEMORY; 1155| 0| } 1156| | 1157| 0| if (!dbuf->dynamic) { ------------------ | Branch (1157:6): [True: 0, False: 0] ------------------ 1158| 0| void *old_base = dbuf->base; 1159| 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) ------------------ 1160| 0| if (old_base != NULL) { ------------------ | Branch (1160:7): [True: 0, False: 0] ------------------ 1161| 0| memmove(dbuf->base, old_base, dbuf->used); 1162| 0| } 1163| 0| dbuf->dynamic = true; 1164| 0| } else { 1165| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1166| 0| dbuf->length, len, sizeof(char)); 1167| 0| } 1168| 0| dbuf->length = (unsigned int)len; 1169| | 1170| 0| return ISC_R_SUCCESS; 1171| 0|} name.c:isc_buffer_putuint8: 889| 14|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 890| 14| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 14| { \ | | 878| 14| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 28| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 14, False: 0] | | | | | | | Branch (41:11): [True: 14, False: 0] | | | | | | ------------------ | | | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 14| \ | | 880| 14| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 14] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 14| \ | | 885| 14| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 14| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 14, False: 0] | | | | | | ------------------ | | | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 14| } ------------------ 891| | 892| 14| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 14| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 893| 14| b->used += sizeof(val); 894| 14| cp[0] = val; 895| 14|} name.c:isc_buffer_forward: 835| 5.16k|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 836| 5.16k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 5.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10.3k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 5.16k, False: 0] | | | | | Branch (41:11): [True: 5.16k, False: 0] | | | | ------------------ | | | | 42| 5.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 837| 5.16k| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 5.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 5.16k, False: 0] | | | | ------------------ | | | | 42| 5.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 838| | 839| 5.16k| b->current += n; 840| 5.16k|} name.c:isc_buffer_init: 584| 4| const unsigned int length) { 585| 4| REQUIRE(b != NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 4| *b = (isc_buffer_t){ 588| 4| .base = base, 589| 4| .length = length, 590| 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| } | | ------------------ ------------------ 591| 4| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 4|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 4| }; 593| 4|} rcode.c:isc_buffer_availableregion: 690| 2|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 691| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 692| 2| REQUIRE(r != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 693| | 694| 2| r->base = isc_buffer_used(b); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 695| 2| r->length = isc_buffer_availablelength(b); ------------------ | | 162| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 696| 2|} rcode.c:isc_buffer_add: 699| 2|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 2| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 2| b->used += n; 704| 2|} rdata.c:isc_buffer_activeregion: 786| 2.77k|isc_buffer_activeregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 787| 2.77k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2.77k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.55k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2.77k, False: 0] | | | | | Branch (41:11): [True: 2.77k, False: 0] | | | | ------------------ | | | | 42| 2.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 788| 2.77k| REQUIRE(r != NULL); ------------------ | | 198| 2.77k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.77k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.77k, False: 0] | | | | ------------------ | | | | 42| 2.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 789| | 790| 2.77k| if (b->current < b->active) { ------------------ | Branch (790:6): [True: 2.75k, False: 17] ------------------ 791| 2.75k| r->base = isc_buffer_current(b); ------------------ | | 146| 2.75k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 792| 2.75k| r->length = isc_buffer_activelength(b); ------------------ | | 161| 2.75k|#define isc_buffer_activelength(b) ((b)->active - (b)->current) /* c-b */ ------------------ 793| 2.75k| } else { 794| | r->base = NULL; 795| 17| r->length = 0; 796| 17| } 797| 2.77k|} rdata.c:isc_buffer_setactive: 809| 6|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 810| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 811| 6| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 812| | 813| 6| b->active = b->current + n; 814| 6|} rdata.c:isc_buffer_forward: 835| 4.92k|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 836| 4.92k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 4.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 9.84k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4.92k, False: 0] | | | | | Branch (41:11): [True: 4.92k, False: 0] | | | | ------------------ | | | | 42| 4.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 837| 4.92k| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 4.92k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.92k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4.92k, False: 0] | | | | ------------------ | | | | 42| 4.92k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 838| | 839| 4.92k| b->current += n; 840| 4.92k|} rdata.c:isc_buffer_availableregion: 690| 5.06k|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 691| 5.06k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 5.06k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 5.06k, False: 0] | | | | | Branch (41:11): [True: 5.06k, False: 0] | | | | ------------------ | | | | 42| 5.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 692| 5.06k| REQUIRE(r != NULL); ------------------ | | 198| 5.06k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.06k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 5.06k, False: 0] | | | | ------------------ | | | | 42| 5.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 693| | 694| 5.06k| r->base = isc_buffer_used(b); ------------------ | | 150| 5.06k| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 695| 5.06k| r->length = isc_buffer_availablelength(b); ------------------ | | 162| 5.06k|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 696| 5.06k|} rdata.c:isc_buffer_add: 699| 4.69k|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 4.69k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 4.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 9.38k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4.69k, False: 0] | | | | | Branch (41:11): [True: 4.69k, False: 0] | | | | ------------------ | | | | 42| 4.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 4.69k| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 4.69k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4.69k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4.69k, False: 0] | | | | ------------------ | | | | 42| 4.69k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 4.69k| b->used += n; 704| 4.69k|} rdata.c:isc_buffer_putuint16: 917| 2|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 918| 2| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 2| { \ | | 878| 2| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 2, False: 0] | | | | | | | Branch (41:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 2| \ | | 880| 2| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 2] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 2| \ | | 885| 2| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 2| } ------------------ 919| | 920| 2| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 921| 2| b->used += sizeof(val); 922| 2| ISC_U16TO8_BE(cp, val); ------------------ | | 223| 2| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 2| (p)[1] = (uint8_t)((v)); ------------------ 923| 2|} rdata.c:isc_buffer_putuint32: 945| 10|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 946| 10| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 10| { \ | | 878| 10| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 20| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 10, False: 0] | | | | | | | Branch (41:11): [True: 10, False: 0] | | | | | | ------------------ | | | | | | 42| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 10| \ | | 880| 10| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 10] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 10| \ | | 885| 10| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 10| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 10, False: 0] | | | | | | ------------------ | | | | | | 42| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 10| } ------------------ 947| | 948| 10| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 10| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 949| 10| b->used += sizeof(val); 950| | 951| 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)); ------------------ 952| 10|} rdata.c:isc_buffer_init: 584| 6| const unsigned int length) { 585| 6| REQUIRE(b != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 6| *b = (isc_buffer_t){ 588| 6| .base = base, 589| 6| .length = length, 590| 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| } | | ------------------ ------------------ 591| 6| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 6|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 6| }; 593| 6|} tsig.c:isc_buffer_init: 584| 36| const unsigned int length) { 585| 36| REQUIRE(b != NULL); ------------------ | | 198| 36|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 36| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 36, False: 0] | | | | ------------------ | | | | 42| 36| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 36| *b = (isc_buffer_t){ 588| 36| .base = base, 589| 36| .length = length, 590| 36| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 36|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 36| { \ | | | | 27| 36| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 36|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 36| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 36|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 36| } | | ------------------ ------------------ 591| 36| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 36|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 36| }; 593| 36|} tsig.c:isc_buffer_add: 699| 2|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 2| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 2| b->used += n; 704| 2|} tsig.c:isc_buffer_putuint48: 974| 29|isc_buffer_putuint48(isc_buffer_t *restrict b, const uint64_t val) { 975| 29| ISC_BUFFER_PUT_RESERVE(b, val, 6); /* 48-bits */ ------------------ | | 877| 29| { \ | | 878| 29| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 58| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 29, False: 0] | | | | | | | Branch (41:11): [True: 29, False: 0] | | | | | | ------------------ | | | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 29| \ | | 880| 29| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 29] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 29| \ | | 885| 29| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 29| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 29, False: 0] | | | | | | ------------------ | | | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 29| } ------------------ 976| | 977| 29| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 29| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 978| 29| b->used += 6; 979| | 980| 29| ISC_U48TO8_BE(cp, val); ------------------ | | 239| 29| (p)[0] = (uint8_t)((v) >> 40); \ | | 240| 29| (p)[1] = (uint8_t)((v) >> 32); \ | | 241| 29| (p)[2] = (uint8_t)((v) >> 24); \ | | 242| 29| (p)[3] = (uint8_t)((v) >> 16); \ | | 243| 29| (p)[4] = (uint8_t)((v) >> 8); \ | | 244| 29| (p)[5] = (uint8_t)((v)); ------------------ 981| 29|} tsig.c:isc_buffer_putuint16: 917| 121|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 918| 121| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 121| { \ | | 878| 121| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 121|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 242| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 121, False: 0] | | | | | | | Branch (41:11): [True: 121, False: 0] | | | | | | ------------------ | | | | | | 42| 121| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 121| \ | | 880| 121| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 121] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 121| \ | | 885| 121| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 121|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 121| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 121, False: 0] | | | | | | ------------------ | | | | | | 42| 121| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 121| } ------------------ 919| | 920| 121| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 121| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 921| 121| b->used += sizeof(val); 922| 121| ISC_U16TO8_BE(cp, val); ------------------ | | 223| 121| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 121| (p)[1] = (uint8_t)((v)); ------------------ 923| 121|} tsig.c:isc_buffer_usedregion: 672| 121| isc_region_t *restrict r) { 673| 121| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 121|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 242| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 121, False: 0] | | | | | Branch (41:11): [True: 121, False: 0] | | | | ------------------ | | | | 42| 121| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 674| 121| REQUIRE(r != NULL); ------------------ | | 198| 121|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 121| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 121, False: 0] | | | | ------------------ | | | | 42| 121| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 675| | 676| 121| r->base = b->base; 677| 121| r->length = b->used; 678| 121|} tsig.c:isc_buffer_clear: 732| 29|isc_buffer_clear(isc_buffer_t *restrict b) { 733| 29| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 58| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 29, False: 0] | | | | | Branch (41:11): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 734| | 735| 29| b->used = 0; 736| 29| b->current = 0; 737| 29| b->active = 0; 738| 29|} tsig.c:isc_buffer_putuint32: 945| 29|isc_buffer_putuint32(isc_buffer_t *restrict b, const uint32_t val) { 946| 29| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 29| { \ | | 878| 29| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 58| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 29, False: 0] | | | | | | | Branch (41:11): [True: 29, False: 0] | | | | | | ------------------ | | | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 29| \ | | 880| 29| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 29] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 29| \ | | 885| 29| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 29| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 29, False: 0] | | | | | | ------------------ | | | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 29| } ------------------ 947| | 948| 29| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 29| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 949| 29| b->used += sizeof(val); 950| | 951| 29| ISC_U32TO8_BE(cp, val); ------------------ | | 229| 29| (p)[0] = (uint8_t)((v) >> 24); \ | | 230| 29| (p)[1] = (uint8_t)((v) >> 16); \ | | 231| 29| (p)[2] = (uint8_t)((v) >> 8); \ | | 232| 29| (p)[3] = (uint8_t)((v)); ------------------ 952| 29|} zone.c:isc_buffer_putstr: 1016| 2|isc_buffer_putstr(isc_buffer_t *restrict b, const char *restrict source) { 1017| 2| unsigned int length; 1018| 2| unsigned char *cp; 1019| | 1020| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1021| 2| REQUIRE(source != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1022| | 1023| 2| length = (unsigned int)strlen(source); 1024| 2| if (b->mctx) { ------------------ | Branch (1024:6): [True: 0, False: 2] ------------------ 1025| 0| isc_result_t result = isc_buffer_reserve(b, length); 1026| 0| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 0, False: 0] | | | | ------------------ | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 1027| 0| } 1028| | 1029| 2| REQUIRE(isc_buffer_availablelength(b) >= length); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1030| | 1031| 2| cp = isc_buffer_used(b); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1032| 2| memmove(cp, source, length); 1033| 2| b->used += length; 1034| 2|} zone.c:isc_buffer_init: 584| 2| const unsigned int length) { 585| 2| REQUIRE(b != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 2| *b = (isc_buffer_t){ 588| 2| .base = base, 589| 2| .length = length, 590| 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| } | | ------------------ ------------------ 591| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 2| }; 593| 2|} zoneproperties.c:isc_buffer_putmem: 985| 2| const unsigned int length) { 986| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 987| | 988| 2| if (b->mctx) { ------------------ | Branch (988:6): [True: 0, False: 2] ------------------ 989| 0| isc_result_t result = isc_buffer_reserve(b, length); 990| 0| REQUIRE(result == ISC_R_SUCCESS); ------------------ | | 198| 0|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 0, False: 0] | | | | ------------------ | | | | 42| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 991| 0| } 992| | 993| 2| REQUIRE(isc_buffer_availablelength(b) >= (unsigned int)length); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 994| | 995| 2| if (length > 0U) { ------------------ | Branch (995:6): [True: 2, False: 0] ------------------ 996| 2| memmove(isc_buffer_used(b), base, length); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 997| 2| b->used += length; 998| 2| } 999| 2|} zoneproperties.c:isc_buffer_putuint8: 889| 2|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 890| 2| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 2| { \ | | 878| 2| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 2, False: 0] | | | | | | | Branch (41:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 2| \ | | 880| 2| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 2] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 2| \ | | 885| 2| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 2| } ------------------ 891| | 892| 2| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 893| 2| b->used += sizeof(val); 894| 2| cp[0] = val; 895| 2|} zoneproperties.c:isc_buffer_init: 584| 2| const unsigned int length) { 585| 2| REQUIRE(b != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 2| *b = (isc_buffer_t){ 588| 2| .base = base, 589| 2| .length = length, 590| 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| } | | ------------------ ------------------ 591| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 2| }; 593| 2|} dnssec.c:isc_buffer_init: 584| 82| const unsigned int length) { 585| 82| REQUIRE(b != NULL); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 82| *b = (isc_buffer_t){ 588| 82| .base = base, 589| 82| .length = length, 590| 82| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 82|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 82| { \ | | | | 27| 82| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 82|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 82| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 82|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 82| } | | ------------------ ------------------ 591| 82| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 82|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 82| }; 593| 82|} dnssec.c:isc_buffer_add: 699| 82|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 82| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 82, False: 0] | | | | | Branch (41:11): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 82| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 82| b->used += n; 704| 82|} dnssec.c:isc_buffer_usedregion: 672| 80| isc_region_t *restrict r) { 673| 80| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 80|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 160| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 80, False: 0] | | | | | Branch (41:11): [True: 80, False: 0] | | | | ------------------ | | | | 42| 80| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 674| 80| REQUIRE(r != NULL); ------------------ | | 198| 80|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 80| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 80, False: 0] | | | | ------------------ | | | | 42| 80| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 675| | 676| 80| r->base = b->base; 677| 80| r->length = b->used; 678| 80|} dst_api.c:isc_buffer_putuint8: 889| 4|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 890| 4| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 4| { \ | | 878| 4| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 8| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 4, False: 0] | | | | | | | Branch (41:11): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 4| \ | | 880| 4| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 4] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 4| \ | | 885| 4| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 4| } ------------------ 891| | 892| 4| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 4| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 893| 4| b->used += sizeof(val); 894| 4| cp[0] = val; 895| 4|} dst_api.c:isc_buffer_init: 584| 2| const unsigned int length) { 585| 2| REQUIRE(b != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 2| *b = (isc_buffer_t){ 588| 2| .base = base, 589| 2| .length = length, 590| 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| } | | ------------------ ------------------ 591| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 2| }; 593| 2|} dst_api.c:isc_buffer_putuint16: 917| 2|isc_buffer_putuint16(isc_buffer_t *restrict b, const uint16_t val) { 918| 2| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 2| { \ | | 878| 2| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 2, False: 0] | | | | | | | Branch (41:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 2| \ | | 880| 2| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 0, False: 2] | | ------------------ | | 881| 0| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 0| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 0|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 48| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 0| } \ | | 884| 2| \ | | 885| 2| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 2| } ------------------ 919| | 920| 2| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 921| 2| b->used += sizeof(val); 922| 2| ISC_U16TO8_BE(cp, val); ------------------ | | 223| 2| (p)[0] = (uint8_t)((v) >> 8); \ | | 224| 2| (p)[1] = (uint8_t)((v)); ------------------ 923| 2|} dst_api.c:isc_buffer_remainingregion: 768| 82|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 769| 82| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 82, False: 0] | | | | | Branch (41:11): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 770| 82| REQUIRE(r != NULL); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 771| | 772| 82| r->base = isc_buffer_current(b); ------------------ | | 146| 82| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 773| 82| r->length = isc_buffer_remaininglength(b); ------------------ | | 160| 82|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 774| 82|} dst_api.c:isc_buffer_getuint16: 908| 82|isc_buffer_getuint16(isc_buffer_t *restrict b) { 909| 82| uint16_t val = 0; 910| 82| isc_result_t result = isc_buffer_peekuint16(b, &val); 911| 82| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 82|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 82, False: 0] | | | | ------------------ | | | | 48| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 912| 82| b->current += sizeof(val); 913| 82| return val; 914| 82|} dst_api.c:isc_buffer_peekuint16: 898| 82|isc_buffer_peekuint16(const isc_buffer_t *restrict b, uint16_t *valp) { 899| 82| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 851| 82| { \ | | 852| 82| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 164| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 82, False: 0] | | | | | | | Branch (41:11): [True: 82, False: 0] | | | | | | ------------------ | | | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 853| 82| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (853:7): [True: 0, False: 82] | | ------------------ | | 854| 0| return (ISC_R_NOMORE); \ | | 855| 0| } \ | | 856| 82| } ------------------ 900| | 901| 82| uint8_t *cp = isc_buffer_current(b); ------------------ | | 146| 82| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 902| | 903| | SET_IF_NOT_NULL(valp, ISC_U8TO16_BE(cp)); ------------------ | | 104| 82| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 82, False: 0] | | ------------------ | | 105| 82| *(obj) = (val); \ | | 106| 82| } ------------------ 904| 82| return ISC_R_SUCCESS; 905| 82|} dst_api.c:isc_buffer_getuint8: 868| 164|isc_buffer_getuint8(isc_buffer_t *restrict b) { 869| 164| uint8_t val = 0; 870| 164| isc_result_t result = isc_buffer_peekuint8(b, &val); 871| 164| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 164|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 164, False: 0] | | | | ------------------ | | | | 48| 164| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 872| 164| b->current += sizeof(val); 873| 164| return val; 874| 164|} dst_api.c:isc_buffer_peekuint8: 859| 164|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 860| 164| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 851| 164| { \ | | 852| 164| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 164|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 328| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 164, False: 0] | | | | | | | Branch (41:11): [True: 164, False: 0] | | | | | | ------------------ | | | | | | 42| 164| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 853| 164| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (853:7): [True: 0, False: 164] | | ------------------ | | 854| 0| return (ISC_R_NOMORE); \ | | 855| 0| } \ | | 856| 164| } ------------------ 861| | 862| 164| uint8_t *cp = isc_buffer_current(b); ------------------ | | 146| 164| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 863| | SET_IF_NOT_NULL(valp, (uint8_t)(cp[0])); ------------------ | | 104| 164| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 164, False: 0] | | ------------------ | | 105| 164| *(obj) = (val); \ | | 106| 164| } ------------------ 864| 164| return ISC_R_SUCCESS; 865| 164|} dst_api.c:isc_buffer_usedregion: 672| 2| isc_region_t *restrict r) { 673| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 674| 2| REQUIRE(r != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 675| | 676| 2| r->base = b->base; 677| 2| r->length = b->used; 678| 2|} hmac_link.c:isc_buffer_init: 584| 29| const unsigned int length) { 585| 29| REQUIRE(b != NULL); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 29| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 29| *b = (isc_buffer_t){ 588| 29| .base = base, 589| 29| .length = length, 590| 29| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 29|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 29| { \ | | | | 27| 29| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 29|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 29| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 29|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 29| } | | ------------------ ------------------ 591| 29| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 29|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 29| }; 593| 29|} hmac_link.c:isc_buffer_remainingregion: 768| 2|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 769| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 770| 2| REQUIRE(r != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 771| | 772| 2| r->base = isc_buffer_current(b); ------------------ | | 146| 2| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 773| 2| r->length = isc_buffer_remaininglength(b); ------------------ | | 160| 2|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 774| 2|} hmac_link.c:isc_buffer_forward: 835| 2|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 836| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 837| 2| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 838| | 839| 2| b->current += n; 840| 2|} hmac_link.c:isc_buffer_copyregion: 1212| 2| const isc_region_t *restrict r) { 1213| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1214| 2| REQUIRE(r != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1215| | 1216| 2| if (b->mctx) { ------------------ | Branch (1216:6): [True: 0, False: 2] ------------------ 1217| 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| } ------------------ 1218| 0| } 1219| | 1220| 2| if (r->length > isc_buffer_availablelength(b)) { ------------------ | | 162| 2|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1220:6): [True: 0, False: 2] ------------------ 1221| 0| return ISC_R_NOSPACE; 1222| 0| } 1223| | 1224| 2| if (r->length > 0U) { ------------------ | Branch (1224:6): [True: 2, False: 0] ------------------ 1225| 2| memmove(isc_buffer_used(b), r->base, r->length); ------------------ | | 150| 2| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1226| 2| b->used += r->length; 1227| 2| } 1228| | 1229| 2| return ISC_R_SUCCESS; 1230| 2|} master.c:isc_buffer_init: 584| 10| const unsigned int length) { 585| 10| REQUIRE(b != NULL); ------------------ | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 10, False: 0] | | | | ------------------ | | | | 42| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 10| *b = (isc_buffer_t){ 588| 10| .base = base, 589| 10| .length = length, 590| 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| } | | ------------------ ------------------ 591| 10| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 10|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 10| }; 593| 10|} master.c:isc_buffer_add: 699| 6|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 6| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 6| b->used += n; 704| 6|} master.c:isc_buffer_setactive: 809| 6|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 810| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 811| 6| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 812| | 813| 6| b->active = b->current + n; 814| 6|} opensslrsa_link.c:isc_buffer_remainingregion: 768| 82|isc_buffer_remainingregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 769| 82| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 82, False: 0] | | | | | Branch (41:11): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 770| 82| REQUIRE(r != NULL); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 771| | 772| 82| r->base = isc_buffer_current(b); ------------------ | | 146| 82| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 773| 82| r->length = isc_buffer_remaininglength(b); ------------------ | | 160| 82|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 774| 82|} opensslrsa_link.c:isc_buffer_forward: 835| 82|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 836| 82| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 164| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 82, False: 0] | | | | | Branch (41:11): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 837| 82| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 82|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 82| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 82, False: 0] | | | | ------------------ | | | | 42| 82| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 838| | 839| 82| b->current += n; 840| 82|} ossl3.c:isc_buffer_add: 699| 29|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 29| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 58| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 29, False: 0] | | | | | Branch (41:11): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 29| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 29|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 29| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 29, False: 0] | | | | ------------------ | | | | 42| 29| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 29| b->used += n; 704| 29|} base64.c:isc_buffer_availableregion: 690| 174|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 691| 174| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 348| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 174, False: 0] | | | | | Branch (41:11): [True: 174, False: 0] | | | | ------------------ | | | | 42| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 692| 174| REQUIRE(r != NULL); ------------------ | | 198| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 174| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 174, False: 0] | | | | ------------------ | | | | 42| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 693| | 694| 174| r->base = isc_buffer_used(b); ------------------ | | 150| 174| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 695| 174| r->length = isc_buffer_availablelength(b); ------------------ | | 162| 174|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 696| 174|} base64.c:isc_buffer_add: 699| 174|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 174| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 348| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 174, False: 0] | | | | | Branch (41:11): [True: 174, False: 0] | | | | ------------------ | | | | 42| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 174| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 174|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 174| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 174, False: 0] | | | | ------------------ | | | | 42| 174| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 174| b->used += n; 704| 174|} file.c:isc_buffer_init: 584| 2| const unsigned int length) { 585| 2| REQUIRE(b != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 2| *b = (isc_buffer_t){ 588| 2| .base = base, 589| 2| .length = length, 590| 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| } | | ------------------ ------------------ 591| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 2| }; 593| 2|} file.c:isc_buffer_putuint8: 889| 14|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 890| 14| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 14| { \ | | 878| 14| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 28| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 14, False: 0] | | | | | | | Branch (41:11): [True: 14, False: 0] | | | | | | ------------------ | | | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 14| \ | | 880| 14| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 12, False: 2] | | ------------------ | | 881| 12| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 12| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 12|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 12| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 12, False: 0] | | | | | | ------------------ | | | | | | 48| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 12| } \ | | 884| 14| \ | | 885| 14| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 14| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 14, False: 0] | | | | | | ------------------ | | | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 14| } ------------------ 891| | 892| 14| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 14| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 893| 14| b->used += sizeof(val); 894| 14| cp[0] = val; 895| 14|} file.c:isc_buffer_reserve: 1130| 24|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1131| 24| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 198| 24|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 48| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 24, False: 0] | | | | | Branch (41:11): [True: 24, False: 0] | | | | ------------------ | | | | 42| 24| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1132| | 1133| 24| size_t len; 1134| | 1135| 24| len = dbuf->length; 1136| 24| if ((len - dbuf->used) >= size) { ------------------ | Branch (1136:6): [True: 22, False: 2] ------------------ 1137| 22| return ISC_R_SUCCESS; 1138| 22| } 1139| | 1140| 2| if (dbuf->mctx == NULL) { ------------------ | Branch (1140:6): [True: 0, False: 2] ------------------ 1141| 0| return ISC_R_NOSPACE; 1142| 0| } 1143| | 1144| | /* Round to nearest buffer size increment */ 1145| 2| len = size + dbuf->used; 1146| 2| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 296| 2|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1147| | 1148| | /* Cap at UINT_MAX */ 1149| 2| if (len > UINT_MAX) { ------------------ | Branch (1149:6): [True: 0, False: 2] ------------------ 1150| 0| len = UINT_MAX; 1151| 0| } 1152| | 1153| 2| if ((len - dbuf->used) < size) { ------------------ | Branch (1153:6): [True: 0, False: 2] ------------------ 1154| 0| return ISC_R_NOMEMORY; 1155| 0| } 1156| | 1157| 2| if (!dbuf->dynamic) { ------------------ | Branch (1157:6): [True: 2, False: 0] ------------------ 1158| 2| void *old_base = dbuf->base; 1159| 2| dbuf->base = isc_mem_get(dbuf->mctx, len); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1160| 2| if (old_base != NULL) { ------------------ | Branch (1160:7): [True: 0, False: 2] ------------------ 1161| 0| memmove(dbuf->base, old_base, dbuf->used); 1162| 0| } 1163| 2| dbuf->dynamic = true; 1164| 2| } else { 1165| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1166| 0| dbuf->length, len, sizeof(char)); 1167| 0| } 1168| 2| dbuf->length = (unsigned int)len; 1169| | 1170| 2| return ISC_R_SUCCESS; 1171| 2|} file.c:isc_buffer_initnull: 596| 2|isc_buffer_initnull(isc_buffer_t *restrict b) { 597| 2| *b = (isc_buffer_t){ 598| 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| } | | ------------------ ------------------ 599| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 600| 2| }; 601| 2|} file.c:isc_buffer_setmctx: 1111| 2|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1112| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1113| | 1114| 2| b->mctx = mctx; 1115| 2|} file.c:isc_buffer_clear: 732| 6|isc_buffer_clear(isc_buffer_t *restrict b) { 733| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 734| | 735| 6| b->used = 0; 736| 6| b->current = 0; 737| 6| b->active = 0; 738| 6|} file.c:isc_buffer_putstr: 1016| 12|isc_buffer_putstr(isc_buffer_t *restrict b, const char *restrict source) { 1017| 12| unsigned int length; 1018| 12| unsigned char *cp; 1019| | 1020| 12| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1021| 12| REQUIRE(source != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1022| | 1023| 12| length = (unsigned int)strlen(source); 1024| 12| if (b->mctx) { ------------------ | Branch (1024:6): [True: 12, False: 0] ------------------ 1025| 12| isc_result_t result = isc_buffer_reserve(b, length); 1026| 12| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 12|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 12, False: 0] | | | | ------------------ | | | | 48| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 1027| 12| } 1028| | 1029| 12| REQUIRE(isc_buffer_availablelength(b) >= length); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1030| | 1031| 12| cp = isc_buffer_used(b); ------------------ | | 150| 12| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1032| 12| memmove(cp, source, length); 1033| 12| b->used += length; 1034| 12|} file.c:isc_buffer_clearmctx: 1118| 2|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1119| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1120| | 1121| 2| if (b->dynamic) { ------------------ | Branch (1121:6): [True: 2, False: 0] ------------------ 1122| 2| isc_mem_put(b->mctx, b->base, b->length); ------------------ | | 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] | | ------------------ ------------------ 1123| 2| b->dynamic = false; 1124| 2| } 1125| | 1126| | b->mctx = NULL; 1127| 2|} hex.c:isc_buffer_availableregion: 690| 126|isc_buffer_availableregion(isc_buffer_t *restrict b, isc_region_t *restrict r) { 691| 126| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 126|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 252| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 126, False: 0] | | | | | Branch (41:11): [True: 126, False: 0] | | | | ------------------ | | | | 42| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 692| 126| REQUIRE(r != NULL); ------------------ | | 198| 126|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 126| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 126, False: 0] | | | | ------------------ | | | | 42| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 693| | 694| 126| r->base = isc_buffer_used(b); ------------------ | | 150| 126| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 695| 126| r->length = isc_buffer_availablelength(b); ------------------ | | 162| 126|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 696| 126|} hex.c:isc_buffer_add: 699| 126|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 700| 126| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 126|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 252| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 126, False: 0] | | | | | Branch (41:11): [True: 126, False: 0] | | | | ------------------ | | | | 42| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 701| 126| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 126|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 126| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 126, False: 0] | | | | ------------------ | | | | 42| 126| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 702| | 703| 126| b->used += n; 704| 126|} lex.c:isc_buffer_allocate: 1097| 2| const unsigned int length) { 1098| 2| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1099| | 1100| 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) ------------------ 1101| 2| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1102| | 1103| 2| isc_buffer_init(dbuf, bdata, length); 1104| 2| dbuf->extra = length; 1105| 2| isc_buffer_setmctx(dbuf, mctx); 1106| | 1107| 2| *dbufp = dbuf; 1108| 2|} lex.c:isc_buffer_init: 584| 2| const unsigned int length) { 585| 2| REQUIRE(b != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 586| | 587| 2| *b = (isc_buffer_t){ 588| 2| .base = base, 589| 2| .length = length, 590| 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| } | | ------------------ ------------------ 591| 2| .magic = ISC_BUFFER_MAGIC, ------------------ | | 122| 2|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 592| 2| }; 593| 2|} lex.c:isc_buffer_setmctx: 1111| 2|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1112| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1113| | 1114| 2| b->mctx = mctx; 1115| 2|} lex.c:isc_buffer_free: 1174| 2|isc_buffer_free(isc_buffer_t **restrict dbufp) { 1175| 2| REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1176| 2| REQUIRE((*dbufp)->mctx != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1177| | 1178| 2| isc_buffer_t *dbuf = *dbufp; 1179| 2| isc_mem_t *mctx = dbuf->mctx; 1180| 2| unsigned int extra = dbuf->extra; 1181| | 1182| 2| *dbufp = NULL; /* destroy external reference */ 1183| | 1184| 2| isc_buffer_clearmctx(dbuf); 1185| | 1186| 2| isc_buffer_invalidate(dbuf); 1187| | 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] | | ------------------ ------------------ 1188| 2|} lex.c:isc_buffer_clearmctx: 1118| 2|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1119| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1120| | 1121| 2| if (b->dynamic) { ------------------ | Branch (1121:6): [True: 0, False: 2] ------------------ 1122| 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] | | ------------------ ------------------ 1123| 0| b->dynamic = false; 1124| 0| } 1125| | 1126| | b->mctx = NULL; 1127| 2|} lex.c:isc_buffer_invalidate: 633| 2|isc_buffer_invalidate(isc_buffer_t *restrict b) { 634| 2| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 635| 2| REQUIRE(!ISC_LINK_LINKED(b, link)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 636| 2| REQUIRE(b->mctx == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 637| | 638| 2| *b = (isc_buffer_t){ 639| 2| .magic = 0, 640| 2| }; 641| 2|} lex.c:isc_buffer_compact: 1068| 74|isc_buffer_compact(isc_buffer_t *restrict b) { 1069| 74| unsigned int length; 1070| 74| void *src; 1071| | 1072| | /* 1073| | * Compact the used region by moving the remaining region so it occurs 1074| | * at the start of the buffer. The used region is shrunk by the size 1075| | * of the consumed region, and the consumed region is then made empty. 1076| | */ 1077| | 1078| 74| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 74|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 148| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 74, False: 0] | | | | | Branch (41:11): [True: 74, False: 0] | | | | ------------------ | | | | 42| 74| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1079| | 1080| 74| src = isc_buffer_current(b); ------------------ | | 146| 74| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1081| 74| length = isc_buffer_remaininglength(b); ------------------ | | 160| 74|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 1082| 74| if (length > 0U) { ------------------ | Branch (1082:6): [True: 66, False: 8] ------------------ 1083| 66| (void)memmove(b->base, src, (size_t)length); 1084| 66| } 1085| | 1086| 74| if (b->active > b->current) { ------------------ | Branch (1086:6): [True: 0, False: 74] ------------------ 1087| 0| b->active -= b->current; 1088| 74| } else { 1089| 74| b->active = 0; 1090| 74| } 1091| 74| b->current = 0; 1092| 74| b->used = length; 1093| 74|} lex.c:isc_buffer_reserve: 1130| 864|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1131| 864| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 198| 864|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.72k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 864, False: 0] | | | | | Branch (41:11): [True: 864, False: 0] | | | | ------------------ | | | | 42| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1132| | 1133| 864| size_t len; 1134| | 1135| 864| len = dbuf->length; 1136| 864| if ((len - dbuf->used) >= size) { ------------------ | Branch (1136:6): [True: 864, False: 0] ------------------ 1137| 864| return ISC_R_SUCCESS; 1138| 864| } 1139| | 1140| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1140:6): [True: 0, False: 0] ------------------ 1141| 0| return ISC_R_NOSPACE; 1142| 0| } 1143| | 1144| | /* Round to nearest buffer size increment */ 1145| 0| len = size + dbuf->used; 1146| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 296| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1147| | 1148| | /* Cap at UINT_MAX */ 1149| 0| if (len > UINT_MAX) { ------------------ | Branch (1149:6): [True: 0, False: 0] ------------------ 1150| 0| len = UINT_MAX; 1151| 0| } 1152| | 1153| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1153:6): [True: 0, False: 0] ------------------ 1154| 0| return ISC_R_NOMEMORY; 1155| 0| } 1156| | 1157| 0| if (!dbuf->dynamic) { ------------------ | Branch (1157:6): [True: 0, False: 0] ------------------ 1158| 0| void *old_base = dbuf->base; 1159| 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) ------------------ 1160| 0| if (old_base != NULL) { ------------------ | Branch (1160:7): [True: 0, False: 0] ------------------ 1161| 0| memmove(dbuf->base, old_base, dbuf->used); 1162| 0| } 1163| 0| dbuf->dynamic = true; 1164| 0| } else { 1165| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | | | | | ------------------ | | | | | | | | 53| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1166| 0| dbuf->length, len, sizeof(char)); 1167| 0| } 1168| 0| dbuf->length = (unsigned int)len; 1169| | 1170| 0| return ISC_R_SUCCESS; 1171| 0|} lex.c:isc_buffer_putuint8: 889| 864|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 890| 864| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 877| 864| { \ | | 878| 864| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 864|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 1.72k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 864, False: 0] | | | | | | | Branch (41:11): [True: 864, False: 0] | | | | | | ------------------ | | | | | | 42| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 879| 864| \ | | 880| 864| if (b->mctx) { \ | | ------------------ | | | Branch (880:7): [True: 864, False: 0] | | ------------------ | | 881| 864| isc_result_t result = isc_buffer_reserve(b, s); \ | | 882| 864| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 864|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 47| 864| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (47:10): [True: 864, False: 0] | | | | | | ------------------ | | | | | | 48| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (48:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 50| 0| 0))) | | | | ------------------ | | ------------------ | | 883| 864| } \ | | 884| 864| \ | | 885| 864| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 864|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 864| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:10): [True: 864, False: 0] | | | | | | ------------------ | | | | | | 42| 864| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 886| 864| } ------------------ 891| | 892| 864| uint8_t *cp = isc_buffer_used(b); ------------------ | | 150| 864| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 893| 864| b->used += sizeof(val); 894| 864| cp[0] = val; 895| 864|} lex.c:isc_buffer_getuint8: 868| 946|isc_buffer_getuint8(isc_buffer_t *restrict b) { 869| 946| uint8_t val = 0; 870| 946| isc_result_t result = isc_buffer_peekuint8(b, &val); 871| 946| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 946|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 47| 946| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (47:10): [True: 946, False: 0] | | | | ------------------ | | | | 48| 946| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (48:3): [True: 0, False: 0] | | | | ------------------ | | | | 49| 0| isc_assertiontype_ensure, #cond), \ | | | | 50| 0| 0))) | | ------------------ ------------------ 872| 946| b->current += sizeof(val); 873| 946| return val; 874| 946|} lex.c:isc_buffer_peekuint8: 859| 946|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 860| 946| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 851| 946| { \ | | 852| 946| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 946|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 41| 1.89k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (41:11): [True: 946, False: 0] | | | | | | | Branch (41:11): [True: 946, False: 0] | | | | | | ------------------ | | | | | | 42| 946| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (42:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | | | 44| 0| 0))) | | | | ------------------ | | ------------------ | | 853| 946| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (853:7): [True: 0, False: 946] | | ------------------ | | 854| 0| return (ISC_R_NOMORE); \ | | 855| 0| } \ | | 856| 946| } ------------------ 861| | 862| 946| uint8_t *cp = isc_buffer_current(b); ------------------ | | 146| 946| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 863| | 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| } ------------------ 864| 946| return ISC_R_SUCCESS; 865| 946|} lex.c:isc_buffer_first: 828| 6|isc_buffer_first(isc_buffer_t *restrict b) { 829| 6| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 830| | 831| 6| b->current = 0; 832| 6|} hashmap.c:isc_hash_bits32: 114| 590|isc_hash_bits32(uint32_t val, unsigned int bits) { 115| 590| ISC_REQUIRE(bits <= ISC_HASH_MAX_BITS); ------------------ | | 41| 590| ((void)((cond) || \ | | ------------------ | | | Branch (41:10): [True: 590, False: 0] | | ------------------ | | 42| 590| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | ------------------ | | | Branch (42:3): [True: 0, False: 0] | | ------------------ | | 43| 0| isc_assertiontype_require, #cond), \ | | 44| 0| 0))) ------------------ 116| | /* High bits are more random. */ 117| 590| return val * ISC_HASH_GOLDENRATIO_32 >> (32 - bits); ------------------ | | 111| 590|#define ISC_HASH_GOLDENRATIO_32 0x61C88647 ------------------ 118| 590|} master.c:isc_token_hasnul: 347| 26|isc_token_hasnul(const isc_token_t *token) { 348| | /* 349| | * Only string tokens carry a text region; other types have no 350| | * text to inspect. 351| | */ 352| 26| if (token->type != isc_tokentype_string && ------------------ | Branch (352:6): [True: 2, False: 24] ------------------ 353| 2| token->type != isc_tokentype_qstring) ------------------ | Branch (353:6): [True: 2, False: 0] ------------------ 354| 2| { 355| 2| return false; 356| 2| } 357| 24| return memchr(token->value.as_textregion.base, 0, 358| | token->value.as_textregion.length) != NULL; 359| 26|} isc_lib_initialize: 57| 2|isc_lib_initialize(void) { 58| 2| isc__lib_initialize(); 59| 2|} dns_tsigkeyring_attach: 222| 1.09k| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 1.09k| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 1.09k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 1.09k, False: 0] | | | | | Branch (41:11): [True: 1.09k, False: 0] | | | | ------------------ | | | | 42| 1.09k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 224| 1.09k| name##_ref(ptr); \ 225| 1.09k| *ptrp = ptr; \ 226| 1.09k| } \ dns_tsigkey_attach: 222| 294| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 294| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 294|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 588| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 294, False: 0] | | | | | Branch (41:11): [True: 294, False: 0] | | | | ------------------ | | | | 42| 294| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 224| 294| name##_ref(ptr); \ 225| 294| *ptrp = ptr; \ 226| 294| } \ dns_zone_attach: 222| 208| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 208| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 208|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 416| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 208, False: 0] | | | | | Branch (41:11): [True: 208, False: 0] | | | | ------------------ | | | | 42| 208| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 224| 208| name##_ref(ptr); \ 225| 208| *ptrp = ptr; \ 226| 208| } \ dns_db_attach: 222| 212| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 212| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 212|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 424| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 212, False: 0] | | | | | Branch (41:11): [True: 212, False: 0] | | | | ------------------ | | | | 42| 212| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 224| 212| name##_ref(ptr); \ 225| 212| *ptrp = ptr; \ 226| 212| } \ 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 224| 4| name##_ref(ptr); \ 225| 4| *ptrp = ptr; \ 226| 4| } \ isc_mem_attach: 222| 5.23k| stat void name##_attach(name##_t *ptr, name##_t **ptrp) { \ 223| 5.23k| REQUIRE(ptrp != NULL && *ptrp == NULL); \ ------------------ | | 198| 5.23k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 10.4k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 5.23k, False: 0] | | | | | Branch (41:11): [True: 5.23k, False: 0] | | | | ------------------ | | | | 42| 5.23k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 224| 5.23k| name##_ref(ptr); \ 225| 5.23k| *ptrp = ptr; \ 226| 5.23k| } \ hash.c:isc_halfsiphash13_init: 633| 590|isc_halfsiphash13_init(isc_halfsiphash24_t *restrict state, const uint8_t *k) { 634| 590| REQUIRE(k != NULL); ------------------ | | 198| 590|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 590| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 590, False: 0] | | | | ------------------ | | | | 42| 590| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 635| | 636| 590| uint32_t k0 = ISC_U8TO32_LE(k); ------------------ | | 188| 590| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 189| 590| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 637| 590| uint32_t k1 = ISC_U8TO32_LE(k + 4); ------------------ | | 188| 590| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 189| 590| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 638| | 639| 590| *state = (isc_halfsiphash24_t){ 640| 590| .k0 = k0, 641| 590| .k1 = k1, 642| 590| .v0 = UINT32_C(0x00000000) ^ k0, 643| 590| .v1 = UINT32_C(0x00000000) ^ k1, 644| 590| .v2 = UINT32_C(0x6c796765) ^ k0, 645| | .v3 = UINT32_C(0x74656462) ^ k1, 646| 590| }; 647| 590|} hash.c:isc_halfsiphash13_hash: 662| 590| const size_t inlen, const bool case_sensitive) { 663| 590| REQUIRE(inlen == 0 || in != NULL); ------------------ | | 198| 590|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 1.18k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 0, False: 590] | | | | | Branch (41:11): [True: 590, False: 0] | | | | ------------------ | | | | 42| 590| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 664| | 665| 590| if (in == NULL || inlen == 0) { ------------------ | Branch (665:6): [True: 0, False: 590] | Branch (665:20): [True: 0, False: 590] ------------------ 666| 0| return; 667| 0| } 668| | 669| 590| size_t len = inlen; 670| 590| const int right = state->inlen & 3; 671| | 672| 590| switch (right) { 673| 590| case 0: ------------------ | Branch (673:2): [True: 590, False: 0] ------------------ 674| 590| break; 675| 0| case 1: ------------------ | Branch (675:2): [True: 0, False: 590] ------------------ 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; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 684| 0| case 2: ------------------ | Branch (684:2): [True: 0, False: 590] ------------------ 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; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 693| 0| case 3: ------------------ | Branch (693:2): [True: 0, False: 590] ------------------ 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: 590] ------------------ 706| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 707| 590| } 708| | 709| 590| const uint8_t *end = in + len - (len % sizeof(uint32_t)); 710| 590| const int left = len & 3; 711| | 712| 1.77k| for (; in != end; in += 4) { ------------------ | Branch (712:9): [True: 1.18k, False: 590] ------------------ 713| 1.18k| uint32_t m = case_sensitive ------------------ | Branch (713:16): [True: 0, False: 1.18k] ------------------ 714| 1.18k| ? 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.18k| : isc_ascii_tolower4(ISC_U8TO32_LE(in)); ------------------ | | 188| 1.18k| (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ | | 189| 1.18k| ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) ------------------ 716| | 717| 1.18k| isc_halfsiphash13_one(state, m); 718| 1.18k| } 719| | 720| 590| INSIST(state->b == 0); ------------------ | | 202| 590|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 590| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 590, False: 0] | | | | ------------------ | | | | 54| 590| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 721| 590| switch (left) { 722| 0| case 3: ------------------ | Branch (722:2): [True: 0, False: 590] ------------------ 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; ------------------ | | 105| 0|#define FALLTHROUGH [[fallthrough]] ------------------ 725| 590| case 2: ------------------ | Branch (725:2): [True: 590, False: 0] ------------------ 726| 590| state->b |= U8TO32_ONE(case_sensitive, in[1]) << 8; ------------------ | | 77| 590| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 590] | | ------------------ ------------------ 727| 590| FALLTHROUGH; ------------------ | | 105| 590|#define FALLTHROUGH [[fallthrough]] ------------------ 728| 590| case 1: ------------------ | Branch (728:2): [True: 0, False: 590] ------------------ 729| 590| state->b |= U8TO32_ONE(case_sensitive, in[0]); ------------------ | | 77| 590| (uint32_t)(case_sensitive ? byte : isc__ascii_tolower1(byte)) | | ------------------ | | | Branch (77:13): [True: 0, False: 590] | | ------------------ ------------------ 730| 590| FALLTHROUGH; ------------------ | | 105| 590|#define FALLTHROUGH [[fallthrough]] ------------------ 731| 590| case 0: ------------------ | Branch (731:2): [True: 0, False: 590] ------------------ 732| 590| break; 733| 0| default: ------------------ | Branch (733:2): [True: 0, False: 590] ------------------ 734| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 735| 590| } 736| | 737| 590| state->inlen += len; 738| 590|} hash.c:isc_halfsiphash13_one: 650| 1.77k|isc_halfsiphash13_one(isc_halfsiphash13_t *restrict state, const uint32_t m) { 651| 1.77k| state->v3 ^= m; 652| | 653| 3.54k| for (size_t i = 0; i < cROUNDS_13; ++i) { ------------------ | | 47| 3.54k|#define cROUNDS_13 1 ------------------ | Branch (653:21): [True: 1.77k, False: 1.77k] ------------------ 654| 1.77k| HALFSIPROUND(state->v0, state->v1, state->v2, state->v3); ------------------ | | 74| 1.77k|#define HALFSIPROUND FULL_ROUND32 | | ------------------ | | | | 71| 1.77k| HALF_ROUND32(v0, v1, v2, v3, 5, 8); \ | | | | ------------------ | | | | | | 64| 1.77k| a += b; \ | | | | | | 65| 1.77k| c += d; \ | | | | | | 66| 1.77k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.77k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.77k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | | | 72| 1.77k| HALF_ROUND32(v2, v1, v0, v3, 13, 7); | | | | ------------------ | | | | | | 64| 1.77k| a += b; \ | | | | | | 65| 1.77k| c += d; \ | | | | | | 66| 1.77k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.77k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.77k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 655| 1.77k| } 656| | 657| 1.77k| state->v0 ^= m; 658| 1.77k|} hash.c:isc_halfsiphash13_finalize: 741| 590|isc_halfsiphash13_finalize(isc_halfsiphash13_t *restrict state, uint8_t *out) { 742| 590| REQUIRE(out != NULL); ------------------ | | 198| 590|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 590| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 590, False: 0] | | | | ------------------ | | | | 42| 590| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 743| | 744| 590| uint32_t b = ((uint32_t)state->inlen) << 24 | state->b; 745| | 746| 590| isc_halfsiphash13_one(state, b); 747| | 748| 590| state->v2 ^= 0xff; 749| | 750| 2.36k| for (size_t i = 0; i < dROUNDS_13; ++i) { ------------------ | | 48| 2.36k|#define dROUNDS_13 3 ------------------ | Branch (750:21): [True: 1.77k, False: 590] ------------------ 751| 1.77k| HALFSIPROUND(state->v0, state->v1, state->v2, state->v3); ------------------ | | 74| 1.77k|#define HALFSIPROUND FULL_ROUND32 | | ------------------ | | | | 71| 1.77k| HALF_ROUND32(v0, v1, v2, v3, 5, 8); \ | | | | ------------------ | | | | | | 64| 1.77k| a += b; \ | | | | | | 65| 1.77k| c += d; \ | | | | | | 66| 1.77k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.77k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.77k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | | | 72| 1.77k| HALF_ROUND32(v2, v1, v0, v3, 13, 7); | | | | ------------------ | | | | | | 64| 1.77k| a += b; \ | | | | | | 65| 1.77k| c += d; \ | | | | | | 66| 1.77k| b = ISC_ROTATE_LEFT(b, s) ^ a; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 67| 1.77k| d = ISC_ROTATE_LEFT(d, t) ^ c; \ | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | | | 68| 1.77k| a = ISC_ROTATE_LEFT(a, 16); | | | | | | ------------------ | | | | | | | | 133| 1.77k| _Generic((x), \ | | | | | | | | 134| 1.77k| uint8_t: isc_rotate_left8, \ | | | | | | | | 135| 1.77k| uint16_t: isc_rotate_left16, \ | | | | | | | | 136| 1.77k| uint32_t: isc_rotate_left32, \ | | | | | | | | 137| 1.77k| uint64_t: isc_rotate_left64 EXTRA_ROTATE_LEFT)(x, n) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 752| 1.77k| } 753| | 754| 590| b = state->v1 ^ state->v3; 755| 590| ISC_U32TO8_LE(out, b); ------------------ | | 182| 590| (p)[0] = (uint8_t)((v)); \ | | 183| 590| (p)[1] = (uint8_t)((v) >> 8); \ | | 184| 590| (p)[2] = (uint8_t)((v) >> 16); \ | | 185| 590| (p)[3] = (uint8_t)((v) >> 24); ------------------ 756| 590|} master.c:isc_string_casehasprefix: 54| 6|isc_string_casehasprefix(const char *str, const char *prefix) { 55| 6| return strncasecmp(str, prefix, strlen(prefix)) == 0; 56| 6|} qp.c:isc_tid: 39| 1.20k|isc_tid(void) { 40| 1.20k| return isc__tid_local; 41| 1.20k|} mem.c:isc_tid: 39| 6.45M|isc_tid(void) { 40| 6.45M| return isc__tid_local; 41| 6.45M|} 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) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 151| 2| mdctx = EVP_MD_CTX_new(); 152| 2| INSIST(mdctx != NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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.22M|mallocx(size_t size, int flags) { 110| 3.22M| size_t alignment = MALLOCX_ALIGN_GET(flags); ------------------ | | 74| 3.22M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 3.22M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 111| 3.22M| size_t header_size = get_header_size(flags); 112| 3.22M| size_info *si; 113| | 114| 3.22M| if (MALLOCX_NEEDS_ALIGN(flags)) { ------------------ | | 81| 3.22M| (MALLOCX_ALIGN_GET(flags) > _Alignof(max_align_t)) | | ------------------ | | | | 74| 3.22M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | | | ------------------ | | | | | | 64| 3.22M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | | | ------------------ | | ------------------ | | | Branch (81:2): [True: 16, False: 3.22M] | | ------------------ ------------------ 115| 16| size_t bytes = ISC_CHECKED_ADD( ------------------ | | 40| 16| ({ \ | | 41| 16| typeof(a) _c; \ | | 42| 16| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 16| INSIST(!_overflow); \ | | ------------------ | | | | 202| 16|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 16| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 16, False: 0] | | | | | | ------------------ | | | | | | 54| 16| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 16| _c; \ | | 45| 16| }) ------------------ 116| 16| get_aligned_size(alignment, size), header_size); 117| 16| si = aligned_alloc(alignment, bytes); 118| 3.22M| } else { 119| 3.22M| si = malloc(ISC_CHECKED_ADD(size, header_size)); ------------------ | | 40| 3.22M| ({ \ | | 41| 3.22M| typeof(a) _c; \ | | 42| 3.22M| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 3.22M| INSIST(!_overflow); \ | | ------------------ | | | | 202| 3.22M|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 3.22M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 3.22M, False: 0] | | | | | | ------------------ | | | | | | 54| 3.22M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 3.22M| _c; \ | | 45| 3.22M| }) ------------------ 120| 3.22M| } 121| 3.22M| if (si == NULL) { ------------------ | Branch (121:6): [True: 0, False: 3.22M] ------------------ 122| 0| return NULL; 123| 0| } 124| 3.22M| si->size = size; 125| 3.22M| si->flags = flags; 126| | 127| 3.22M| void *ptr = (uint8_t *)si + header_size; 128| 3.22M| if (MALLOCX_ZERO_GET(flags)) { ------------------ | | 62| 3.22M|#define MALLOCX_ZERO_GET(flags) ((bool)(flags & MALLOCX_ZERO)) | | ------------------ | | | | 61| 3.22M|#define MALLOCX_ZERO ((int)0x40) | | ------------------ | | | Branch (62:33): [True: 22, False: 3.22M] | | ------------------ ------------------ 129| 22| memset(ptr, 0, size); 130| 22| } 131| | 132| 3.22M| return ptr; 133| 3.22M|} mem.c:get_header_size: 99| 9.68M|get_header_size(int flags) { 100| 9.68M| return get_aligned_size(MALLOCX_ALIGN_GET(flags), sizeof(size_info)); ------------------ | | 74| 9.68M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 9.68M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 101| 9.68M|} mem.c:get_aligned_size: 31| 9.68M|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| 9.68M| ({ \ | | 41| 9.68M| typeof(a) _c; \ | | 42| 9.68M| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 9.68M| INSIST(!_overflow); \ | | ------------------ | | | | 202| 9.68M|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 9.68M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 9.68M, False: 0] | | | | | | ------------------ | | | | | | 54| 9.68M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 9.68M| _c; \ | | 45| 9.68M| }) ------------------ 38| 9.68M|} mem.c:sdallocx: 136| 3.22M|sdallocx(void *ptr, size_t size, int flags) { 137| 3.22M| size_info *si = get_size_info(ptr, flags); 138| 3.22M| size_t alignment = MALLOCX_ALIGN_GET(flags); ------------------ | | 74| 3.22M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 3.22M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 139| 3.22M| size_t header_size = get_header_size(flags); 140| | 141| 3.22M| INSIST((flags & MALLOCX_LG_ALIGN_MASK) == ------------------ | | 202| 3.22M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 3.22M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 3.22M, False: 0] | | | | ------------------ | | | | 54| 3.22M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 142| 3.22M| (si->flags & MALLOCX_LG_ALIGN_MASK)); 143| | 144| 3.22M| if (MALLOCX_NEEDS_ALIGN(flags)) { ------------------ | | 81| 3.22M| (MALLOCX_ALIGN_GET(flags) > _Alignof(max_align_t)) | | ------------------ | | | | 74| 3.22M| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | | | ------------------ | | | | | | 64| 3.22M|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | | | ------------------ | | ------------------ | | | Branch (81:2): [True: 0, False: 3.22M] | | ------------------ ------------------ 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) | | | | ------------------ | | | | | | 53| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 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.22M| } else { 149| | free_sized(si, ISC_CHECKED_ADD(si->size, header_size)); ------------------ | | 40| 3.22M| ({ \ | | 41| 3.22M| typeof(a) _c; \ | | 42| 3.22M| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 3.22M| INSIST(!_overflow); \ | | ------------------ | | | | 202| 3.22M|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 53| 3.22M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 3.22M, False: 0] | | | | | | ------------------ | | | | | | 54| 3.22M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 3.22M| _c; \ | | 45| 3.22M| }) ------------------ 150| 3.22M| } 151| 3.22M|} mem.c:get_size_info: 104| 3.22M|get_size_info(void *ptr, int flags) { 105| 3.22M| return (size_info *)((uint8_t *)ptr - get_header_size(flags)); 106| 3.22M|} mem.c:free_sized: 42| 3.22M|free_sized(void *ptr, size_t size ISC_ATTR_UNUSED) { 43| 3.22M| free(ptr); 44| 3.22M|} mem.c:sallocx: 154| 60|sallocx(void *ptr, int flags) { 155| 60| size_info *si = get_size_info(ptr, flags); 156| | 157| 60| return si[0].size; 158| 60|} 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 122| 2| lex = *lexp; 123| 2| *lexp = NULL; 124| 2| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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)); \ | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 2| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | ------------------ | | | | 41| 148| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 74, False: 0] | | | | | Branch (41:11): [True: 74, False: 0] | | | | ------------------ | | | | 42| 74| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 74| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 74, False: 0] | | | | ------------------ | | | | 42| 74| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 353| | 354| 74| if (source == NULL) { ------------------ | Branch (354:6): [True: 0, False: 74] ------------------ 355| 0| if ((options & ISC_LEXOPT_NOMORE) != 0) { ------------------ | | 79| 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) ------------------ | | 160| 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 && ------------------ | | 78| 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) ------------------ | | 85| 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) { ------------------ | | 64| 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) { ------------------ | | 78| 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) | | ------------------ | | | | 65| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 63| 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) { ------------------ | | 160| 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( ------------------ | | 159| 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) != ------------------ | | 98| 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 | ------------------ | | 95| 8|#define ISC_LEXCOMMENT_C 0x01 ------------------ 476| 8| ISC_LEXCOMMENT_CPLUSPLUS)) != 0) ------------------ | | 96| 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)) ------------------ | | 97| 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 && ------------------ | | 78| 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 && ------------------ | | 85| 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) { ------------------ | | 64| 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) ------------------ | | 65| 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) { ------------------ | | 63| 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) { ------------------ | | 63| 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) ------------------ | | 67| 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| lex->last_was_eol = false; 545| 0| tokenp->type = isc_tokentype_unknown; 546| 0| tokenp->value.as_textregion.base = NULL; 547| 0| tokenp->value.as_textregion.length = 0; 548| 0| done = true; 549| 66| } else if (lex->specials[c]) { ------------------ | Branch (549:15): [True: 0, False: 66] ------------------ 550| 0| lex->last_was_eol = false; 551| 0| if ((c == '(' || c == ')') && ------------------ | Branch (551:10): [True: 0, False: 0] | Branch (551:22): [True: 0, False: 0] ------------------ 552| 0| (options & ISC_LEXOPT_DNSMULTILINE) != 0) ------------------ | | 78| 0|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (552:9): [True: 0, False: 0] ------------------ 553| 0| { 554| 0| if (c == '(') { ------------------ | Branch (554:10): [True: 0, False: 0] ------------------ 555| 0| if (lex->paren_count == 0) { ------------------ | Branch (555:11): [True: 0, False: 0] ------------------ 556| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 65| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 63| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 557| 0| } 558| 0| lex->paren_count++; 559| 0| } else { 560| 0| if (lex->paren_count == 0) { ------------------ | Branch (560:11): [True: 0, False: 0] ------------------ 561| 0| result = 562| 0| ISC_R_UNBALANCED; 563| 0| goto done; 564| 0| } 565| 0| lex->paren_count--; 566| 0| if (lex->paren_count == 0) { ------------------ | Branch (566:11): [True: 0, False: 0] ------------------ 567| 0| options = saved_options; 568| 0| } 569| 0| } 570| 0| continue; 571| 0| } else if (c == '{' && ------------------ | Branch (571:16): [True: 0, False: 0] ------------------ 572| 0| (options & ISC_LEXOPT_BTEXT) != 0) ------------------ | | 85| 0|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (572:9): [True: 0, False: 0] ------------------ 573| 0| { 574| 0| if (lex->brace_count != 0) { ------------------ | Branch (574:10): [True: 0, False: 0] ------------------ 575| 0| result = ISC_R_UNBALANCED; 576| 0| goto done; 577| 0| } 578| 0| lex->brace_count++; 579| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 65| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 63| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 580| 0| state = lexstate_btext; 581| 0| no_comments = true; 582| 0| continue; 583| 0| } 584| 0| tokenp->type = isc_tokentype_special; 585| 0| tokenp->value.as_char = c; 586| 0| done = true; 587| 66| } else if (isdigit((unsigned char)c) && ------------------ | Branch (587:15): [True: 24, False: 42] ------------------ 588| 24| (options & ISC_LEXOPT_NUMBER) != 0) ------------------ | | 66| 24|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ | Branch (588:8): [True: 2, False: 22] ------------------ 589| 2| { 590| 2| lex->last_was_eol = false; 591| 2| if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 84| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (591:9): [True: 0, False: 2] ------------------ 592| 0| (c == '8' || c == '9')) ------------------ | Branch (592:10): [True: 0, False: 0] | Branch (592:22): [True: 0, False: 0] ------------------ 593| 0| { 594| 0| state = lexstate_string; 595| 2| } else { 596| 2| state = lexstate_number; 597| 2| } 598| 2| goto no_read; 599| 64| } else { 600| 64| lex->last_was_eol = false; 601| 64| state = lexstate_string; 602| 64| goto no_read; 603| 64| } 604| 68| break; 605| 68| case lexstate_crlf: ------------------ | Branch (605:3): [True: 0, False: 1.01k] ------------------ 606| 0| if (c != '\n') { ------------------ | Branch (606:8): [True: 0, False: 0] ------------------ 607| 0| pushback(source, c); 608| 0| } 609| 0| tokenp->type = isc_tokentype_eol; 610| 0| done = true; 611| 0| lex->last_was_eol = true; 612| 0| break; 613| 4| case lexstate_number: ------------------ | Branch (613:3): [True: 4, False: 1.01k] ------------------ 614| 4| if (c == EOF || !isdigit((unsigned char)c)) { ------------------ | Branch (614:8): [True: 0, False: 4] | Branch (614:20): [True: 2, False: 2] ------------------ 615| 2| if (c == ' ' || c == '\t' || c == '\r' || ------------------ | Branch (615:9): [True: 2, False: 0] | Branch (615:21): [True: 0, False: 0] | Branch (615:34): [True: 0, False: 0] ------------------ 616| 0| c == '\n' || c == '\0' || c == EOF || ------------------ | Branch (616:9): [True: 0, False: 0] | Branch (616:22): [True: 0, False: 0] | Branch (616:35): [True: 0, False: 0] ------------------ 617| 0| lex->specials[c]) ------------------ | Branch (617:9): [True: 0, False: 0] ------------------ 618| 2| { 619| 2| int base; 620| 2| if ((options & ISC_LEXOPT_OCTAL) != 0) { ------------------ | | 84| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (620:10): [True: 0, False: 2] ------------------ 621| 0| base = 8; 622| 2| } else if ((options & ------------------ | Branch (622:17): [True: 0, False: 2] ------------------ 623| 2| ISC_LEXOPT_CNUMBER) != 0) ------------------ | | 81| 2|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ 624| 0| { 625| 0| base = 0; 626| 2| } else { 627| 2| base = 10; 628| 2| } 629| 2| pushback(source, c); 630| | 631| 2| result = isc_parse_uint32( 632| 2| &as_ulong, lex->data, base); 633| 2| if (result == ISC_R_SUCCESS) { ------------------ | Branch (633:10): [True: 2, False: 0] ------------------ 634| 2| tokenp->type = 635| 2| isc_tokentype_number; 636| 2| tokenp->value.as_ulong = 637| 2| as_ulong; 638| 2| } else if (result == ISC_R_BADNUMBER) { ------------------ | Branch (638:17): [True: 0, False: 0] ------------------ 639| 0| isc_tokenvalue_t *v; 640| | 641| 0| tokenp->type = 642| 0| isc_tokentype_string; 643| 0| v = &(tokenp->value); 644| 0| v->as_textregion.base = 645| 0| lex->data; 646| 0| v->as_textregion.length = 647| 0| (unsigned int)(lex->max_token - 648| 0| remaining); 649| 0| } else { 650| 0| goto done; 651| 0| } 652| 2| done = true; 653| 2| continue; 654| 2| } else if ((options & ISC_LEXOPT_CNUMBER) == ------------------ | | 81| 0|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ | Branch (654:16): [True: 0, False: 0] ------------------ 655| 0| 0 || 656| 0| ((c != 'x' && c != 'X') || ------------------ | Branch (656:11): [True: 0, False: 0] | Branch (656:23): [True: 0, False: 0] ------------------ 657| 0| (curr != &lex->data[1]) || ------------------ | Branch (657:10): [True: 0, False: 0] ------------------ 658| 0| (lex->data[0] != '0'))) ------------------ | Branch (658:10): [True: 0, False: 0] ------------------ 659| 0| { 660| | /* Above test supports hex numbers */ 661| 0| state = lexstate_string; 662| 0| } 663| 2| } else if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 84| 2|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (663:15): [True: 0, False: 2] ------------------ 664| 0| (c == '8' || c == '9')) ------------------ | Branch (664:9): [True: 0, False: 0] | Branch (664:21): [True: 0, False: 0] ------------------ 665| 0| { 666| 0| state = lexstate_string; 667| 0| } 668| 2| if (remaining == 0U) { ------------------ | Branch (668:8): [True: 0, False: 2] ------------------ 669| 0| grow_data(lex, &remaining, &curr, &prev); 670| 0| } 671| 2| INSIST(remaining > 0U); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 672| 2| *curr++ = c; 673| 2| *curr = '\0'; 674| 2| remaining--; 675| 2| break; 676| 876| case lexstate_string: ------------------ | Branch (676:3): [True: 876, False: 138] ------------------ 677| 876| if (!escaped && c == '=' && ------------------ | Branch (677:8): [True: 876, False: 0] | Branch (677:20): [True: 2, False: 874] ------------------ 678| 2| (options & ISC_LEXOPT_VPAIR) != 0) ------------------ | | 86| 2|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ | Branch (678:8): [True: 0, False: 2] ------------------ 679| 0| { 680| 0| if (remaining == 0U) { ------------------ | Branch (680:9): [True: 0, False: 0] ------------------ 681| 0| grow_data(lex, &remaining, &curr, 682| 0| &prev); 683| 0| } 684| 0| INSIST(remaining > 0U); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 685| 0| *curr++ = c; 686| 0| *curr = '\0'; 687| 0| remaining--; 688| 0| state = lexstate_vpairstart; 689| 0| break; 690| 0| } 691| 876| FALLTHROUGH; ------------------ | | 105| 876|#define FALLTHROUGH [[fallthrough]] ------------------ 692| 876| case lexstate_vpairstart: ------------------ | Branch (692:3): [True: 0, False: 1.01k] ------------------ 693| 876| if (state == lexstate_vpairstart) { ------------------ | Branch (693:8): [True: 0, False: 876] ------------------ 694| 0| if (c == '"' && ------------------ | Branch (694:9): [True: 0, False: 0] ------------------ 695| 0| (options & ISC_LEXOPT_QVPAIR) != 0) ------------------ | | 87| 0|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ | Branch (695:9): [True: 0, False: 0] ------------------ 696| 0| { 697| 0| no_comments = true; 698| 0| state = lexstate_qvpair; 699| 0| break; 700| 0| } 701| 0| state = lexstate_vpair; 702| 0| } 703| 876| FALLTHROUGH; ------------------ | | 105| 876|#define FALLTHROUGH [[fallthrough]] ------------------ 704| 876| case lexstate_vpair: ------------------ | Branch (704:3): [True: 0, False: 1.01k] ------------------ 705| | /* 706| | * EOF needs to be checked before lex->specials[c] 707| | * as lex->specials[EOF] is not a good idea. 708| | */ 709| 876| if (c == '\r' || c == '\n' || c == EOF || ------------------ | Branch (709:8): [True: 0, False: 876] | Branch (709:21): [True: 8, False: 868] | Branch (709:34): [True: 0, False: 868] ------------------ 710| 868| (!escaped && (c == ' ' || c == '\t' || c == '\0' || ------------------ | Branch (710:9): [True: 868, False: 0] | Branch (710:22): [True: 56, False: 812] | Branch (710:34): [True: 0, False: 812] | Branch (710:47): [True: 0, False: 812] ------------------ 711| 812| lex->specials[c]))) ------------------ | Branch (711:8): [True: 0, False: 812] ------------------ 712| 64| { 713| 64| pushback(source, c); 714| 64| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (714:9): [True: 0, False: 64] ------------------ 715| 0| result = source->result; 716| 0| goto done; 717| 0| } 718| 64| if (escaped && c == EOF) { ------------------ | Branch (718:9): [True: 0, False: 64] | Branch (718:20): [True: 0, False: 0] ------------------ 719| 0| result = ISC_R_UNEXPECTEDEND; 720| 0| goto done; 721| 0| } 722| 64| tokenp->type = (state == lexstate_string) ------------------ | Branch (722:20): [True: 64, False: 0] ------------------ 723| 64| ? isc_tokentype_string 724| 64| : isc_tokentype_vpair; 725| 64| tokenp->value.as_textregion.base = lex->data; 726| 64| tokenp->value.as_textregion.length = 727| 64| (unsigned int)(lex->max_token - 728| 64| remaining); 729| 64| done = true; 730| 64| continue; 731| 64| } 732| 812| if ((options & ISC_LEXOPT_ESCAPE) != 0) { ------------------ | | 82| 812|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ | Branch (732:8): [True: 812, False: 0] ------------------ 733| 812| escaped = (!escaped && c == '\\') ? true ------------------ | Branch (733:16): [True: 812, False: 0] | Branch (733:28): [True: 0, False: 812] ------------------ 734| 812| : false; 735| 812| } 736| 812| if (remaining == 0U) { ------------------ | Branch (736:8): [True: 0, False: 812] ------------------ 737| 0| grow_data(lex, &remaining, &curr, &prev); 738| 0| } 739| 812| INSIST(remaining > 0U); ------------------ | | 202| 812|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 812| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 812, False: 0] | | | | ------------------ | | | | 54| 812| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 740| 812| *curr++ = c; 741| 812| *curr = '\0'; 742| 812| remaining--; 743| 812| break; 744| 0| case lexstate_maybecomment: ------------------ | Branch (744:3): [True: 0, False: 1.01k] ------------------ 745| 0| if (c == '*' && (lex->comments & ISC_LEXCOMMENT_C) != 0) ------------------ | | 95| 0|#define ISC_LEXCOMMENT_C 0x01 ------------------ | Branch (745:8): [True: 0, False: 0] | Branch (745:20): [True: 0, False: 0] ------------------ 746| 0| { 747| 0| state = lexstate_ccomment; 748| 0| continue; 749| 0| } else if (c == '/' && (lex->comments & ------------------ | Branch (749:15): [True: 0, False: 0] | Branch (749:27): [True: 0, False: 0] ------------------ 750| 0| ISC_LEXCOMMENT_CPLUSPLUS) != 0) ------------------ | | 96| 0|#define ISC_LEXCOMMENT_CPLUSPLUS 0x02 ------------------ 751| 0| { 752| 0| state = lexstate_eatline; 753| 0| continue; 754| 0| } 755| 0| pushback(source, c); 756| 0| c = '/'; 757| 0| no_comments = false; 758| 0| state = saved_state; 759| 0| goto no_read; 760| 0| case lexstate_ccomment: ------------------ | Branch (760:3): [True: 0, False: 1.01k] ------------------ 761| 0| if (c == EOF) { ------------------ | Branch (761:8): [True: 0, False: 0] ------------------ 762| 0| result = ISC_R_UNEXPECTEDEND; 763| 0| goto done; 764| 0| } 765| 0| if (c == '*') { ------------------ | Branch (765:8): [True: 0, False: 0] ------------------ 766| 0| state = lexstate_ccommentend; 767| 0| } 768| 0| break; 769| 0| case lexstate_ccommentend: ------------------ | Branch (769:3): [True: 0, False: 1.01k] ------------------ 770| 0| if (c == EOF) { ------------------ | Branch (770:8): [True: 0, False: 0] ------------------ 771| 0| result = ISC_R_UNEXPECTEDEND; 772| 0| goto done; 773| 0| } 774| 0| if (c == '/') { ------------------ | Branch (774:8): [True: 0, False: 0] ------------------ 775| | /* 776| | * C-style comments become a single space. 777| | * We do this to ensure that a comment will 778| | * act as a delimiter for strings and 779| | * numbers. 780| | */ 781| 0| c = ' '; 782| 0| no_comments = false; 783| 0| state = saved_state; 784| 0| goto no_read; 785| 0| } else if (c != '*') { ------------------ | Branch (785:15): [True: 0, False: 0] ------------------ 786| 0| state = lexstate_ccomment; 787| 0| } 788| 0| break; 789| 0| case lexstate_eatline: ------------------ | Branch (789:3): [True: 0, False: 1.01k] ------------------ 790| 0| if ((c == '\n') || (c == EOF)) { ------------------ | Branch (790:8): [True: 0, False: 0] | Branch (790:23): [True: 0, False: 0] ------------------ 791| 0| no_comments = false; 792| 0| state = saved_state; 793| 0| goto no_read; 794| 0| } 795| 0| break; 796| 0| case lexstate_qstring: ------------------ | Branch (796:3): [True: 0, False: 1.01k] ------------------ 797| 0| case lexstate_qvpair: ------------------ | Branch (797:3): [True: 0, False: 1.01k] ------------------ 798| 0| if (c == EOF) { ------------------ | Branch (798:8): [True: 0, False: 0] ------------------ 799| 0| result = ISC_R_UNEXPECTEDEND; 800| 0| goto done; 801| 0| } 802| 0| if (c == '"') { ------------------ | Branch (802:8): [True: 0, False: 0] ------------------ 803| 0| if (escaped) { ------------------ | Branch (803:9): [True: 0, False: 0] ------------------ 804| 0| escaped = false; 805| | /* 806| | * Overwrite the preceding backslash. 807| | */ 808| 0| INSIST(prev != NULL); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 809| 0| *prev = '"'; 810| 0| } else { 811| 0| tokenp->type = 812| 0| (state == lexstate_qstring) ------------------ | Branch (812:7): [True: 0, False: 0] ------------------ 813| 0| ? isc_tokentype_qstring 814| 0| : isc_tokentype_qvpair; 815| 0| tokenp->value.as_textregion.base = 816| 0| lex->data; 817| 0| tokenp->value.as_textregion.length = 818| 0| (unsigned int)(lex->max_token - 819| 0| remaining); 820| 0| no_comments = false; 821| 0| done = true; 822| 0| } 823| 0| } else { 824| 0| if (c == '\n' && !escaped && ------------------ | Branch (824:9): [True: 0, False: 0] | Branch (824:22): [True: 0, False: 0] ------------------ 825| 0| (options & ISC_LEXOPT_QSTRINGMULTILINE) == ------------------ | | 83| 0|#define ISC_LEXOPT_QSTRINGMULTILINE 0x0200 /*%< Allow multiline "" strings */ ------------------ | Branch (825:9): [True: 0, False: 0] ------------------ 826| 0| 0) 827| 0| { 828| 0| pushback(source, c); 829| 0| result = ISC_R_UNBALANCEDQUOTES; 830| 0| goto done; 831| 0| } 832| 0| if (c == '\\' && !escaped) { ------------------ | Branch (832:9): [True: 0, False: 0] | Branch (832:22): [True: 0, False: 0] ------------------ 833| 0| escaped = true; 834| 0| } else { 835| 0| escaped = false; 836| 0| } 837| 0| if (remaining == 0U) { ------------------ | Branch (837:9): [True: 0, False: 0] ------------------ 838| 0| grow_data(lex, &remaining, &curr, 839| 0| &prev); 840| 0| } 841| 0| INSIST(remaining > 0U); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 842| 0| prev = curr; 843| 0| *curr++ = c; 844| 0| *curr = '\0'; 845| 0| remaining--; 846| 0| } 847| 0| break; 848| 0| case lexstate_btext: ------------------ | Branch (848:3): [True: 0, False: 1.01k] ------------------ 849| 0| if (c == EOF) { ------------------ | Branch (849:8): [True: 0, False: 0] ------------------ 850| 0| result = ISC_R_UNEXPECTEDEND; 851| 0| goto done; 852| 0| } 853| 0| if (c == '\0') { ------------------ | Branch (853:8): [True: 0, False: 0] ------------------ 854| 0| tokenp->type = isc_tokentype_unknown; 855| 0| tokenp->value.as_textregion.base = NULL; 856| 0| tokenp->value.as_textregion.length = 0; 857| 0| done = true; 858| 0| break; 859| 0| } 860| 0| if (c == '{') { ------------------ | Branch (860:8): [True: 0, False: 0] ------------------ 861| 0| if (escaped) { ------------------ | Branch (861:9): [True: 0, False: 0] ------------------ 862| 0| escaped = false; 863| 0| } else { 864| 0| lex->brace_count++; 865| 0| } 866| 0| } else if (c == '}') { ------------------ | Branch (866:15): [True: 0, False: 0] ------------------ 867| 0| if (escaped) { ------------------ | Branch (867:9): [True: 0, False: 0] ------------------ 868| 0| escaped = false; 869| 0| } else { 870| 0| INSIST(lex->brace_count > 0); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 871| 0| lex->brace_count--; 872| 0| } 873| | 874| 0| if (lex->brace_count == 0) { ------------------ | Branch (874:9): [True: 0, False: 0] ------------------ 875| 0| tokenp->type = isc_tokentype_btext; 876| 0| tokenp->value.as_textregion.base = 877| 0| lex->data; 878| 0| tokenp->value.as_textregion.length = 879| 0| (unsigned int)(lex->max_token - 880| 0| remaining); 881| 0| no_comments = false; 882| 0| done = true; 883| 0| break; 884| 0| } 885| 0| } 886| | 887| 0| if (c == '\\' && !escaped) { ------------------ | Branch (887:8): [True: 0, False: 0] | Branch (887:21): [True: 0, False: 0] ------------------ 888| 0| escaped = true; 889| 0| } else { 890| 0| escaped = false; 891| 0| } 892| | 893| 0| if (remaining == 0U) { ------------------ | Branch (893:8): [True: 0, False: 0] ------------------ 894| 0| grow_data(lex, &remaining, &curr, &prev); 895| 0| } 896| 0| INSIST(remaining > 0U); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 897| 0| prev = curr; 898| 0| *curr++ = c; 899| 0| *curr = '\0'; 900| 0| remaining--; 901| 0| break; 902| 0| default: ------------------ | Branch (902:3): [True: 0, False: 1.01k] ------------------ 903| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 904| 1.01k| } 905| 1.01k| } while (!done); ------------------ | Branch (905:11): [True: 874, False: 74] ------------------ 906| | 907| 74| result = ISC_R_SUCCESS; 908| 74|done: 909| 74|#ifdef HAVE_FLOCKFILE 910| 74| if (source->is_file) { ------------------ | Branch (910:6): [True: 74, False: 0] ------------------ 911| 74| funlockfile(source->input); 912| 74| } 913| 74|#endif /* ifdef HAVE_FLOCKFILE */ 914| 74| return result; 915| 74|} isc_lex_getmastertoken: 919| 42| isc_tokentype_t expect, bool eol) { 920| 42| unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 63| 42|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 64| 42|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ 921| 42| ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 78| 42|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 82| 42|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 922| 42| isc_result_t result; 923| | 924| 42| if (expect == isc_tokentype_vpair) { ------------------ | Branch (924:6): [True: 0, False: 42] ------------------ 925| 0| options |= ISC_LEXOPT_VPAIR; ------------------ | | 86| 0|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 926| 42| } else if (expect == isc_tokentype_qvpair) { ------------------ | Branch (926:13): [True: 0, False: 42] ------------------ 927| 0| options |= ISC_LEXOPT_VPAIR; ------------------ | | 86| 0|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 928| 0| options |= ISC_LEXOPT_QVPAIR; ------------------ | | 87| 0|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ 929| 42| } else if (expect == isc_tokentype_qstring) { ------------------ | Branch (929:13): [True: 6, False: 36] ------------------ 930| 6| options |= ISC_LEXOPT_QSTRING; ------------------ | | 67| 6|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ 931| 36| } else if (expect == isc_tokentype_number) { ------------------ | Branch (931:13): [True: 2, False: 34] ------------------ 932| 2| options |= ISC_LEXOPT_NUMBER; ------------------ | | 66| 2|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ 933| 2| } 934| 42| result = isc_lex_gettoken(lex, options, token); 935| 42| if (result == ISC_R_RANGE) { ------------------ | Branch (935:6): [True: 0, False: 42] ------------------ 936| 0| isc_lex_ungettoken(lex, token); 937| 0| } 938| 42| if (result != ISC_R_SUCCESS) { ------------------ | Branch (938:6): [True: 0, False: 42] ------------------ 939| 0| return result; 940| 0| } 941| | 942| 42| if (eol && ((token->type == isc_tokentype_eol) || ------------------ | Branch (942:6): [True: 20, False: 22] | Branch (942:14): [True: 0, False: 20] ------------------ 943| 20| (token->type == isc_tokentype_eof))) ------------------ | Branch (943:7): [True: 0, False: 20] ------------------ 944| 0| { 945| 0| return ISC_R_SUCCESS; 946| 0| } 947| 42| if (token->type == isc_tokentype_string && ------------------ | Branch (947:6): [True: 40, False: 2] ------------------ 948| 40| (expect == isc_tokentype_qstring || expect == isc_tokentype_qvpair)) ------------------ | Branch (948:7): [True: 6, False: 34] | Branch (948:42): [True: 0, False: 34] ------------------ 949| 6| { 950| 6| return ISC_R_SUCCESS; 951| 6| } 952| 36| if (token->type == isc_tokentype_vpair && ------------------ | Branch (952:6): [True: 0, False: 36] ------------------ 953| 0| expect == isc_tokentype_qvpair) ------------------ | Branch (953:6): [True: 0, False: 0] ------------------ 954| 0| { 955| 0| return ISC_R_SUCCESS; 956| 0| } 957| 36| if (token->type != expect) { ------------------ | Branch (957:6): [True: 0, False: 36] ------------------ 958| 0| isc_lex_ungettoken(lex, token); 959| 0| if (token->type == isc_tokentype_eol || ------------------ | Branch (959:7): [True: 0, False: 0] ------------------ 960| 0| token->type == isc_tokentype_eof) ------------------ | Branch (960:7): [True: 0, False: 0] ------------------ 961| 0| { 962| 0| return ISC_R_UNEXPECTEDEND; 963| 0| } 964| 0| if (expect == isc_tokentype_number) { ------------------ | Branch (964:7): [True: 0, False: 0] ------------------ 965| 0| return ISC_R_BADNUMBER; 966| 0| } 967| 0| return ISC_R_UNEXPECTEDTOKEN; 968| 0| } 969| 36| return ISC_R_SUCCESS; 970| 36|} isc_lex_ungettoken: 1005| 6|isc_lex_ungettoken(isc_lex_t *lex, isc_token_t *tokenp) { 1006| 6| inputsource *source; 1007| | /* 1008| | * Unget the current token. 1009| | */ 1010| | 1011| 6| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1012| 6| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 6|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1013| 6| REQUIRE(source != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1014| 6| REQUIRE(tokenp != NULL); ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1015| 6| REQUIRE(isc_buffer_consumedlength(source->pushback) != 0 || ------------------ | | 198| 6|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 6| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1016| 6| tokenp->type == isc_tokentype_eof); 1017| | 1018| 6| UNUSED(tokenp); ------------------ | | 69| 6|#define UNUSED(x) (void)(x) ------------------ 1019| | 1020| 6| isc_buffer_first(source->pushback); 1021| 6| lex->paren_count = lex->saved_paren_count; 1022| 6| source->line = source->saved_line; 1023| | source->at_eof = false; 1024| 6|} isc_lex_getsourcename: 1047| 8|isc_lex_getsourcename(isc_lex_t *lex) { 1048| 8| inputsource *source; 1049| | 1050| 8| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1051| 8| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 8|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1052| | 1053| 8| if (source == NULL) { ------------------ | Branch (1053:6): [True: 0, False: 8] ------------------ 1054| 0| return NULL; 1055| 0| } 1056| | 1057| 8| return source->name; 1058| 8|} isc_lex_getsourceline: 1061| 22|isc_lex_getsourceline(isc_lex_t *lex) { 1062| 22| inputsource *source; 1063| | 1064| 22| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 22|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 44| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 22, False: 0] | | | | | Branch (41:11): [True: 22, False: 0] | | | | ------------------ | | | | 42| 22| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1065| 22| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 22|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1066| | 1067| 22| if (source == NULL) { ------------------ | Branch (1067:6): [True: 0, False: 22] ------------------ 1068| 0| return 0; 1069| 0| } 1070| | 1071| 22| return source->line; 1072| 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) { ------------------ | | 162| 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); ------------------ | | 151| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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) | | ------------------ | | | | 41| 66| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 66, False: 0] | | | | ------------------ | | | | 42| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | | | ------------------ | | | | | | 53| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:10): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 330| 2| REQUIRE(VALID_CONTEXT(isc__lctx)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 481| 8| REQUIRE(name != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 482| 8| REQUIRE(type == ISC_LOG_TOSYSLOG || type == ISC_LOG_TOFILE || ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 6] | | | | | Branch (41:11): [True: 0, False: 6] | | | | | Branch (41:11): [True: 4, False: 2] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6, False: 2] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 485| 8| REQUIRE(level >= ISC_LOG_CRITICAL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 486| 8| REQUIRE((flags & ~permitted) == 0); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 487| 8| REQUIRE(!(flags & ISC_LOG_UTC) || !(flags & ISC_LOG_TZINFO)); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 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| 866|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| 866| if (isc__lctx == NULL) { ------------------ | Branch (1208:6): [True: 0, False: 866] ------------------ 1209| 0| return false; 1210| 0| } 1211| 866| if (forcelog) { ------------------ | Branch (1211:6): [True: 0, False: 866] ------------------ 1212| 0| return true; 1213| 0| } 1214| | 1215| 866| int highest_level = atomic_load_acquire(&isc__lctx->highest_level); ------------------ | | 50| 866|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) ------------------ 1216| 866| if (level <= highest_level) { ------------------ | Branch (1216:6): [True: 4, False: 862] ------------------ 1217| 4| return true; 1218| 4| } 1219| 862| if (atomic_load_acquire(&isc__lctx->dynamic)) { ------------------ | | 50| 862|#define atomic_load_acquire(o) atomic_load_explicit((o), memory_order_acquire) | | ------------------ | | | Branch (50:32): [True: 0, False: 862] | | ------------------ ------------------ 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| 862| return false; 1227| 862|} isc__log_initialize: 1532| 2|isc__log_initialize(void) { 1533| 2| REQUIRE(isc__lctx == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 0, False: 2] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1249| 2| REQUIRE(category > ISC_LOGCATEGORY_DEFAULT && ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1252| 2| REQUIRE(level != ISC_LOG_DYNAMIC); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1253| 2| REQUIRE(format != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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; ------------------ | | 105| 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) | | ------------------ | | | | 53| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 0, False: 0] | | | | ------------------ | | | | 54| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 341| 2| REQUIRE(nloops > 0); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 47| 2| REQUIRE(type < ISC_MD_MAX); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 93| 2| REQUIRE(digest != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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: 491| 2|isc__mem_initialize(void) { 492| | /* 493| | * Check if the values copied from jemalloc still match; the 494| | * shim defines the MALLOCX_* macros too, so this holds on 495| | * every allocator path. 496| | */ 497| 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] | | ------------------ ------------------ 498| 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] | | ------------------ ------------------ 499| 2| MALLOCX_ALIGN(sizeof(void *))); 500| 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] | | ------------------ ------------------ 501| 2| MALLOCX_ALIGN(ISC_OS_CACHELINE_SIZE)); 502| | 503| |#ifdef JEMALLOC_API_SUPPORTED 504| | /* 505| | * ignore errors — volumetric-based purge in mem_put handles the rest 506| | * regardless 507| | */ 508| | 509| | (void)mallctl("background_thread", NULL, NULL, &(bool){ true }, 510| | sizeof(bool)); 511| | 512| | (void)mallctl("arenas.dirty_decay_ms", NULL, NULL, 513| | &default_dirty_decay_ms, sizeof(default_dirty_decay_ms)); 514| | 515| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".dirty_decay_ms", 516| | NULL, NULL, &default_dirty_decay_ms, 517| | sizeof(default_dirty_decay_ms)); 518| | 519| |#endif /* JEMALLOC_API_SUPPORTED */ 520| | 521| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 522| 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] | | ------------------ ------------------ 523| | 524| 2| if (debugging_enabled("ISC_MEM_DEBUGTRACE")) { ------------------ | Branch (524:6): [True: 0, False: 2] ------------------ 525| 0| mem_debugging |= ISC_MEM_DEBUGTRACE; ------------------ | | 41| 0|#define ISC_MEM_DEBUGTRACE 0x00000001U ------------------ 526| 0| } 527| | 528| 2| if (debugging_enabled("ISC_MEM_DEBUGRECORD")) { ------------------ | Branch (528:6): [True: 0, False: 2] ------------------ 529| 0| mem_debugging |= ISC_MEM_DEBUGRECORD; ------------------ | | 42| 0|#define ISC_MEM_DEBUGRECORD 0x00000002U ------------------ 530| 0| } 531| | 532| 2| if (debugging_enabled("ISC_MEM_DEBUGUSAGE")) { ------------------ | Branch (532:6): [True: 0, False: 2] ------------------ 533| 0| mem_debugging |= ISC_MEM_DEBUGUSAGE; ------------------ | | 43| 0|#define ISC_MEM_DEBUGUSAGE 0x00000004U ------------------ 534| 0| } 535| | 536| 2| isc_mem_create("default", &isc_g_mctx); ------------------ | | 236| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 537| 2|} isc_mem_setdebugging: 559| 4|isc_mem_setdebugging(isc_mem_t *ctx, unsigned int debugging) { 560| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 561| 4| REQUIRE(isc_mem_inuse(ctx) == 0); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 562| | 563| 4| ctx->debugging = debugging; 564| 4|} isc__mem_putanddetach: 724| 5.16k| int flags FLARG) { 725| 5.16k| REQUIRE(ctxp != NULL && VALID_CONTEXT(*ctxp)); ------------------ | | 198| 5.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 20.6k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 5.16k, False: 0] | | | | | Branch (41:11): [True: 5.16k, False: 0] | | | | | Branch (41:11): [True: 5.16k, False: 0] | | | | ------------------ | | | | 42| 5.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 726| 5.16k| REQUIRE(ptr != NULL); ------------------ | | 198| 5.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 5.16k, False: 0] | | | | ------------------ | | | | 42| 5.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 727| 5.16k| REQUIRE(size != 0); ------------------ | | 198| 5.16k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 5.16k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 5.16k, False: 0] | | | | ------------------ | | | | 42| 5.16k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 728| | 729| 5.16k| isc_mem_t *ctx = *ctxp; 730| 5.16k| *ctxp = NULL; 731| | 732| 5.16k| isc__mem_put(ctx, ptr, size, flags FLARG_PASS); 733| |#if ISC_MEM_TRACE 734| | isc_mem__detach(&ctx, func, file, line); 735| |#else 736| 5.16k| isc_mem_detach(&ctx); 737| 5.16k|#endif 738| 5.16k|} isc__mem_get: 741| 10.8k|isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) { 742| 10.8k| void *ptr = NULL; 743| | 744| 10.8k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 10.8k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 21.6k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 10.8k, False: 0] | | | | | Branch (41:11): [True: 10.8k, False: 0] | | | | ------------------ | | | | 42| 10.8k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 745| | 746| 10.8k| ptr = mem_get(ctx, size, flags); 747| | 748| 10.8k| mem_getstats(ctx, size); 749| 10.8k| ADD_TRACE(ctx, ptr, size, func, file, line); 750| | 751| 10.8k| return ptr; 752| 10.8k|} isc__mem_put: 755| 10.6k|isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size, int flags FLARG) { 756| 10.6k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 10.6k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 21.3k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 10.6k, False: 0] | | | | | Branch (41:11): [True: 10.6k, False: 0] | | | | ------------------ | | | | 42| 10.6k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 757| | 758| 10.6k| DELETE_TRACE(ctx, ptr, size, func, file, line); 759| | 760| 10.6k| mem_putstats(ctx, size); 761| 10.6k| mem_put(ctx, ptr, size, flags); 762| 10.6k|} isc__mem_allocate: 833| 52|isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) { 834| 52| void *ptr = NULL; 835| | 836| 52| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 52|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 104| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 52, False: 0] | | | | | Branch (41:11): [True: 52, False: 0] | | | | ------------------ | | | | 42| 52| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 837| | 838| 52| ptr = mem_get(ctx, size, flags); 839| | 840| | /* Recalculate the real allocated size */ 841| 52| size = sallocx(ptr, flags | ctx->jemalloc_flags); 842| | 843| 52| mem_getstats(ctx, size); 844| 52| ADD_TRACE(ctx, ptr, size, func, file, line); 845| | 846| 52| return ptr; 847| 52|} isc__mem_reallocate: 882| 14| int flags FLARG) { 883| 14| void *new_ptr = NULL; 884| | 885| 14| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 14|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 14, False: 0] | | | | | Branch (41:11): [True: 14, False: 0] | | | | ------------------ | | | | 42| 14| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 886| | 887| 14| if (old_ptr == NULL) { ------------------ | Branch (887:6): [True: 14, False: 0] ------------------ 888| 14| new_ptr = isc__mem_allocate(ctx, new_size, flags FLARG_PASS); 889| 14| } else if (new_size == 0) { ------------------ | Branch (889:13): [True: 0, False: 0] ------------------ 890| 0| isc__mem_free(ctx, old_ptr, flags FLARG_PASS); 891| 0| } else { 892| 0| size_t size = sallocx(old_ptr, flags | ctx->jemalloc_flags); 893| | 894| 0| DELETE_TRACE(ctx, old_ptr, size, func, file, line); 895| 0| mem_putstats(ctx, size); 896| | 897| 0| new_ptr = mem_realloc(ctx, old_ptr, new_size, flags); 898| | 899| | /* Recalculate the real allocated size */ 900| 0| size = sallocx(new_ptr, flags | ctx->jemalloc_flags); 901| | 902| 0| mem_getstats(ctx, size); 903| 0| ADD_TRACE(ctx, new_ptr, size, func, file, line); 904| 0| } 905| | 906| 14| return new_ptr; 907| 14|} isc__mem_free: 910| 8|isc__mem_free(isc_mem_t *ctx, void *ptr, int flags FLARG) { 911| 8| size_t size = 0; 912| | 913| 8| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 8, False: 0] | | | | | Branch (41:11): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 914| 8| REQUIRE(ptr != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 8, False: 0] | | | | ------------------ | | | | 42| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 915| | 916| 8| size = sallocx(ptr, flags | ctx->jemalloc_flags); 917| | 918| 8| DELETE_TRACE(ctx, ptr, size, func, file, line); 919| | 920| 8| mem_putstats(ctx, size); 921| 8| mem_put(ctx, ptr, size, flags); 922| 8|} isc__mem_strdup: 929| 28|isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) { 930| 28| size_t len; 931| 28| char *ns = NULL; 932| | 933| 28| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 198| 28|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 56| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 28, False: 0] | | | | | Branch (41:11): [True: 28, False: 0] | | | | ------------------ | | | | 42| 28| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 934| 28| REQUIRE(s != NULL); ------------------ | | 198| 28|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 28, False: 0] | | | | ------------------ | | | | 42| 28| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 935| | 936| 28| len = strlen(s) + 1; 937| | 938| 28| ns = isc__mem_allocate(mctx, len, 0 FLARG_PASS); 939| | 940| 28| strlcpy(ns, s, len); 941| | 942| 28| return ns; 943| 28|} isc_mem_setdestroycheck: 946| 2|isc_mem_setdestroycheck(isc_mem_t *ctx, bool flag) { 947| 2| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 948| | 949| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ ------------------ 950| | 951| 2| ctx->checkfree = flag; 952| | 953| 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } | | ------------------ ------------------ 954| 2|} isc_mem_inuse: 957| 4|isc_mem_inuse(isc_mem_t *ctx) { 958| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 959| | 960| 4| int_fast64_t inuse = 0; 961| | 962| 8| for (ssize_t i = -1; i < isc_tid_count(); i++) { ------------------ | Branch (962:23): [True: 4, False: 4] ------------------ 963| 4| inuse += atomic_load_relaxed(&ctx->stat[i].inuse); ------------------ | | 28| 4|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 964| 4| } 965| 4| INSIST(inuse >= 0); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 4, False: 0] | | | | ------------------ | | | | 54| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 966| | 967| 4| return (size_t)inuse; 968| 4|} isc__mempool_create: 1033| 3.15k| const char *name, isc_mempool_t **restrict mpctxp FLARG) { 1034| 3.15k| isc_mempool_t *restrict mpctx = NULL; 1035| 3.15k| size_t size = element_size; 1036| | 1037| 3.15k| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.30k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1038| 3.15k| REQUIRE(size > 0U); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1039| 3.15k| REQUIRE(mpctxp != NULL && *mpctxp == NULL); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.30k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1040| 3.15k| REQUIRE(name != NULL); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1041| | 1042| | /* 1043| | * Mempools are stored as a linked list of element. 1044| | */ 1045| 3.15k| if (size < sizeof(element)) { ------------------ | Branch (1045:6): [True: 0, False: 3.15k] ------------------ 1046| 0| size = sizeof(element); 1047| 0| } 1048| | 1049| | /* 1050| | * Allocate space for this pool, initialize values, and if all 1051| | * works well, attach to the memory context. 1052| | */ 1053| 3.15k| mpctx = isc_mem_get(mctx, sizeof(isc_mempool_t)); ------------------ | | 144| 3.15k|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1054| | 1055| 3.15k| *mpctx = (isc_mempool_t){ 1056| 3.15k| .size = size, 1057| 3.15k| .freemax = 1, 1058| 3.15k| .fillcount = 1, 1059| 3.15k| .name = strdup(name), 1060| 3.15k| }; 1061| | 1062| |#if ISC_MEM_TRACKLINES 1063| | if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) { 1064| | fprintf(stderr, 1065| | "create pool %p func %s file %s line %u mctx %p\n", 1066| | mpctx, func, file, line, mctx); 1067| | } 1068| |#endif /* ISC_MEM_TRACKLINES */ 1069| | 1070| 3.15k| isc_mem_attach(mctx, &mpctx->mctx); 1071| 3.15k| mpctx->magic = MEMPOOL_MAGIC; ------------------ | | 161| 3.15k|#define MEMPOOL_MAGIC ISC_MAGIC('M', 'E', 'M', 'p') | | ------------------ | | | | 31| 3.15k|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1072| | 1073| 3.15k| *mpctxp = (isc_mempool_t *)mpctx; 1074| | 1075| 3.15k| MCTXLOCK(mctx); ------------------ | | 69| 3.15k|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 3.15k| { \ | | | | 27| 3.15k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 3.15k| __FILE__, __LINE__)); \ | | | | 29| 3.15k| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 3.15k|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 3.15k| { \ | | | | | | | | 86| 3.15k| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 3.15k| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.15k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.15k] | | | | | | | | | | ------------------ | | | | | | | | | | 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 3.15k| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 3.15k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 3.15k| __FILE__, __LINE__)); \ | | | | 32| 3.15k| } | | ------------------ ------------------ 1076| 3.15k| ISC_LIST_INITANDAPPEND(mctx->pools, mpctx, link); ------------------ | | 106| 3.15k| __ISC_LIST_APPENDUNSAFE(list, elt, link) | | ------------------ | | | | 88| 3.15k| do { \ | | | | 89| 3.15k| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 1.57k, False: 1.57k] | | | | ------------------ | | | | 90| 1.57k| (list).tail->link.next = (elt); \ | | | | 91| 1.57k| } else { \ | | | | 92| 1.57k| (list).head = (elt); \ | | | | 93| 1.57k| } \ | | | | 94| 3.15k| (elt)->link.prev = (list).tail; \ | | | | 95| 3.15k| (elt)->link.next = NULL; \ | | | | 96| 3.15k| (list).tail = (elt); \ | | | | 97| 3.15k| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 3.15k] | | | | ------------------ | | ------------------ ------------------ 1077| 3.15k| mctx->poolcnt++; 1078| 3.15k| MCTXUNLOCK(mctx); ------------------ | | 70| 3.15k|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 3.15k| { \ | | | | 35| 3.15k| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 3.15k|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 3.15k| { \ | | | | | | | | 92| 3.15k| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 3.15k| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.15k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.15k] | | | | | | | | | | ------------------ | | | | | | | | | | 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 3.15k| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 3.15k| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 3.15k| __FILE__, __LINE__)); \ | | | | 38| 3.15k| } | | ------------------ ------------------ 1079| 3.15k|} isc__mempool_destroy: 1082| 3.15k|isc__mempool_destroy(isc_mempool_t **restrict mpctxp FLARG) { 1083| 3.15k| isc_mempool_t *restrict mpctx = NULL; 1084| 3.15k| isc_mem_t *mctx = NULL; 1085| 3.15k| element *restrict item = NULL; 1086| | 1087| 3.15k| REQUIRE(mpctxp != NULL); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1088| 3.15k| REQUIRE(VALID_MEMPOOL(*mpctxp)); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.30k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1089| | 1090| 3.15k| mpctx = *mpctxp; 1091| 3.15k| *mpctxp = NULL; 1092| | 1093| 3.15k| mctx = mpctx->mctx; 1094| | 1095| |#if ISC_MEM_TRACKLINES 1096| | if ((mctx->debugging & ISC_MEM_DEBUGTRACE) != 0) { 1097| | fprintf(stderr, 1098| | "destroy pool %p func %s file %s line %u mctx %p\n", 1099| | mpctx, func, file, line, mctx); 1100| | } 1101| |#endif 1102| | 1103| 3.15k| if (mpctx->allocated > 0) { ------------------ | Branch (1103:6): [True: 0, False: 3.15k] ------------------ 1104| 0| UNEXPECTED_ERROR("mempool %s leaked memory", mpctx->name); ------------------ | | 217| 0| isc_error_unexpected(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 1105| 0| } 1106| 3.15k| REQUIRE(mpctx->allocated == 0); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1107| | 1108| | /* 1109| | * Return any items on the free list 1110| | */ 1111| 3.22M| while (mpctx->items != NULL) { ------------------ | Branch (1111:9): [True: 3.21M, False: 3.15k] ------------------ 1112| 3.21M| INSIST(mpctx->freecount > 0); ------------------ | | 202| 3.21M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 3.21M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 3.21M, False: 0] | | | | ------------------ | | | | 54| 3.21M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1113| 3.21M| mpctx->freecount--; 1114| | 1115| 3.21M| item = mpctx->items; 1116| 3.21M| mpctx->items = item->next; 1117| | 1118| 3.21M| mem_putstats(mctx, mpctx->size); 1119| 3.21M| mem_put(mctx, item, mpctx->size, 0); 1120| 3.21M| } 1121| | 1122| | /* 1123| | * Remove our linked list entry from the memory context. 1124| | */ 1125| 3.15k| MCTXLOCK(mctx); ------------------ | | 69| 3.15k|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 3.15k| { \ | | | | 27| 3.15k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 3.15k| __FILE__, __LINE__)); \ | | | | 29| 3.15k| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 3.15k|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 3.15k| { \ | | | | | | | | 86| 3.15k| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 3.15k| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.15k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.15k] | | | | | | | | | | ------------------ | | | | | | | | | | 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 3.15k| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 3.15k| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 3.15k| __FILE__, __LINE__)); \ | | | | 32| 3.15k| } | | ------------------ ------------------ 1126| 3.15k| ISC_LIST_UNLINK(mctx->pools, mpctx, link); ------------------ | | 137| 3.15k| ISC_LIST_UNLINK_TYPE(list, elt, link, void) | | ------------------ | | | | 132| 3.15k| do { \ | | | | 133| 3.15k| ISC_LINK_INSIST(ISC_LINK_LINKED(elt, link)); \ | | | | 134| 3.15k| __ISC_LIST_UNLINKUNSAFE_TYPE(list, elt, link, type); \ | | | | ------------------ | | | | | | 109| 3.15k| do { \ | | | | | | 110| 3.15k| if ((elt)->link.next != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (110:7): [True: 0, False: 3.15k] | | | | | | ------------------ | | | | | | 111| 0| (elt)->link.next->link.prev = (elt)->link.prev; \ | | | | | | 112| 3.15k| } else { \ | | | | | | 113| 3.15k| ISC_INSIST((list).tail == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 3.15k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 3.15k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 114| 3.15k| (list).tail = (elt)->link.prev; \ | | | | | | 115| 3.15k| } \ | | | | | | 116| 3.15k| if ((elt)->link.prev != NULL) { \ | | | | | | ------------------ | | | | | | | Branch (116:7): [True: 1.57k, False: 1.57k] | | | | | | ------------------ | | | | | | 117| 1.57k| (elt)->link.prev->link.next = (elt)->link.next; \ | | | | | | 118| 1.57k| } else { \ | | | | | | 119| 1.57k| ISC_INSIST((list).head == (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 1.57k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 1.57k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 1.57k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 120| 1.57k| (list).head = (elt)->link.next; \ | | | | | | 121| 1.57k| } \ | | | | | | 122| 3.15k| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 3.15k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 123| 3.15k| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | | | ------------------ | | | | | | | | 18| 3.15k|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | | | ------------------ | | | | | | 124| 3.15k| ISC_INSIST((list).head != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 3.15k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 3.15k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 125| 3.15k| ISC_INSIST((list).tail != (elt)); \ | | | | | | ------------------ | | | | | | | | 53| 3.15k| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 3.15k, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 0| 0))) | | | | | | ------------------ | | | | | | 126| 3.15k| } while (0) | | | | | | ------------------ | | | | | | | Branch (126:11): [Folded, False: 3.15k] | | | | | | ------------------ | | | | ------------------ | | | | 135| 3.15k| } while (0) | | | | ------------------ | | | | | Branch (135:11): [Folded, False: 3.15k] | | | | ------------------ | | ------------------ ------------------ 1127| 3.15k| mctx->poolcnt--; 1128| 3.15k| MCTXUNLOCK(mctx); ------------------ | | 70| 3.15k|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 3.15k| { \ | | | | 35| 3.15k| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 3.15k|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 3.15k| { \ | | | | | | | | 92| 3.15k| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 3.15k| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 3.15k| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 3.15k] | | | | | | | | | | ------------------ | | | | | | | | | | 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__, \ | | | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 3.15k| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 3.15k| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 3.15k| __FILE__, __LINE__)); \ | | | | 38| 3.15k| } | | ------------------ ------------------ 1129| | 1130| 3.15k| free(mpctx->name); 1131| | 1132| 3.15k| mpctx->magic = 0; 1133| | 1134| | isc_mem_putanddetach(&mpctx->mctx, mpctx, sizeof(isc_mempool_t)); ------------------ | | 187| 3.15k| do { \ | | 188| 3.15k| isc__mem_putanddetach((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 189| 3.15k| (p) = NULL; \ | | 190| 3.15k| } while (0) | | ------------------ | | | Branch (190:11): [Folded, False: 3.15k] | | ------------------ ------------------ 1135| 3.15k|} isc__mempool_get: 1138| 6.01k|isc__mempool_get(isc_mempool_t *restrict mpctx FLARG) { 1139| 6.01k| element *restrict item = NULL; 1140| | 1141| 6.01k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 6.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12.0k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6.01k, False: 0] | | | | | Branch (41:11): [True: 6.01k, False: 0] | | | | ------------------ | | | | 42| 6.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1142| | 1143| 6.01k| mpctx->allocated++; 1144| | 1145| 6.01k| if (mpctx->items == NULL) { ------------------ | Branch (1145:6): [True: 3.14k, False: 2.87k] ------------------ 1146| 3.14k| isc_mem_t *mctx = mpctx->mctx; 1147| 3.14k|#if !__SANITIZE_ADDRESS__ 1148| 3.14k| const size_t fillcount = mpctx->fillcount; 1149| |#else 1150| | const size_t fillcount = 1; 1151| |#endif 1152| | /* 1153| | * We need to dip into the well. Fill up our free list. 1154| | */ 1155| 3.22M| for (size_t i = 0; i < fillcount; i++) { ------------------ | Branch (1155:22): [True: 3.21M, False: 3.14k] ------------------ 1156| 3.21M| item = mem_get(mctx, mpctx->size, 0); 1157| 3.21M| mem_getstats(mctx, mpctx->size); 1158| 3.21M| item->next = mpctx->items; 1159| 3.21M| mpctx->items = item; 1160| 3.21M| mpctx->freecount++; 1161| 3.21M| } 1162| 3.14k| } 1163| | 1164| 6.01k| INSIST(mpctx->items != NULL); ------------------ | | 202| 6.01k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6.01k, False: 0] | | | | ------------------ | | | | 54| 6.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1165| 6.01k| item = mpctx->items; 1166| | 1167| 6.01k| mpctx->items = item->next; 1168| | 1169| 6.01k| INSIST(mpctx->freecount > 0); ------------------ | | 202| 6.01k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6.01k, False: 0] | | | | ------------------ | | | | 54| 6.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1170| 6.01k| mpctx->freecount--; 1171| 6.01k| mpctx->gets++; 1172| | 1173| 6.01k| ADD_TRACE(mpctx->mctx, item, mpctx->size, func, file, line); 1174| | 1175| 6.01k| return item; 1176| 6.01k|} isc__mempool_put: 1179| 6.01k|isc__mempool_put(isc_mempool_t *restrict mpctx, void *mem FLARG) { 1180| 6.01k| element *restrict item = NULL; 1181| | 1182| 6.01k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 6.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12.0k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 6.01k, False: 0] | | | | | Branch (41:11): [True: 6.01k, False: 0] | | | | ------------------ | | | | 42| 6.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1183| 6.01k| REQUIRE(mem != NULL); ------------------ | | 198| 6.01k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 6.01k, False: 0] | | | | ------------------ | | | | 42| 6.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1184| | 1185| 6.01k| isc_mem_t *mctx = mpctx->mctx; 1186| 6.01k| const size_t freecount = mpctx->freecount; 1187| 6.01k|#if !__SANITIZE_ADDRESS__ 1188| 6.01k| const size_t freemax = mpctx->freemax; 1189| |#else 1190| | const size_t freemax = 0; 1191| |#endif 1192| | 1193| 6.01k| INSIST(mpctx->allocated > 0); ------------------ | | 202| 6.01k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 6.01k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 6.01k, False: 0] | | | | ------------------ | | | | 54| 6.01k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 1194| 6.01k| mpctx->allocated--; 1195| | 1196| 6.01k| DELETE_TRACE(mctx, mem, mpctx->size, func, file, line); 1197| | 1198| | /* 1199| | * If our free list is full, return this to the mctx directly. 1200| | */ 1201| 6.01k| if (freecount >= freemax) { ------------------ | Branch (1201:6): [True: 0, False: 6.01k] ------------------ 1202| 0| mem_putstats(mctx, mpctx->size); 1203| 0| mem_put(mctx, mem, mpctx->size, 0); 1204| 0| return; 1205| 0| } 1206| | 1207| | /* 1208| | * Otherwise, attach it to our free list and bump the counter. 1209| | */ 1210| 6.01k| item = (element *)mem; 1211| 6.01k| item->next = mpctx->items; 1212| 6.01k| mpctx->items = item; 1213| 6.01k| mpctx->freecount++; 1214| 6.01k|} isc_mempool_setfreemax: 1222| 3.15k| const unsigned int limit) { 1223| 3.15k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.30k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1224| 3.15k| mpctx->freemax = limit; 1225| 3.15k|} isc_mempool_getallocated: 1242| 3.15k|isc_mempool_getallocated(isc_mempool_t *restrict mpctx) { 1243| 3.15k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.30k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1244| | 1245| 3.15k| return mpctx->allocated; 1246| 3.15k|} isc_mempool_setfillcount: 1250| 3.15k| unsigned int const limit) { 1251| 3.15k| REQUIRE(VALID_MEMPOOL(mpctx)); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 6.30k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | | Branch (41:11): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1252| 3.15k| REQUIRE(limit > 0); ------------------ | | 198| 3.15k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 3.15k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 3.15k, False: 0] | | | | ------------------ | | | | 42| 3.15k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 1253| | 1254| 3.15k| mpctx->fillcount = limit; 1255| 3.15k|} isc__mem_create: 1517| 12|isc__mem_create(const char *name, isc_mem_t **mctxp FLARG) { 1518| 12| mem_create(name, mctxp, mem_debugging, 0); 1519| |#if ISC_MEM_TRACKLINES 1520| | if ((mem_debugging & ISC_MEM_DEBUGTRACE) != 0) { 1521| | fprintf(stderr, "create mctx %p func %s file %s line %u\n", 1522| | *mctxp, func, file, line); 1523| | } 1524| |#endif /* ISC_MEM_TRACKLINES */ 1525| 12|} mem.c:debugging_enabled: 474| 6|debugging_enabled(const char *name) { 475| 6| char env_buf[256]; 476| 6| size_t env_size = sizeof(env_buf); 477| | 478| 6| int r = uv_os_getenv(name, env_buf, &env_size); 479| 6| switch (r) { 480| 0| case 0: ------------------ | Branch (480:2): [True: 0, False: 6] ------------------ 481| 0| return true; 482| 6| case UV_ENOENT: ------------------ | Branch (482:2): [True: 6, False: 0] ------------------ 483| 6| return false; 484| 0| default: ------------------ | Branch (484:2): [True: 0, False: 6] ------------------ 485| 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| } ------------------ 486| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 487| 6| } 488| 6|} mem.c:mem_get: 382| 3.22M|mem_get(isc_mem_t *ctx, size_t size, int flags) { 383| 3.22M| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 374| 3.22M| if (s == 0) { \ | | ------------------ | | | Branch (374:6): [True: 4, False: 3.22M] | | ------------------ | | 375| 4| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 86| 4|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 376| 4| } ------------------ 384| | 385| 3.22M| void *ptr = mallocx(size, flags | ctx->jemalloc_flags); 386| 3.22M| CHECK_OOM(ptr, size); ------------------ | | 244| 3.22M|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (244:37): [True: 3.22M, False: 0] | | | Branch (244:54): [True: 0, False: 0] | | ------------------ ------------------ 387| | 388| 3.22M| return ptr; 389| 3.22M|} mem.c:mem_getstats: 457| 3.22M|mem_getstats(isc_mem_t *ctx, size_t size) { 458| | atomic_fetch_add_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 30| 3.22M| atomic_fetch_add_explicit((o), (v), memory_order_relaxed) ------------------ 459| 3.22M|} mem.c:mem_putstats: 465| 3.22M|mem_putstats(isc_mem_t *ctx, size_t size) { 466| | atomic_fetch_sub_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 32| 3.22M| atomic_fetch_sub_explicit((o), (v), memory_order_relaxed) ------------------ 467| 3.22M|} mem.c:mem_put: 428| 3.22M|mem_put(isc_mem_t *ctx, void *mem, size_t size, int flags) { 429| 3.22M| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 374| 3.22M| if (s == 0) { \ | | ------------------ | | | Branch (374:6): [True: 0, False: 3.22M] | | ------------------ | | 375| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 86| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 376| 0| } ------------------ 430| | 431| 3.22M| sdallocx(mem, size, flags | ctx->jemalloc_flags); 432| | 433| 3.22M| freed_bytes += size; 434| | 435| 3.22M| if (freed_bytes >= purge_threshold) { ------------------ | Branch (435:6): [True: 47, False: 3.22M] ------------------ 436| 47| freed_bytes = 0; 437| 47| mem_purge(); 438| 47| } 439| 3.22M|} mem.c:mem_purge: 400| 47|mem_purge(void) { 401| 47| isc_stdtime_t now = isc_stdtime_now(); 402| 47| isc_stdtime_t last = atomic_load_relaxed(&last_purge); ------------------ | | 28| 47|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 403| | 404| 47| if (now > last && ------------------ | Branch (404:6): [True: 2, False: 45] ------------------ 405| 47| atomic_compare_exchange_strong_acq_rel(&last_purge, &last, now)) ------------------ | | 71| 47| atomic_compare_exchange_strong_explicit( \ | | ------------------ | | | Branch (71:2): [True: 2, False: 0] | | ------------------ | | 72| 2| (o), (e), (d), memory_order_acq_rel, memory_order_acquire) ------------------ 406| 2| { 407| |#if defined(JEMALLOC_API_SUPPORTED) 408| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".decay", 409| | NULL, NULL, NULL, 0); 410| |#elif defined(__GLIBC__) 411| | (void)malloc_trim(0); 412| 2|#endif 413| 2| } 414| 47|} mem.c:mem_create: 594| 12| unsigned int jemalloc_flags) { 595| 12| isc_mem_t *ctx = NULL; 596| | 597| 12| REQUIRE(ctxp != NULL && *ctxp == NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 12, False: 0] | | | | | Branch (41:11): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 598| 12| REQUIRE(name != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 599| | 600| 12| ctx = mallocx(sizeof(*ctx), 601| 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)) ------------------ 602| 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] | | ------------------ ------------------ 603| | 604| 12| *ctx = (isc_mem_t){ 605| 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)) | | ------------------ ------------------ 606| 12| .debugging = debugging, 607| 12| .jemalloc_flags = jemalloc_flags, 608| 12| .checkfree = true, 609| 12| .name = strdup(name), 610| 12| }; 611| | 612| 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__, \ | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 12| } | | ------------------ ------------------ 613| 12| isc_refcount_init(&ctx->references, 1); ------------------ | | 44| 12|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 614| | 615| 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 (615:21): [True: 6.15k, False: 12] ------------------ 616| 6.15k| atomic_init(&ctx->stat_s[i].inuse, 0); 617| 6.15k| } 618| | 619| | /* Reserve the [-1] index for ISC_TID_UNKNOWN */ 620| 12| ctx->stat = &ctx->stat_s[1]; 621| | 622| 12| atomic_init(&ctx->hi_water, 0); 623| 12| atomic_init(&ctx->lo_water, 0); 624| | 625| 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] | | ------------------ ------------------ 626| | 627| |#if ISC_MEM_TRACKLINES 628| | if ((ctx->debugging & ISC_MEM_DEBUGRECORD) != 0) { 629| | unsigned int i; 630| | size_t debuglist_size = ISC_CHECKED_MUL(DEBUG_TABLE_COUNT, 631| | sizeof(debuglist_t)); 632| | 633| | ctx->debuglist = mallocx(debuglist_size, jemalloc_flags); 634| | CHECK_OOM(ctx->debuglist, debuglist_size); 635| | 636| | for (i = 0; i < DEBUG_TABLE_COUNT; i++) { 637| | ISC_LIST_INIT(ctx->debuglist[i]); 638| | } 639| | } 640| |#endif /* if ISC_MEM_TRACKLINES */ 641| | 642| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 643| 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] | | | | ------------------ | | ------------------ ------------------ 644| 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__, \ | | | | | | | | | | | | 227| 0| fmt ": %s (%d)", ##__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| } ------------------ 645| | 646| 12| *ctxp = ctx; 647| 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| 12|isc_ossl_wrap_rsa_exponent_is_allowed(EVP_PKEY *pkey) { 632| 12| BIGNUM *e = NULL; 633| 12| BIGNUM *emin = NULL; 634| 12| BIGNUM *emax = NULL; 635| 12| bool ok = false; 636| | 637| 12| if (EVP_PKEY_get_bn_param(pkey, OSSL_PKEY_PARAM_RSA_E, &e) != 1) { ------------------ | Branch (637:6): [True: 0, False: 12] ------------------ 638| 0| goto cleanup; 639| 0| } 640| | 641| 12| emin = BN_new(); 642| 12| if (emin == NULL || !BN_set_word(emin, 3)) { ------------------ | Branch (642:6): [True: 0, False: 12] | Branch (642:22): [True: 0, False: 12] ------------------ 643| 0| goto cleanup; 644| 0| } 645| 12| if (BN_hex2bn(&emax, "100000001") == 0) { ------------------ | Branch (645:6): [True: 0, False: 12] ------------------ 646| 0| goto cleanup; 647| 0| } 648| | 649| 12| ok = BN_is_odd(e) && BN_cmp(e, emin) >= 0 && BN_cmp(e, emax) <= 0; ------------------ | Branch (649:7): [True: 12, False: 0] | Branch (649:23): [True: 12, False: 0] | Branch (649:47): [True: 12, False: 0] ------------------ 650| | 651| 12|cleanup: 652| 12| BN_free(e); 653| 12| BN_free(emin); 654| 12| BN_free(emax); 655| 12| return ok; 656| 12|} isc_ossl_wrap_rsa_modulus_bits_in_range: 660| 12| size_t max) { 661| 12| REQUIRE(pkey != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 12, False: 0] | | | | ------------------ | | | | 42| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 662| | 663| 12| int bits = EVP_PKEY_bits(pkey); 664| 12| return bits > 0 && (size_t)bits >= min && (size_t)bits <= max; ------------------ | Branch (664:9): [True: 12, False: 0] | Branch (664:21): [True: 12, False: 0] | Branch (664:44): [True: 12, False: 0] ------------------ 665| 12|} isc_ossl_wrap_load_rsa_public_from_components: 727| 94| EVP_PKEY **pkeyp) { 728| 94| OSSL_PARAM_BLD *bld = NULL; 729| 94| EVP_PKEY_CTX *pctx = NULL; 730| 94| OSSL_PARAM *params = NULL; 731| 94| isc_result_t result; 732| | 733| 94| REQUIRE(pkeyp != NULL && *pkeyp == NULL); ------------------ | | 198| 94|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 188| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 94, False: 0] | | | | | Branch (41:11): [True: 94, False: 0] | | | | ------------------ | | | | 42| 94| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 734| 94| REQUIRE(c != NULL && c->n != NULL && c->e != NULL); ------------------ | | 198| 94|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 376| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 94, False: 0] | | | | | Branch (41:11): [True: 94, False: 0] | | | | | Branch (41:11): [True: 94, False: 0] | | | | ------------------ | | | | 42| 94| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 735| | 736| 94| bld = OSSL_PARAM_BLD_new(); 737| 94| if (bld == NULL) { ------------------ | Branch (737:6): [True: 0, False: 94] ------------------ 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| 94| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, c->n) != 1) { ------------------ | Branch (741:6): [True: 0, False: 94] ------------------ 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| 94| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, c->e) != 1) { ------------------ | Branch (745:6): [True: 0, False: 94] ------------------ 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| 94| params = OSSL_PARAM_BLD_to_param(bld); 750| 94| if (params == NULL) { ------------------ | Branch (750:6): [True: 0, False: 94] ------------------ 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| 94| pctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); 755| 94| if (pctx == NULL) { ------------------ | Branch (755:6): [True: 0, False: 94] ------------------ 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| 94| if (EVP_PKEY_fromdata_init(pctx) != 1) { ------------------ | Branch (759:6): [True: 0, False: 94] ------------------ 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| 94| if (EVP_PKEY_fromdata(pctx, pkeyp, EVP_PKEY_PUBLIC_KEY, params) != 1) { ------------------ | Branch (763:6): [True: 0, False: 94] ------------------ 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| 94| result = ISC_R_SUCCESS; 768| | 769| 94|cleanup: 770| 94| EVP_PKEY_CTX_free(pctx); 771| 94| OSSL_PARAM_free(params); 772| 94| OSSL_PARAM_BLD_free(bld); 773| 94| return result; 774| 94|} isc_ossl_wrap_rsa_components_cleanup: 23| 94|isc_ossl_wrap_rsa_components_cleanup(isc_ossl_wrap_rsa_components_t *c) { 24| 94| REQUIRE(c != NULL); ------------------ | | 198| 94|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 94| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 94, False: 0] | | | | ------------------ | | | | 42| 94| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 25| | 26| 94| if (!c->needs_cleanup) { ------------------ | Branch (26:6): [True: 0, False: 94] ------------------ 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| 94| BN_free(c->e); 37| 94| BN_free(c->n); 38| 94| BN_clear_free(c->d); 39| 94| BN_clear_free(c->p); 40| 94| BN_clear_free(c->q); 41| 94| BN_clear_free(c->dmp1); 42| 94| BN_clear_free(c->dmq1); 43| 94| BN_clear_free(c->iqmp); 44| | 45| | c->needs_cleanup = false; 46| 94|} isc_ossl_wrap_toresult: 49| 11|isc_ossl_wrap_toresult(isc_result_t fallback) { 50| 11| isc_result_t result = fallback; 51| 11| 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| 11| int reason = ERR_GET_REASON(err); 56| | 57| 11| 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: 11] ------------------ 63| 0| result = ISC_R_NOMEMORY; 64| 0| break; 65| 11| default: ------------------ | Branch (65:2): [True: 11, 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| 11| break; 75| 11| } 76| | 77| 11| return result; 78| 11|} isc__ossl_wrap_logged_toresult: 84| 11| int line) { 85| 11| 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| 11| if (category == ISC_LOGCATEGORY_INVALID) { ------------------ | Branch (92:6): [True: 11, False: 0] ------------------ 93| 11| goto done; 94| 11| } 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| 11|done: 122| 11| ERR_clear_error(); 123| 11| return result; 124| 0|} isc_parse_uint64: 28| 22|isc_parse_uint64(uint64_t *uip, const char *string, int base) { 29| 22| unsigned long long ui; 30| 22| char *endp = NULL; 31| | 32| 22| REQUIRE(uip != NULL && string != NULL); ------------------ | | 198| 22|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 44| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 22, False: 0] | | | | | Branch (41:11): [True: 22, False: 0] | | | | ------------------ | | | | 42| 22| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 33| | 34| 22| if (isalnum((unsigned char)string[0]) == 0 && string[0] != '+') { ------------------ | Branch (34:6): [True: 0, False: 22] | Branch (34:48): [True: 0, False: 0] ------------------ 35| 0| return ISC_R_BADNUMBER; 36| 0| } 37| | 38| 22| if (strtoll(string, NULL, base) < 0) { ------------------ | Branch (38:6): [True: 0, False: 22] ------------------ 39| 0| return ISC_R_BADNUMBER; 40| 0| } 41| | 42| 22| errno = 0; 43| 22| ui = strtoull(string, &endp, base); 44| | 45| 22| if (*endp != '\0') { ------------------ | Branch (45:6): [True: 0, False: 22] ------------------ 46| 0| return ISC_R_BADNUMBER; 47| 0| } 48| | 49| 22| switch (errno) { 50| 22| case 0: ------------------ | Branch (50:2): [True: 22, False: 0] ------------------ 51| 22| *uip = ui; 52| 22| return ISC_R_SUCCESS; 53| 0| case EINVAL: ------------------ | Branch (53:2): [True: 0, False: 22] ------------------ 54| 0| return ISC_R_BADNUMBER; 55| 0| case ERANGE: ------------------ | Branch (55:2): [True: 0, False: 22] ------------------ 56| 0| return ISC_R_RANGE; 57| 0| default: ------------------ | Branch (57:2): [True: 0, False: 22] ------------------ 58| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 65| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 66| 0| "unreachable"), \ | | | | 67| 0| __builtin_unreachable()) | | ------------------ ------------------ 59| 22| } 60| 22|} isc_parse_uint32: 63| 22|isc_parse_uint32(uint32_t *uip, const char *string, int base) { 64| 22| uint64_t val; 65| | 66| 22| RETERR(isc_parse_uint64(&val, string, base)); ------------------ | | 276| 22| { \ | | 277| 22| isc_result_t _r = (x); \ | | 278| 22| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 22] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 22| } ------------------ 67| 22| if (val > UINT32_MAX) { ------------------ | Branch (67:6): [True: 0, False: 22] ------------------ 68| 0| return ISC_R_RANGE; 69| 0| } 70| 22| *uip = (uint32_t)val; 71| 22| return ISC_R_SUCCESS; 72| 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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.43k|isc_rwlock_rdlock(isc_rwlock_t *rwl) { 159| 1.43k| uint32_t cnt = 0; 160| 1.43k| bool barrier_raised = false; 161| | 162| 1.43k| LIBISC_RWLOCK_RDLOCK_REQ(rwl); 163| | 164| 1.43k| while (true) { ------------------ | Branch (164:9): [True: 1.43k, Folded] ------------------ 165| 1.43k| read_indicator_arrive(rwl); 166| | 167| 1.43k| if (!writers_lock_islocked(rwl)) { ------------------ | Branch (167:7): [True: 1.43k, False: 0] ------------------ 168| | /* Acquired lock in read-only mode */ 169| 1.43k| break; 170| 1.43k| } 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.43k| if (barrier_raised) { ------------------ | Branch (183:6): [True: 0, False: 1.43k] ------------------ 184| 0| writers_barrier_lower(rwl); 185| 0| } 186| | 187| 1.43k| LIBISC_RWLOCK_RDLOCK_ACQ(rwl); 188| 1.43k|} isc_rwlock_rdunlock: 208| 1.43k|isc_rwlock_rdunlock(isc_rwlock_t *rwl) { 209| 1.43k| read_indicator_depart(rwl); 210| 1.43k| LIBISC_RWLOCK_RDUNLOCK(rwl); 211| 1.43k|} 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) | | ------------------ | | | | 41| 2.06k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2.06k, False: 0] | | | | ------------------ | | | | 42| 2.06k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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.43k|read_indicator_arrive(isc_rwlock_t *rwl) { 98| | (void)atomic_fetch_add_explicit(&rwl->readers_ingress, 1, 99| 1.43k| memory_order_seq_cst); 100| 1.43k|} rwlock.c:writers_lock_islocked: 135| 1.43k|writers_lock_islocked(isc_rwlock_t *rwl) { 136| 1.43k| return atomic_load_explicit(&rwl->writers_lock, memory_order_seq_cst) == 137| | ISC_RWLOCK_LOCKED; ------------------ | | 70| 1.43k|#define ISC_RWLOCK_LOCKED true ------------------ 138| 1.43k|} rwlock.c:read_indicator_depart: 103| 1.43k|read_indicator_depart(isc_rwlock_t *rwl) { 104| | (void)atomic_fetch_add_explicit(&rwl->readers_egress, 1, 105| 1.43k| memory_order_seq_cst); 106| 1.43k|} 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) | | ------------------ | | | | 41| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 20, False: 0] | | | | ------------------ | | | | 42| 20| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 29|isc_safe_memequal(const void *const s1, const void *const s2, size_t len) { 20| 29| return !CRYPTO_memcmp(s1, s2, len); 21| 29|} isc_safe_memwipe: 24| 82|isc_safe_memwipe(void *ptr, size_t len) { 25| 82| OPENSSL_cleanse(ptr, len); 26| 82|} isc_serial_lt: 22| 131|isc_serial_lt(uint32_t a, uint32_t b) { 23| | /* 24| | * Undefined => false 25| | */ 26| 131| if (a == (b ^ 0x80000000U)) { ------------------ | Branch (26:6): [True: 3, False: 128] ------------------ 27| 3| return false; 28| 3| } 29| 128| return ((int32_t)(a - b) < 0) ? true : false; ------------------ | Branch (29:9): [True: 62, False: 66] ------------------ 30| 131|} 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) | | ------------------ | | | | 41| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 4, False: 0] | | | | | Branch (41:11): [True: 4, False: 0] | | | | ------------------ | | | | 42| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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_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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 51| 2| REQUIRE(statsp != NULL && *statsp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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) | | | | ------------------ | | | | | | 53| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (53:11): [True: 2, False: 0] | | | | | | | Branch (53:11): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | 56| 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) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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| 637|isc_stdtime_now(void) { 38| 637| struct timespec ts; 39| | 40| 637| if (clock_gettime(CLOCKSOURCE, &ts) == -1) { ------------------ | | 29| 637|#define CLOCKSOURCE CLOCK_REALTIME_COARSE ------------------ | Branch (40:6): [True: 0, False: 637] ------------------ 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__, \ | | | | 227| 0| fmt ": %s (%d)", ##__VA_ARGS__, strerr, err); \ | | | | 228| 0| } | | ------------------ ------------------ 42| 0| } 43| 637| INSIST(ts.tv_sec > 0 && ts.tv_nsec >= 0 && ------------------ | | 202| 637|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2.54k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 637, False: 0] | | | | | Branch (53:11): [True: 637, False: 0] | | | | | Branch (53:11): [True: 637, False: 0] | | | | ------------------ | | | | 54| 637| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 44| 637| ts.tv_nsec < (long)NS_PER_SEC); 45| | 46| 637| return (isc_stdtime_t)ts.tv_sec; 47| 637|} 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__, \ | | | | | | 227| 0| fmt ": %s (%d)", ##__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) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 0, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 46| 2| REQUIRE(count < ISC_TID_MAX); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 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: 58| 2|isc_time_set(isc_time_t *t, unsigned int seconds, unsigned int nanoseconds) { 59| 2| REQUIRE(t != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 60| 2| REQUIRE(nanoseconds < NS_PER_SEC); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 61| | 62| 2| t->seconds = seconds; 63| 2| t->nanoseconds = nanoseconds; 64| 2|} isc_time_isepoch: 75| 2|isc_time_isepoch(const isc_time_t *t) { 76| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 77| | 78| 2| if (t->seconds == 0 && t->nanoseconds == 0) { ------------------ | Branch (78:6): [True: 2, False: 0] | Branch (78:25): [True: 2, False: 0] ------------------ 79| 2| return true; 80| 2| } 81| | 82| 0| return false; 83| 2|} isc_time_now: 112| 10|isc_time_now(void) { 113| | return time_now(CLOCKSOURCE); ------------------ | | 41| 10|#define CLOCKSOURCE CLOCK_REALTIME_COARSE ------------------ 114| 10|} isc_time_compare: 169| 2|isc_time_compare(const isc_time_t *t1, const isc_time_t *t2) { 170| 2| REQUIRE(ISC_VALID_TIME(t1)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 171| 2| REQUIRE(ISC_VALID_TIME(t2)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 172| | 173| 2| if (t1->seconds < t2->seconds) { ------------------ | Branch (173:6): [True: 0, False: 2] ------------------ 174| 0| return -1; 175| 0| } 176| 2| if (t1->seconds > t2->seconds) { ------------------ | Branch (176:6): [True: 0, False: 2] ------------------ 177| 0| return 1; 178| 0| } 179| 2| if (t1->nanoseconds < t2->nanoseconds) { ------------------ | Branch (179:6): [True: 0, False: 2] ------------------ 180| 0| return -1; 181| 0| } 182| 2| if (t1->nanoseconds > t2->nanoseconds) { ------------------ | Branch (182:6): [True: 1, False: 1] ------------------ 183| 1| return 1; 184| 1| } 185| 1| return 0; 186| 2|} isc_time_formattimestamp: 322| 2|isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) { 323| 2| time_t now; 324| 2| unsigned int flen; 325| 2| struct tm tm; 326| | 327| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 328| 2| REQUIRE(buf != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 329| 2| REQUIRE(len >= ISC_FORMATTIMESTAMP_SIZE); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 330| | 331| 2| now = (time_t)t->seconds; 332| 2| flen = strftime(buf, len, "%d-%b-%Y %X", localtime_r(&now, &tm)); 333| 2| if (flen == 0) { ------------------ | Branch (333:6): [True: 0, False: 2] ------------------ 334| 0| strlcpy(buf, ISC_FORMATTIMESTAMP_ERR, len); ------------------ | | 34| 0|#define ISC_FORMATTIMESTAMP_ERR "99-Bad-9999 99:99:99.999" ------------------ 335| 2| } else { 336| 2| snprintf(buf + flen, len - flen, ".%03u", 337| 2| t->nanoseconds / NS_PER_MS); 338| 2| } 339| 2|} isc_time_formatISO8601Lms: 385| 2|isc_time_formatISO8601Lms(const isc_time_t *t, char *buf, unsigned int len) { 386| 2| time_t now; 387| 2| unsigned int flen; 388| 2| struct tm tm; 389| | 390| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 391| 2| REQUIRE(buf != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 392| 2| REQUIRE(len >= ISC_FORMATISO8601LMS_SIZE); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 393| | 394| 2| now = (time_t)t->seconds; 395| 2| flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", localtime_r(&now, &tm)); 396| 2| if (flen == 0) { ------------------ | Branch (396:6): [True: 0, False: 2] ------------------ 397| 0| strlcpy(buf, ISC_FORMATISO8601LMS_ERR, len); ------------------ | | 36| 0|#define ISC_FORMATISO8601LMS_ERR "9999-99-99T99:99:99.999" ------------------ 398| 2| } else { 399| 2| snprintf(buf + flen, len - flen, ".%03u", 400| 2| t->nanoseconds / NS_PER_MS); 401| 2| } 402| 2|} isc_time_formatISO8601TZms: 405| 2|isc_time_formatISO8601TZms(const isc_time_t *t, char *buf, unsigned int len) { 406| 2| char strftime_buf[64] = { 0 }; 407| 2| char ms_buf[8] = { 0 }; 408| 2| time_t now; 409| 2| unsigned int flen; 410| 2| struct tm tm; 411| | 412| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 413| 2| REQUIRE(buf != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 414| 2| REQUIRE(len >= ISC_FORMATISO8601TZMS_SIZE); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 415| | 416| 2| now = (time_t)t->seconds; 417| 2| flen = strftime(strftime_buf, len, 418| 2| "%Y-%m-%dT%H:%M:%S.xxx%z:", localtime_r(&now, &tm)); 419| 2| snprintf(ms_buf, sizeof(ms_buf), ".%03u", t->nanoseconds / NS_PER_MS); 420| | 421| 2| if (flen == 0) { ------------------ | Branch (421:6): [True: 0, False: 2] ------------------ 422| 0| strlcpy(buf, ISC_FORMATISO8601TZMS_ERR, len); ------------------ | | 40| 0|#define ISC_FORMATISO8601TZMS_ERR "9999-99-99T99:99:99.999+99:99" ------------------ 423| 2| } else { 424| 2| size_t local_date_len = sizeof("yyyy-mm-ddThh:mm:ss") - 1ul; 425| 2| size_t ms_date_len = local_date_len + 4; 426| | 427| 2| INSIST(ms_date_len + 6 < ISC_FORMATISO8601TZMS_SIZE); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:10): [True: 2, False: 0] | | | | ------------------ | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 428| | 429| | /* Copy local time to the second. */ 430| 2| memmove(buf, strftime_buf, local_date_len); 431| | /* Add milliseconds. */ 432| 2| memmove(buf + local_date_len, ms_buf, 4); 433| | /* Add TZ hour offset. */ 434| 2| memmove(buf + ms_date_len, strftime_buf + ms_date_len, 3); 435| | /* Add TZ hour / minute seperator. */ 436| 2| buf[ms_date_len + 3] = ':'; 437| | /* Add TZ minutes offset. */ 438| 2| memmove(buf + ms_date_len + 4, strftime_buf + ms_date_len + 3, 439| 2| 2); 440| | /* Add terminating NUL */ 441| 2| buf[ms_date_len + 6] = 0; 442| 2| } 443| 2|} isc_time_formatISO8601ms: 463| 2|isc_time_formatISO8601ms(const isc_time_t *t, char *buf, unsigned int len) { 464| 2| time_t now; 465| 2| unsigned int flen; 466| 2| struct tm tm; 467| | 468| 2| REQUIRE(ISC_VALID_TIME(t)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:11): [True: 2, False: 0] | | | | | Branch (41:11): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 469| 2| REQUIRE(buf != NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 470| 2| REQUIRE(len >= ISC_FORMATISO8601MS_SIZE); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 41| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (41:10): [True: 2, False: 0] | | | | ------------------ | | | | 42| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (42:3): [True: 0, False: 0] | | | | ------------------ | | | | 43| 0| isc_assertiontype_require, #cond), \ | | | | 44| 0| 0))) | | ------------------ ------------------ 471| | 472| 2| now = (time_t)t->seconds; 473| 2| flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%S", gmtime_r(&now, &tm)); 474| 2| if (flen == 0) { ------------------ | Branch (474:6): [True: 0, False: 2] ------------------ 475| 0| strlcpy(buf, ISC_FORMATISO8601MS_ERR, len); ------------------ | | 38| 0|#define ISC_FORMATISO8601MS_ERR "9999-99-99T99:99:99.999Z" ------------------ 476| 2| } else { 477| 2| snprintf(buf + flen, len - flen, ".%03uZ", 478| 2| t->nanoseconds / NS_PER_MS); 479| 2| } 480| 2|} time.c:time_now: 86| 10|time_now(clockid_t clock) { 87| 10| isc_time_t t; 88| 10| struct timespec ts; 89| | 90| 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] | | ------------------ ------------------ 91| 10| INSIST(ts.tv_sec >= 0 && ts.tv_nsec >= 0 && ------------------ | | 202| 10|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 40| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [True: 10, False: 0] | | | | | Branch (53:11): [True: 10, False: 0] | | | | | Branch (53:11): [True: 10, False: 0] | | | | ------------------ | | | | 54| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 92| 10| ts.tv_nsec < (long)NS_PER_SEC); 93| | 94| | /* 95| | * Ensure the tv_sec value fits in t->seconds. 96| | */ 97| 10| INSIST(sizeof(ts.tv_sec) <= sizeof(t.seconds) || ------------------ | | 202| 10|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 53| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (53:11): [Folded, False: 10] | | | | | Branch (53:11): [True: 10, False: 0] | | | | ------------------ | | | | 54| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (54:3): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | 56| 0| 0))) | | ------------------ ------------------ 98| 10| ((ts.tv_sec | (unsigned int)-1) ^ (unsigned int)-1) == 0U); 99| | 100| 10| t.seconds = ts.tv_sec; 101| 10| t.nanoseconds = ts.tv_nsec; 102| | 103| 10| return t; 104| 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) | | | | | | ------------------ | | | | | | | | 53| 2| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (53:10): [True: 2, False: 0] | | | | | | | | ------------------ | | | | | | | | 54| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 56| 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|}