LLVMFuzzerInitialize: 37| 2|LLVMFuzzerInitialize(int *argc ISC_ATTR_UNUSED, char ***argv ISC_ATTR_UNUSED) { 38| 2| isc_mem_create("fuzz", &mctx); ------------------ | | 236| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 39| 2| isc_lex_create(mctx, 1024, &lex); 40| | 41| 2| return 0; 42| 2|} LLVMFuzzerTestOneInput: 45| 929|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 46| 929| isc_buffer_t buf; 47| 929| isc_result_t result; 48| 929| isc_token_t token; 49| 929| isc_tokentype_t expect; 50| 929| bool eol; 51| | 52| 929| if (size < sizeof(expect) + sizeof(eol)) { ------------------ | Branch (52:6): [True: 4, False: 925] ------------------ 53| 4| return 0; 54| 4| } 55| | 56| 925| (void)memmove(&expect, data, sizeof(expect)); 57| 925| data += sizeof(expect); 58| 925| size -= sizeof(expect); 59| | 60| 925| eol = *data != 0; 61| 925| data += 1; 62| 925| size -= 1; 63| | 64| 925| isc_buffer_constinit(&buf, data, size); ------------------ | | 557| 925| do { \ | | 558| 925| union { \ | | 559| 925| void *_var; \ | | 560| 925| const void *_const; \ | | 561| 925| } _deconst; \ | | 562| 925| _deconst._const = (_d); \ | | 563| 925| isc_buffer_init((_b), _deconst._var, (_l)); \ | | 564| 925| } while (0) | | ------------------ | | | Branch (564:11): [Folded, False: 925] | | ------------------ ------------------ 65| 925| isc_buffer_add(&buf, size); 66| 925| isc_buffer_setactive(&buf, size); 67| | 68| 925| CHECK(isc_lex_openbuffer(lex, &buf)); ------------------ | | 255| 925| { \ | | 256| 925| result = (r); \ | | 257| 925| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 925] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 925| } ------------------ 69| | 70| 8.77k| do { 71| 8.77k| result = isc_lex_getmastertoken(lex, &token, expect, eol); 72| 8.77k| } while (result == ISC_R_SUCCESS && token.type != isc_tokentype_eof); ------------------ | Branch (72:11): [True: 8.18k, False: 593] | Branch (72:38): [True: 7.85k, False: 332] ------------------ 73| | 74| 925|cleanup: 75| 925| return 0; 76| 925|} dns__acl_initialize: 470| 2|dns__acl_initialize(void) {} 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__dlz_initialize: 86| 2|dns__dlz_initialize(void) { 87| 2| isc_rwlock_init(&dlz_implock); 88| | ISC_LIST_INIT(dlz_implementations); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 89| 2|} 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|} dns__dyndb_initialize: 55| 2|dns__dyndb_initialize(void) { 56| 2| isc_mutex_init(&dyndb_lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 57| | ISC_LIST_INIT(dyndb_implementations); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 58| 2|} dns_lib_initialize: 36| 2|dns_lib_initialize(void) { 37| 2| isc__lib_initialize(); 38| 2| dns__lib_initialize(); 39| 2|} dns__lib_initialize: 44| 2|dns__lib_initialize(void) { 45| 2| if (isc_refcount_increment0(&dns__lib_references) > 0) { ------------------ | | 68| 2| ({ \ | | 69| 2| uint_fast32_t __v; \ | | 70| 2| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 2| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 71| 2| INSIST(__v < UINT32_MAX); \ | | ------------------ | | | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 2| __v; \ | | 73| 2| }) ------------------ | Branch (45:6): [True: 0, False: 2] ------------------ 46| 0| return; 47| 0| } 48| | 49| 2| dst__lib_initialize(); 50| 2| dns__acl_initialize(); 51| 2| dns__dlz_initialize(); 52| 2| dns__db_initialize(); 53| 2| dns__dyndb_initialize(); 54| 2| dns__qp_initialize(); 55| 2| dns__qpzone_initialize(); 56| 2| dns__zone_keymgmt_initialize(); 57| 2|} dst__opensslecdsa_init: 668| 4|dst__opensslecdsa_init(dst_func_t **funcp) { 669| 4| REQUIRE(funcp != NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 670| | 671| 4| if (*funcp == NULL) { ------------------ | Branch (671:6): [True: 4, False: 0] ------------------ 672| 4| *funcp = &opensslecdsa_functions; 673| 4| } 674| 4|} dst__openssleddsa_init: 642| 4|dst__openssleddsa_init(dst_func_t **funcp, unsigned char algorithm) { 643| 4| REQUIRE(funcp != NULL); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 644| | 645| 4| if (*funcp == NULL) { ------------------ | Branch (645:6): [True: 4, False: 0] ------------------ 646| 4| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (646:7): [True: 4, False: 0] ------------------ 647| 4| *funcp = &openssleddsa_functions; 648| 4| } 649| 4| } 650| 4|} openssleddsa_link.c:check_algorithm: 582| 4|check_algorithm(unsigned char algorithm) { 583| 4| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 584| 4| EVP_PKEY *pkey = NULL; 585| 4| const eddsa_alginfo_t *alginfo = NULL; 586| 4| const unsigned char *key = NULL; 587| 4| const unsigned char *sig = NULL; 588| 4| const unsigned char test[] = "test"; 589| 4| isc_result_t result = ISC_R_SUCCESS; 590| 4| size_t key_len, sig_len; 591| | 592| 4| if (evp_md_ctx == NULL) { ------------------ | Branch (592:6): [True: 0, False: 4] ------------------ 593| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 594| 0| } 595| | 596| 4| switch (algorithm) { 597| 0|#if HAVE_OPENSSL_ED448 598| 2| case DST_ALG_ED448: ------------------ | Branch (598:2): [True: 2, False: 2] ------------------ 599| 2| sig = ed448_sig; 600| 2| sig_len = sizeof(ed448_sig) - 1; 601| 2| key = ed448_pub; 602| 2| key_len = sizeof(ed448_pub) - 1; 603| 2| alginfo = openssleddsa_alg_info(algorithm); 604| 2| break; 605| 0|#endif /* HAVE_OPENSSL_ED448 */ 606| 2| case DST_ALG_ED25519: ------------------ | Branch (606:2): [True: 2, False: 2] ------------------ 607| 2| sig = ed25519_sig; 608| 2| sig_len = sizeof(ed25519_sig) - 1; 609| 2| key = ed25519_pub; 610| 2| key_len = sizeof(ed25519_pub) - 1; 611| 2| alginfo = openssleddsa_alg_info(algorithm); 612| 2| break; 613| 0| default: ------------------ | Branch (613:2): [True: 0, False: 4] ------------------ 614| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 615| 4| } 616| | 617| 4| INSIST(alginfo != NULL); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 618| 4| CHECK(raw_key_to_ossl(alginfo, 0, key, key_len, &pkey)); ------------------ | | 255| 4| { \ | | 256| 4| result = (r); \ | | 257| 4| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 4] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 4| } ------------------ 619| | 620| | /* 621| | * Check that we can verify the signature. 622| | */ 623| 4| if (EVP_DigestVerifyInit(evp_md_ctx, NULL, NULL, NULL, pkey) != 1 || ------------------ | Branch (623:6): [True: 0, False: 4] ------------------ 624| 4| EVP_DigestVerify(evp_md_ctx, sig, sig_len, test, ------------------ | Branch (624:6): [True: 0, False: 4] ------------------ 625| 4| sizeof(test) - 1) != 1) 626| 0| { 627| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 628| 0| } 629| | 630| 4|cleanup: 631| 4| if (pkey != NULL) { ------------------ | Branch (631:6): [True: 4, False: 0] ------------------ 632| 4| EVP_PKEY_free(pkey); 633| 4| } 634| 4| if (evp_md_ctx != NULL) { ------------------ | Branch (634:6): [True: 4, False: 0] ------------------ 635| | EVP_MD_CTX_destroy(evp_md_ctx); 636| 4| } 637| 4| ERR_clear_error(); 638| 4| return result; 639| 4|} openssleddsa_link.c:openssleddsa_alg_info: 54| 4|openssleddsa_alg_info(unsigned int key_alg) { 55| 4| if (key_alg == DST_ALG_ED25519) { ------------------ | Branch (55:6): [True: 2, False: 2] ------------------ 56| 2| static const eddsa_alginfo_t ed25519_alginfo = { 57| 2| .pkey_type = EVP_PKEY_ED25519, 58| 2| .nid = NID_ED25519, 59| 2| .key_size = DNS_KEY_ED25519SIZE, ------------------ | | 74| 2|#define DNS_KEY_ED25519SIZE 32 ------------------ 60| 2| .sig_size = DNS_SIG_ED25519SIZE, ------------------ | | 75| 2|#define DNS_SIG_ED25519SIZE 64 ------------------ 61| 2| }; 62| 2| return &ed25519_alginfo; 63| 2| } 64| 2|#if HAVE_OPENSSL_ED448 65| 2| if (key_alg == DST_ALG_ED448) { ------------------ | Branch (65:6): [True: 2, False: 0] ------------------ 66| 2| static const eddsa_alginfo_t ed448_alginfo = { 67| 2| .pkey_type = EVP_PKEY_ED448, 68| 2| .nid = NID_ED448, 69| 2| .key_size = DNS_KEY_ED448SIZE, ------------------ | | 77| 2|#define DNS_KEY_ED448SIZE 57 ------------------ 70| 2| .sig_size = DNS_SIG_ED448SIZE, ------------------ | | 78| 2|#define DNS_SIG_ED448SIZE 114 ------------------ 71| 2| }; 72| 2| return &ed448_alginfo; 73| 2| } 74| 0|#endif /* HAVE_OPENSSL_ED448 */ 75| 0| return NULL; 76| 2|} openssleddsa_link.c:raw_key_to_ossl: 80| 4| const unsigned char *key, size_t key_len, EVP_PKEY **pkey) { 81| 4| isc_result_t result; 82| 4| int pkey_type = alginfo->pkey_type; 83| 4| size_t len = alginfo->key_size; 84| | 85| 4| result = (private ? DST_R_INVALIDPRIVATEKEY : DST_R_INVALIDPUBLICKEY); ------------------ | Branch (85:12): [True: 0, False: 4] ------------------ 86| 4| if (key_len != len) { ------------------ | Branch (86:6): [True: 0, False: 4] ------------------ 87| 0| return result; 88| 0| } 89| | 90| 4| if (private) { ------------------ | Branch (90:6): [True: 0, False: 4] ------------------ 91| 0| *pkey = EVP_PKEY_new_raw_private_key(pkey_type, NULL, key, len); 92| 4| } else { 93| 4| *pkey = EVP_PKEY_new_raw_public_key(pkey_type, NULL, key, len); 94| 4| } 95| 4| if (*pkey == NULL) { ------------------ | Branch (95:6): [True: 0, False: 4] ------------------ 96| 0| return dst__openssl_toresult(result); ------------------ | | 28| 0| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 0| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 0| __FILE__, __LINE__) ------------------ 97| 0| } 98| | 99| 4| return ISC_R_SUCCESS; 100| 4|} dst__opensslrsa_init: 963| 12|dst__opensslrsa_init(dst_func_t **funcp, unsigned short algorithm) { 964| 12| REQUIRE(funcp != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 965| | 966| 12| if (*funcp == NULL) { ------------------ | Branch (966:6): [True: 12, False: 0] ------------------ 967| 12| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (967:7): [True: 12, False: 0] ------------------ 968| 12| *funcp = &opensslrsa_functions; 969| 12| } 970| 12| } 971| | 972| 12| if (rsa_exponent_min == NULL) { ------------------ | Branch (972:6): [True: 2, False: 10] ------------------ 973| 2| rsa_exponent_min = BN_new(); 974| 2| INSIST(rsa_exponent_min != NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 975| | 976| 2| RUNTIME_CHECK(BN_set_word(rsa_exponent_min, 3) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 977| 2| } 978| | 979| 12| if (rsa_exponent_max == NULL) { ------------------ | Branch (979:6): [True: 2, False: 10] ------------------ 980| 2| rsa_exponent_max = BN_new(); 981| 2| INSIST(rsa_exponent_max != NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 982| | 983| 2| RUNTIME_CHECK(BN_set_bit(rsa_exponent_max, 0) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 984| 2| RUNTIME_CHECK(BN_set_bit(rsa_exponent_max, 32) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 985| 2| } 986| 12|} opensslrsa_link.c:check_algorithm: 903| 12|check_algorithm(unsigned short algorithm) { 904| 12| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 905| 12| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 906| 12| EVP_PKEY *pkey = NULL; 907| 12| const EVP_MD *type = NULL; 908| 12| const unsigned char *sig = NULL; 909| 12| isc_result_t result = ISC_R_SUCCESS; 910| 12| size_t len; 911| | 912| 12| switch (algorithm) { 913| 2| case DST_ALG_RSASHA1: ------------------ | Branch (913:2): [True: 2, False: 10] ------------------ 914| 4| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (914:2): [True: 2, False: 10] ------------------ 915| 4| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 916| 4| sig = sha1_sig; 917| 4| len = sizeof(sha1_sig) - 1; 918| 4| break; 919| 2| case DST_ALG_RSASHA256: ------------------ | Branch (919:2): [True: 2, False: 10] ------------------ 920| 4| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (920:2): [True: 2, False: 10] ------------------ 921| 4| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 922| 4| sig = sha256_sig; 923| 4| len = sizeof(sha256_sig) - 1; 924| 4| break; 925| 2| case DST_ALG_RSASHA512: ------------------ | Branch (925:2): [True: 2, False: 10] ------------------ 926| 4| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (926:2): [True: 2, False: 10] ------------------ 927| 4| type = isc__crypto_md[ISC_MD_SHA512]; 928| 4| sig = sha512_sig; 929| 4| len = sizeof(sha512_sig) - 1; 930| 4| break; 931| 0| default: ------------------ | Branch (931:2): [True: 0, False: 12] ------------------ 932| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 933| 12| } 934| | 935| | /* 936| | * Construct pkey. 937| | */ 938| 12| c.e = BN_bin2bn(e_bytes, sizeof(e_bytes) - 1, NULL); 939| 12| c.n = BN_bin2bn(n_bytes, sizeof(n_bytes) - 1, NULL); 940| | 941| 12| result = isc_ossl_wrap_load_rsa_public_from_components(&c, &pkey); 942| 12| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 12|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 12, False: 0] | | | | ------------------ | | | | 55| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 943| | 944| | /* 945| | * Check that we can verify the signature. 946| | */ 947| 12| if (EVP_DigestInit_ex(evp_md_ctx, type, NULL) != 1 || ------------------ | Branch (947:6): [True: 0, False: 12] ------------------ 948| 12| EVP_DigestUpdate(evp_md_ctx, "test", 4) != 1 || ------------------ | Branch (948:6): [True: 0, False: 12] ------------------ 949| 12| EVP_VerifyFinal(evp_md_ctx, sig, len, pkey) != 1) ------------------ | Branch (949:6): [True: 0, False: 12] ------------------ 950| 0| { 951| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 952| 0| } 953| | 954| 12|cleanup: 955| 12| isc_ossl_wrap_rsa_components_cleanup(&c); 956| 12| EVP_PKEY_free(pkey); 957| | EVP_MD_CTX_destroy(evp_md_ctx); 958| 12| ERR_clear_error(); 959| 12| return result; 960| 12|} dns__qp_initialize: 180| 2|dns__qp_initialize(void) { 181| | /* zero common character marker not a valid shift position */ 182| 2| INSIST(0 < SHIFT_BITMAP); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, Folded] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 183| | /* first bit is common byte or escape byte */ 184| 2| dns_qpshift_t bit_one = SHIFT_BITMAP; 185| | /* second bit is position in escaped range */ 186| 2| dns_qpshift_t bit_two = SHIFT_BITMAP; 187| 2| bool escaping = true; 188| | 189| 514| for (unsigned int byte = 0; byte < BYTE_VALUES; byte++) { ------------------ | | 132| 514|#define BYTE_VALUES (UINT8_MAX + 1) ------------------ | Branch (189:30): [True: 512, False: 2] ------------------ 190| 512| if (qp_common_character(byte)) { ------------------ | Branch (190:7): [True: 82, False: 430] ------------------ 191| 82| escaping = false; 192| 82| bit_one++; 193| 82| dns_qp_byte_for_bit[bit_one] = byte; 194| 82| dns_qp_bits_for_byte[byte] = bit_one; 195| 430| } else if ('A' <= byte && byte <= 'Z') { ------------------ | Branch (195:14): [True: 326, False: 104] | Branch (195:29): [True: 52, False: 274] ------------------ 196| | /* map upper case to lower case */ 197| 52| dns_qpshift_t after_esc = bit_one + 1; 198| 52| dns_qpshift_t skip_punct = 'a' - '_'; 199| 52| dns_qpshift_t letter = byte - 'A'; 200| 52| dns_qpshift_t bit = after_esc + skip_punct + letter; 201| 52| dns_qp_bits_for_byte[byte] = bit; 202| | /* to simplify reverse conversion */ 203| 52| bit_two++; 204| 378| } else { 205| | /* non-hostname characters need to be escaped */ 206| 378| if (!escaping || bit_two >= SHIFT_OFFSET) { ------------------ | Branch (206:8): [True: 4, False: 374] | Branch (206:21): [True: 4, False: 370] ------------------ 207| 8| escaping = true; 208| 8| bit_one++; 209| 8| dns_qp_byte_for_bit[bit_one] = byte; 210| 8| bit_two = SHIFT_BITMAP; 211| 8| } 212| 378| dns_qp_bits_for_byte[byte] = bit_two << 8 | bit_one; 213| 378| bit_two++; 214| 378| } 215| 512| } 216| 2| ENSURE(bit_one < SHIFT_OFFSET); ------------------ | | 200| 2|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 2, False: 0] | | | | ------------------ | | | | 49| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 217| 2|} qp.c:qp_common_character: 930| 512|qp_common_character(uint8_t byte) { 931| 512| return ('-' <= byte && byte <= '9') || ('_' <= byte && byte <= 'z'); ------------------ | Branch (931:10): [True: 422, False: 90] | Branch (931:25): [True: 26, False: 396] | Branch (931:42): [True: 322, False: 164] | Branch (931:57): [True: 56, False: 266] ------------------ 932| 512|} dns__qpzone_initialize: 470| 2|dns__qpzone_initialize(void) { 471| 2.05k| for (size_t idx = 0; idx < ARRAY_SIZE(qpzone_buckets_g); ++idx) { ------------------ | | 98| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (471:23): [True: 2.04k, False: 2] ------------------ 472| 2.04k| NODE_INITLOCK(&qpzone_buckets_g[idx].lock); ------------------ | | 28| 2.04k|#define NODE_INITLOCK(l) isc_rwlock_init((l)) ------------------ 473| 2.04k| } 474| 2|} dns__zone_keymgmt_initialize: 16142| 2|dns__zone_keymgmt_initialize(void) { 16143| 2.05k| for (size_t idx = 0; idx < ARRAY_SIZE(keymgmt_buckets_g); ++idx) { ------------------ | | 98| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (16143:23): [True: 2.04k, False: 2] ------------------ 16144| 2.04k| isc_mutex_init(&keymgmt_buckets_g[idx].lock); ------------------ | | 68| 2.04k|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2.04k| { \ | | | | 80| 2.04k| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2.04k| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 2.04k| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2.04k] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2.04k| } | | ------------------ ------------------ 16145| 2.04k| } 16146| 2|} isc_hmac: 247| 12| unsigned int *digestlen) { 248| 12| EVP_MAC_CTX *ctx; 249| 12| size_t maclen; 250| | 251| 12| REQUIRE(type < ISC_MD_MAX); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 252| | 253| 12| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (253:6): [True: 0, False: 12] ------------------ 254| 0| return ISC_R_NOTIMPLEMENTED; 255| 0| } 256| | 257| 12| ctx = EVP_MAC_CTX_new(evp_hmac); 258| 12| RUNTIME_CHECK(ctx != NULL); ------------------ | | 245| 12| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 12, False: 0] | | ------------------ ------------------ 259| | 260| 12| if (EVP_MAC_init(ctx, key, keylen, md_to_hmac_params[type]) != 1) { ------------------ | Branch (260:6): [True: 0, False: 12] ------------------ 261| 0| goto fail; 262| 0| } 263| | 264| 12| if (EVP_MAC_update(ctx, buf, len) != 1) { ------------------ | Branch (264:6): [True: 0, False: 12] ------------------ 265| 0| goto fail; 266| 0| } 267| | 268| 12| maclen = *digestlen; 269| 12| if (EVP_MAC_final(ctx, digest, &maclen, maclen) != 1) { ------------------ | Branch (269:6): [True: 0, False: 12] ------------------ 270| 0| goto fail; 271| 0| } 272| | 273| 12| *digestlen = maclen; 274| | 275| 12| EVP_MAC_CTX_free(ctx); 276| 12| return ISC_R_SUCCESS; 277| | 278| 0|fail: 279| 0| ERR_clear_error(); 280| 0| EVP_MAC_CTX_free(ctx); 281| 0| return ISC_R_CRYPTOFAILURE; 282| 12|} isc_crypto_fips_mode: 916| 2|isc_crypto_fips_mode(void) { 917| | return EVP_default_properties_is_fips_enabled(NULL) != 0; 918| 2|} isc__crypto_initialize: 970| 2|isc__crypto_initialize(void) { 971| | /* 972| | * We call OPENSSL_cleanup() manually, in a correct order, thus disable 973| | * the automatic atexit() handler. 974| | */ 975| 2| uint64_t opts = OPENSSL_INIT_LOAD_CONFIG | OPENSSL_INIT_NO_ATEXIT; 976| | 977| 2| RUNTIME_CHECK(OPENSSL_init_ssl(opts, NULL) == 1); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 978| | 979| 2| register_algorithms(); 980| | 981| |#if defined(ENABLE_FIPS_MODE) 982| | if (isc_crypto_fips_enable() != ISC_R_SUCCESS) { 983| | ERR_clear_error(); 984| | FATAL_ERROR("Failed to toggle FIPS mode but is " 985| | "required for this build"); 986| | } 987| |#endif 988| | 989| | /* Protect ourselves against unseeded PRNG */ 990| 2| if (RAND_status() != 1) { ------------------ | Branch (990:6): [True: 0, False: 2] ------------------ 991| 0| isc_ossl_wrap_logged_toresult( ------------------ | | 26| 0| isc__ossl_wrap_logged_toresult(category, module, funcname, fallback, \ | | 27| 0| __FILE__, __LINE__) ------------------ 992| 0| ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_CRYPTO, 993| 0| "RAND_status", ISC_R_CRYPTOFAILURE); 994| 0| FATAL_ERROR("OpenSSL pseudorandom number generator " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 995| 0| "cannot be initialized (see the `PRNG not " 996| 0| "seeded' message in the OpenSSL FAQ)"); 997| 0| } 998| 2|} ossl3.c:register_algorithms: 133| 2|register_algorithms(void) { 134| 2| if (!isc_crypto_fips_mode()) { ------------------ | Branch (134:6): [True: 2, False: 0] ------------------ 135| 2| md_register_algorithm(MD5); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 136| | 137| 2| INSIST(evp_chacha20poly1305 == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 138| 2| evp_chacha20poly1305 = 139| 2| EVP_CIPHER_fetch(NULL, "ChaCha20-Poly1305", NULL); 140| | 141| 2| INSIST(evp_chacha20 == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 142| 2| evp_chacha20 = EVP_CIPHER_fetch(NULL, "ChaCha20", NULL); 143| 2| } 144| | 145| 2| md_register_algorithm(SHA1); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 146| 2| md_register_algorithm(SHA224); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 147| 2| md_register_algorithm(SHA256); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 148| 2| md_register_algorithm(SHA384); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 149| 2| md_register_algorithm(SHA512); ------------------ | | 124| 2| { \ | | 125| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 126| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 127| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (127:7): [True: 0, False: 2] | | ------------------ | | 128| 0| ERR_clear_error(); \ | | 129| 0| } \ | | 130| 2| } ------------------ 150| | 151| 2| INSIST(evp_aes_128_gcm == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 152| 2| evp_aes_128_gcm = EVP_CIPHER_fetch(NULL, "AES-128-GCM", NULL); 153| | 154| 2| INSIST(evp_aes_256_gcm == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 155| 2| evp_aes_256_gcm = EVP_CIPHER_fetch(NULL, "AES-256-GCM", NULL); 156| | 157| 2| INSIST(evp_aes_128_ctr == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 158| 2| evp_aes_128_ctr = EVP_CIPHER_fetch(NULL, "AES-128-CTR", NULL); 159| | 160| 2| INSIST(evp_aes_256_ctr == NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 161| 2| evp_aes_256_ctr = EVP_CIPHER_fetch(NULL, "AES-256-CTR", NULL); 162| | 163| | /* We _must_ have HMAC */ 164| 2| evp_hmac = EVP_MAC_fetch(NULL, "HMAC", NULL); 165| 2| if (evp_hmac == NULL) { ------------------ | Branch (165:6): [True: 0, False: 2] ------------------ 166| 0| FATAL_ERROR("OpenSSL failed to find an HMAC implementation. " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 167| 0| "Please make sure the default provider has an " 168| 0| "EVP_MAC-HMAC implementation"); 169| 0| } 170| | 171| 2| evp_tls_1_3_kdf = EVP_KDF_fetch(NULL, OSSL_KDF_NAME_TLS1_3_KDF, NULL); 172| 2| if (evp_tls_1_3_kdf == NULL) { ------------------ | Branch (172:6): [True: 0, False: 2] ------------------ 173| 0| FATAL_ERROR( ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 174| 0| "OpenSSL failed to find an TLS 1.3 KDF implementation." 175| 0| "Please make sure the default provider has an " 176| 0| "EVP_KDF-TLS13_KDF implementation"); 177| 0| } 178| | 179| 2| evp_hkdf = EVP_KDF_fetch(NULL, OSSL_KDF_NAME_HKDF, NULL); 180| 2| if (evp_hkdf == NULL) { ------------------ | Branch (180:6): [True: 0, False: 2] ------------------ 181| 0| FATAL_ERROR("OpenSSL failed to find an HKDF implementation. " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 182| 0| "Please make sure the default provider has an " 183| 0| "EVP_KDF-HKDF implementation"); 184| 0| } 185| | 186| 2| ERR_clear_error(); 187| | 188| 2| return ISC_R_SUCCESS; 189| 2|} isc__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_lex_getmastertoken.c:isc_buffer_init: 524| 925| const unsigned int length) { 525| 925| REQUIRE(b != NULL); ------------------ | | 198| 925|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 925| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 925, False: 0] | | | | ------------------ | | | | 43| 925| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 925| *b = (isc_buffer_t){ 528| 925| .base = base, 529| 925| .length = length, 530| 925| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 925|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 925| { \ | | | | 27| 925| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 925|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 925| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 925|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 925| } | | ------------------ ------------------ 531| 925| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 925|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 925| }; 533| 925|} isc_lex_getmastertoken.c:isc_buffer_add: 652| 925|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 925| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 925|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.85k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 925, False: 0] | | | | | Branch (42:11): [True: 925, False: 0] | | | | ------------------ | | | | 43| 925| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 925| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 925|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 925| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 925, False: 0] | | | | ------------------ | | | | 43| 925| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 925| b->used += n; 657| 925|} isc_lex_getmastertoken.c:isc_buffer_setactive: 771| 925|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 925| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 925|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.85k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 925, False: 0] | | | | | Branch (42:11): [True: 925, False: 0] | | | | ------------------ | | | | 43| 925| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 925| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 925|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 925| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 925, False: 0] | | | | ------------------ | | | | 43| 925| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 925| b->active = b->current + n; 776| 925|} lex.c:isc_buffer_allocate: 1077| 942| const unsigned int length) { 1078| 942| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 198| 942|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.88k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 942, False: 0] | | | | | Branch (42:11): [True: 942, False: 0] | | | | ------------------ | | | | 43| 942| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1079| | 1080| 942| isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length); ------------------ | | 144| 942|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1081| 942| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1082| | 1083| 942| isc_buffer_init(dbuf, bdata, length); 1084| 942| dbuf->extra = length; 1085| 942| isc_buffer_setmctx(dbuf, mctx); 1086| | 1087| 942| *dbufp = dbuf; 1088| 942|} lex.c:isc_buffer_init: 524| 942| const unsigned int length) { 525| 942| REQUIRE(b != NULL); ------------------ | | 198| 942|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 942| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 942, False: 0] | | | | ------------------ | | | | 43| 942| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 942| *b = (isc_buffer_t){ 528| 942| .base = base, 529| 942| .length = length, 530| 942| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 942|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 942| { \ | | | | 27| 942| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 942|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 942| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 942|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 942| } | | ------------------ ------------------ 531| 942| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 942|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 942| }; 533| 942|} lex.c:isc_buffer_setmctx: 1091| 942|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1092| 942| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 942|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.88k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 942, False: 0] | | | | | Branch (42:11): [True: 942, False: 0] | | | | ------------------ | | | | 43| 942| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1093| | 1094| 942| b->mctx = mctx; 1095| 942|} lex.c:isc_buffer_free: 1154| 17|isc_buffer_free(isc_buffer_t **restrict dbufp) { 1155| 17| REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp)); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 68| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 17, False: 0] | | | | | Branch (42:11): [True: 17, False: 0] | | | | | Branch (42:11): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1156| 17| REQUIRE((*dbufp)->mctx != NULL); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1157| | 1158| 17| isc_buffer_t *dbuf = *dbufp; 1159| 17| isc_mem_t *mctx = dbuf->mctx; 1160| 17| unsigned int extra = dbuf->extra; 1161| | 1162| 17| *dbufp = NULL; /* destroy external reference */ 1163| | 1164| 17| isc_buffer_clearmctx(dbuf); 1165| | 1166| 17| isc_buffer_invalidate(dbuf); 1167| | isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra); ------------------ | | 171| 17| do { \ | | 172| 17| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 17| (p) = NULL; \ | | 174| 17| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 17] | | ------------------ ------------------ 1168| 17|} lex.c:isc_buffer_clearmctx: 1098| 17|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1099| 17| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 17, False: 0] | | | | | Branch (42:11): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1100| | 1101| 17| if (b->dynamic) { ------------------ | Branch (1101:6): [True: 0, False: 17] ------------------ 1102| 0| isc_mem_put(b->mctx, b->base, b->length); ------------------ | | 171| 0| do { \ | | 172| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 0| (p) = NULL; \ | | 174| 0| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 0] | | ------------------ ------------------ 1103| 0| b->dynamic = false; 1104| 0| } 1105| | 1106| | b->mctx = NULL; 1107| 17|} lex.c:isc_buffer_invalidate: 577| 17|isc_buffer_invalidate(isc_buffer_t *restrict b) { 578| 17| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 17, False: 0] | | | | | Branch (42:11): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 579| 17| REQUIRE(!ISC_LINK_LINKED(b, link)); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 580| 17| REQUIRE(b->mctx == NULL); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 581| | 582| 17| *b = (isc_buffer_t){ 583| 17| .magic = 0, 584| 17| }; 585| 17|} lex.c:isc_buffer_compact: 1048| 8.77k|isc_buffer_compact(isc_buffer_t *restrict b) { 1049| 8.77k| unsigned int length; 1050| 8.77k| void *src; 1051| | 1052| | /* 1053| | * Compact the used region by moving the remaining region so it occurs 1054| | * at the start of the buffer. The used region is shrunk by the size 1055| | * of the consumed region, and the consumed region is then made empty. 1056| | */ 1057| | 1058| 8.77k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 8.77k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8.77k, False: 0] | | | | | Branch (42:11): [True: 8.77k, False: 0] | | | | ------------------ | | | | 43| 8.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1059| | 1060| 8.77k| src = isc_buffer_current(b); ------------------ | | 145| 8.77k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1061| 8.77k| length = isc_buffer_remaininglength(b); ------------------ | | 159| 8.77k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 1062| 8.77k| if (length > 0U) { ------------------ | Branch (1062:6): [True: 4.83k, False: 3.94k] ------------------ 1063| 4.83k| (void)memmove(b->base, src, (size_t)length); 1064| 4.83k| } 1065| | 1066| 8.77k| if (b->active > b->current) { ------------------ | Branch (1066:6): [True: 0, False: 8.77k] ------------------ 1067| 0| b->active -= b->current; 1068| 8.77k| } else { 1069| 8.77k| b->active = 0; 1070| 8.77k| } 1071| 8.77k| b->current = 0; 1072| 8.77k| b->used = length; 1073| 8.77k|} lex.c:isc_buffer_usedregion: 616| 17| isc_region_t *restrict r) { 617| 17| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 17, False: 0] | | | | | Branch (42:11): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 17| REQUIRE(r != NULL); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 17| r->base = b->base; 621| 17| r->length = b->used; 622| 17|} lex.c:isc_buffer_copyregion: 1192| 17| const isc_region_t *restrict r) { 1193| 17| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 17, False: 0] | | | | | Branch (42:11): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1194| 17| REQUIRE(r != NULL); ------------------ | | 198| 17|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 17, False: 0] | | | | ------------------ | | | | 43| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1195| | 1196| 17| if (b->mctx) { ------------------ | Branch (1196:6): [True: 17, False: 0] ------------------ 1197| 17| RETERR(isc_buffer_reserve(b, r->length)); ------------------ | | 276| 17| { \ | | 277| 17| isc_result_t _r = (x); \ | | 278| 17| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (278:7): [True: 0, False: 17] | | ------------------ | | 279| 0| return ((_r)); \ | | 280| 0| } \ | | 281| 17| } ------------------ 1198| 17| } 1199| | 1200| 17| if (r->length > isc_buffer_availablelength(b)) { ------------------ | | 161| 17|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1200:6): [True: 0, False: 17] ------------------ 1201| 0| return ISC_R_NOSPACE; 1202| 0| } 1203| | 1204| 17| if (r->length > 0U) { ------------------ | Branch (1204:6): [True: 17, False: 0] ------------------ 1205| 17| memmove(isc_buffer_used(b), r->base, r->length); ------------------ | | 149| 17| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1206| 17| b->used += r->length; 1207| 17| } 1208| | 1209| 17| return ISC_R_SUCCESS; 1210| 17|} lex.c:isc_buffer_reserve: 1110| 15.8M|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1111| 15.8M| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 198| 15.8M|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 31.7M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 15.8M, False: 0] | | | | | Branch (42:11): [True: 15.8M, False: 0] | | | | ------------------ | | | | 43| 15.8M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1112| | 1113| 15.8M| size_t len; 1114| | 1115| 15.8M| len = dbuf->length; 1116| 15.8M| if ((len - dbuf->used) >= size) { ------------------ | Branch (1116:6): [True: 15.8M, False: 0] ------------------ 1117| 15.8M| return ISC_R_SUCCESS; 1118| 15.8M| } 1119| | 1120| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1120:6): [True: 0, False: 0] ------------------ 1121| 0| return ISC_R_NOSPACE; 1122| 0| } 1123| | 1124| | /* Round to nearest buffer size increment */ 1125| 0| len = size + dbuf->used; 1126| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 296| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1127| | 1128| | /* Cap at UINT_MAX */ 1129| 0| if (len > UINT_MAX) { ------------------ | Branch (1129:6): [True: 0, False: 0] ------------------ 1130| 0| len = UINT_MAX; 1131| 0| } 1132| | 1133| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1133:6): [True: 0, False: 0] ------------------ 1134| 0| return ISC_R_NOMEMORY; 1135| 0| } 1136| | 1137| 0| if (!dbuf->dynamic) { ------------------ | Branch (1137:6): [True: 0, False: 0] ------------------ 1138| 0| void *old_base = dbuf->base; 1139| 0| dbuf->base = isc_mem_get(dbuf->mctx, len); ------------------ | | 144| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1140| 0| if (old_base != NULL) { ------------------ | Branch (1140:7): [True: 0, False: 0] ------------------ 1141| 0| memmove(dbuf->base, old_base, dbuf->used); 1142| 0| } 1143| 0| dbuf->dynamic = true; 1144| 0| } else { 1145| 0| dbuf->base = isc_mem_creget(dbuf->mctx, dbuf->base, ------------------ | | 152| 0| isc__mem_reget((c), (p), ISC_CHECKED_MUL((o), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 153| 0| ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 154| 0| ISC_MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 142| 0|#define ISC_MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1146| 0| dbuf->length, len, sizeof(char)); 1147| 0| } 1148| 0| dbuf->length = (unsigned int)len; 1149| | 1150| 0| return ISC_R_SUCCESS; 1151| 0|} lex.c:isc_buffer_putuint8: 869| 15.8M|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 15.8M| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 15.8M| { \ | | 858| 15.8M| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 15.8M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 31.7M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 15.8M, False: 0] | | | | | | | Branch (42:11): [True: 15.8M, False: 0] | | | | | | ------------------ | | | | | | 43| 15.8M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 15.8M| \ | | 860| 15.8M| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 15.8M, False: 0] | | ------------------ | | 861| 15.8M| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 15.8M| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 15.8M|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 15.8M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 15.8M, False: 0] | | | | | | ------------------ | | | | | | 49| 15.8M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 15.8M| } \ | | 864| 15.8M| \ | | 865| 15.8M| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 15.8M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 15.8M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 15.8M, False: 0] | | | | | | ------------------ | | | | | | 43| 15.8M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 15.8M| } ------------------ 871| | 872| 15.8M| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 15.8M| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 15.8M| b->used += sizeof(val); 874| 15.8M| cp[0] = val; 875| 15.8M|} lex.c:isc_buffer_getuint8: 848| 15.8M|isc_buffer_getuint8(isc_buffer_t *restrict b) { 849| 15.8M| uint8_t val = 0; 850| 15.8M| isc_result_t result = isc_buffer_peekuint8(b, &val); 851| 15.8M| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 15.8M|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 15.8M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 15.8M, False: 0] | | | | ------------------ | | | | 49| 15.8M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 852| 15.8M| b->current += sizeof(val); 853| 15.8M| return val; 854| 15.8M|} lex.c:isc_buffer_peekuint8: 839| 15.8M|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 840| 15.8M| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 15.8M| { \ | | 832| 15.8M| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 15.8M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 31.7M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 15.8M, False: 0] | | | | | | | Branch (42:11): [True: 15.8M, False: 0] | | | | | | ------------------ | | | | | | 43| 15.8M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 15.8M| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 15.8M] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 15.8M| } ------------------ 841| | 842| 15.8M| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 15.8M| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 843| | SET_IF_NOT_NULL(valp, (uint8_t)(cp[0])); ------------------ | | 104| 15.8M| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 15.8M, False: 0] | | ------------------ | | 105| 15.8M| *(obj) = (val); \ | | 106| 15.8M| } ------------------ 844| 15.8M| return ISC_R_SUCCESS; 845| 15.8M|} lex.c:isc_buffer_first: 790| 466|isc_buffer_first(isc_buffer_t *restrict b) { 791| 466| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 466|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 932| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 466, False: 0] | | | | | Branch (42:11): [True: 466, False: 0] | | | | ------------------ | | | | 43| 466| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 792| | 793| 466| b->current = 0; 794| 466|} isc_lib_initialize: 57| 2|isc_lib_initialize(void) { 58| 2| isc__lib_initialize(); 59| 2|} mem.c:isc_tid: 39| 2.85k|isc_tid(void) { 40| 2.85k| return isc__tid_local; 41| 2.85k|} isc__iterated_hash_initialize: 144| 2|isc__iterated_hash_initialize(void) { 145| 2| if (initialized) { ------------------ | Branch (145:6): [True: 0, False: 2] ------------------ 146| 0| return; 147| 0| } 148| | 149| 2| basectx = EVP_MD_CTX_new(); 150| 2| INSIST(basectx != NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 151| 2| mdctx = EVP_MD_CTX_new(); 152| 2| INSIST(mdctx != NULL); ------------------ | | 202| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 153| | 154| 2| RUNTIME_CHECK(EVP_DigestInit_ex(basectx, isc__crypto_md[ISC_MD_SHA1], ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | ------------------ ------------------ 155| 2| NULL) == 1); 156| | initialized = true; 157| 2|} mem.c:mallocx: 109| 2.83k|mallocx(size_t size, int flags) { 110| 2.83k| size_t alignment = MALLOCX_ALIGN_GET(flags); ------------------ | | 74| 2.83k| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 2.83k|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 111| 2.83k| size_t header_size = get_header_size(flags); 112| 2.83k| size_info *si; 113| | 114| 2.83k| if (MALLOCX_NEEDS_ALIGN(flags)) { ------------------ | | 81| 2.83k| (MALLOCX_ALIGN_GET(flags) > _Alignof(max_align_t)) | | ------------------ | | | | 74| 2.83k| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | | | ------------------ | | | | | | 64| 2.83k|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | | | ------------------ | | ------------------ | | | Branch (81:2): [True: 10, False: 2.82k] | | ------------------ ------------------ 115| 10| size_t bytes = ISC_CHECKED_ADD( ------------------ | | 40| 10| ({ \ | | 41| 10| typeof(a) _c; \ | | 42| 10| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 10| INSIST(!_overflow); \ | | ------------------ | | | | 202| 10|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 10| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 10, False: 0] | | | | | | ------------------ | | | | | | 55| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 10| _c; \ | | 45| 10| }) ------------------ 116| 10| get_aligned_size(alignment, size), header_size); 117| 10| si = aligned_alloc(alignment, bytes); 118| 2.82k| } else { 119| 2.82k| si = malloc(ISC_CHECKED_ADD(size, header_size)); ------------------ | | 40| 2.82k| ({ \ | | 41| 2.82k| typeof(a) _c; \ | | 42| 2.82k| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 2.82k| INSIST(!_overflow); \ | | ------------------ | | | | 202| 2.82k|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2.82k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2.82k, False: 0] | | | | | | ------------------ | | | | | | 55| 2.82k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 2.82k| _c; \ | | 45| 2.82k| }) ------------------ 120| 2.82k| } 121| 2.83k| if (si == NULL) { ------------------ | Branch (121:6): [True: 0, False: 2.83k] ------------------ 122| 0| return NULL; 123| 0| } 124| 2.83k| si->size = size; 125| 2.83k| si->flags = flags; 126| | 127| 2.83k| void *ptr = (uint8_t *)si + header_size; 128| 2.83k| if (MALLOCX_ZERO_GET(flags)) { ------------------ | | 62| 2.83k|#define MALLOCX_ZERO_GET(flags) ((bool)(flags & MALLOCX_ZERO)) | | ------------------ | | | | 61| 2.83k|#define MALLOCX_ZERO ((int)0x40) | | ------------------ | | | Branch (62:33): [True: 0, False: 2.83k] | | ------------------ ------------------ 129| 0| memset(ptr, 0, size); 130| 0| } 131| | 132| 2.83k| return ptr; 133| 2.83k|} mem.c:get_header_size: 99| 3.82k|get_header_size(int flags) { 100| 3.82k| return get_aligned_size(MALLOCX_ALIGN_GET(flags), sizeof(size_info)); ------------------ | | 74| 3.82k| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 3.82k|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 101| 3.82k|} mem.c:get_aligned_size: 31| 3.83k|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| 3.83k| ({ \ | | 41| 3.83k| typeof(a) _c; \ | | 42| 3.83k| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 3.83k| INSIST(!_overflow); \ | | ------------------ | | | | 202| 3.83k|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 3.83k| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 3.83k, False: 0] | | | | | | ------------------ | | | | | | 55| 3.83k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 3.83k| _c; \ | | 45| 3.83k| }) ------------------ 38| 3.83k|} mem.c:sdallocx: 136| 27|sdallocx(void *ptr, size_t size, int flags) { 137| 27| size_info *si = get_size_info(ptr, flags); 138| 27| size_t alignment = MALLOCX_ALIGN_GET(flags); ------------------ | | 74| 27| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | ------------------ | | | | 64| 27|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | ------------------ ------------------ 139| 27| size_t header_size = get_header_size(flags); 140| | 141| 27| INSIST((flags & MALLOCX_LG_ALIGN_MASK) == ------------------ | | 202| 27|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 27| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 27, False: 0] | | | | ------------------ | | | | 55| 27| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 142| 27| (si->flags & MALLOCX_LG_ALIGN_MASK)); 143| | 144| 27| if (MALLOCX_NEEDS_ALIGN(flags)) { ------------------ | | 81| 27| (MALLOCX_ALIGN_GET(flags) > _Alignof(max_align_t)) | | ------------------ | | | | 74| 27| (((size_t)1) << (flags & MALLOCX_LG_ALIGN_MASK)) | | | | ------------------ | | | | | | 64| 27|#define MALLOCX_LG_ALIGN_MASK ((int)0x3f) | | | | ------------------ | | ------------------ | | | Branch (81:2): [True: 0, False: 27] | | ------------------ ------------------ 145| 0| size_t bytes = ISC_CHECKED_ADD( ------------------ | | 40| 0| ({ \ | | 41| 0| typeof(a) _c; \ | | 42| 0| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 0| INSIST(!_overflow); \ | | ------------------ | | | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 0| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 0| _c; \ | | 45| 0| }) ------------------ 146| 0| get_aligned_size(alignment, size), header_size); 147| 0| free_aligned_sized(si, alignment, bytes); 148| 27| } else { 149| | free_sized(si, ISC_CHECKED_ADD(si->size, header_size)); ------------------ | | 40| 27| ({ \ | | 41| 27| typeof(a) _c; \ | | 42| 27| bool _overflow = ckd_add(&_c, a, b); \ | | 43| 27| INSIST(!_overflow); \ | | ------------------ | | | | 202| 27|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 27| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 27, False: 0] | | | | | | ------------------ | | | | | | 55| 27| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 44| 27| _c; \ | | 45| 27| }) ------------------ 150| 27| } 151| 27|} mem.c:get_size_info: 104| 960|get_size_info(void *ptr, int flags) { 105| 960| return (size_info *)((uint8_t *)ptr - get_header_size(flags)); 106| 960|} mem.c:free_sized: 42| 27|free_sized(void *ptr, size_t size ISC_ATTR_UNUSED) { 43| 27| free(ptr); 44| 27|} mem.c:sallocx: 154| 933|sallocx(void *ptr, int flags) { 155| 933| size_info *si = get_size_info(ptr, flags); 156| | 157| 933| return si[0].size; 158| 933|} isc_lex_create: 84| 2|isc_lex_create(isc_mem_t *mctx, size_t max_token, isc_lex_t **lexp) { 85| 2| isc_lex_t *lex; 86| | 87| | /* 88| | * Create a lexer. 89| | */ 90| 2| REQUIRE(lexp != NULL && *lexp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 91| | 92| 2| if (max_token == 0U) { ------------------ | Branch (92:6): [True: 0, False: 2] ------------------ 93| 0| max_token = 1; 94| 0| } 95| | 96| 2| lex = isc_mem_get(mctx, sizeof(*lex)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 97| 2| lex->data = isc_mem_get(mctx, max_token + 1); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 98| 2| lex->mctx = mctx; 99| 2| lex->max_token = max_token; 100| 2| lex->comments = 0; 101| 2| lex->comment_ok = true; 102| 2| lex->last_was_eol = true; 103| 2| lex->brace_count = 0; 104| 2| lex->paren_count = 0; 105| 2| lex->saved_paren_count = 0; 106| 2| memset(lex->specials, 0, 256); 107| 2| ISC_LIST_INIT(lex->sources); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 108| 2| lex->magic = LEX_MAGIC; ------------------ | | 48| 2|#define LEX_MAGIC ISC_MAGIC('L', 'e', 'x', '!') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 109| | 110| 2| *lexp = lex; 111| 2|} isc_lex_openbuffer: 233| 925|isc_lex_openbuffer(isc_lex_t *lex, isc_buffer_t *buffer) { 234| 925| char name[128]; 235| | 236| | /* 237| | * Make 'buffer' the current input source for 'lex'. 238| | */ 239| | 240| 925| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 925|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.85k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 925, False: 0] | | | | | Branch (42:11): [True: 925, False: 0] | | | | ------------------ | | | | 43| 925| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 241| | 242| 925| snprintf(name, sizeof(name), "buffer-%p", buffer); 243| | 244| 925| new_source(lex, false, false, buffer, name); 245| 925| return ISC_R_SUCCESS; 246| 925|} isc_lex_gettoken: 330| 8.77k|isc_lex_gettoken(isc_lex_t *lex, unsigned int options, isc_token_t *tokenp) { 331| 8.77k| inputsource *source; 332| 8.77k| int c; 333| 8.77k| bool done = false; 334| 8.77k| bool no_comments = false; 335| 8.77k| bool escaped = false; 336| 8.77k| lexstate state = lexstate_start; 337| 8.77k| lexstate saved_state = lexstate_start; 338| 8.77k| isc_buffer_t *buffer; 339| 8.77k| FILE *stream; 340| 8.77k| char *curr, *prev; 341| 8.77k| size_t remaining; 342| 8.77k| uint32_t as_ulong; 343| 8.77k| unsigned int saved_options; 344| 8.77k| isc_result_t result; 345| | 346| | /* 347| | * Get the next token. 348| | */ 349| | 350| 8.77k| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 8.77k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17.5k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8.77k, False: 0] | | | | | Branch (42:11): [True: 8.77k, False: 0] | | | | ------------------ | | | | 43| 8.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 351| 8.77k| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 8.77k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 352| 8.77k| REQUIRE(tokenp != NULL); ------------------ | | 198| 8.77k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8.77k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8.77k, False: 0] | | | | ------------------ | | | | 43| 8.77k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 353| | 354| 8.77k| if (source == NULL) { ------------------ | Branch (354:6): [True: 0, False: 8.77k] ------------------ 355| 0| if ((options & ISC_LEXOPT_NOMORE) != 0) { ------------------ | | 78| 0|#define ISC_LEXOPT_NOMORE 0x0040 /*%< Want "no more" token. */ ------------------ | Branch (355:7): [True: 0, False: 0] ------------------ 356| 0| tokenp->type = isc_tokentype_nomore; 357| 0| return ISC_R_SUCCESS; 358| 0| } 359| 0| return ISC_R_NOMORE; 360| 0| } 361| | 362| 8.77k| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (362:6): [True: 0, False: 8.77k] ------------------ 363| 0| return source->result; 364| 0| } 365| | 366| 8.77k| lex->saved_paren_count = lex->paren_count; 367| 8.77k| source->saved_line = source->line; 368| | 369| 8.77k| if (isc_buffer_remaininglength(source->pushback) == 0 && source->at_eof) ------------------ | | 159| 8.77k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (369:6): [True: 3.94k, False: 4.83k] | Branch (369:59): [True: 0, False: 3.94k] ------------------ 370| 0| { 371| 0| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && ------------------ | | 77| 0|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (371:7): [True: 0, False: 0] ------------------ 372| 0| lex->paren_count != 0) ------------------ | Branch (372:7): [True: 0, False: 0] ------------------ 373| 0| { 374| 0| lex->paren_count = 0; 375| 0| return ISC_R_UNBALANCED; 376| 0| } 377| 0| if ((options & ISC_LEXOPT_BTEXT) != 0 && lex->brace_count != 0) ------------------ | | 84| 0|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (377:7): [True: 0, False: 0] | Branch (377:44): [True: 0, False: 0] ------------------ 378| 0| { 379| 0| lex->brace_count = 0; 380| 0| return ISC_R_UNBALANCED; 381| 0| } 382| 0| if ((options & ISC_LEXOPT_EOF) != 0) { ------------------ | | 63| 0|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ | Branch (382:7): [True: 0, False: 0] ------------------ 383| 0| tokenp->type = isc_tokentype_eof; 384| 0| return ISC_R_SUCCESS; 385| 0| } 386| 0| return ISC_R_EOF; 387| 0| } 388| | 389| 8.77k| isc_buffer_compact(source->pushback); 390| | 391| 8.77k| saved_options = options; 392| 8.77k| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && lex->paren_count > 0) { ------------------ | | 77| 8.77k|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (392:6): [True: 8.77k, False: 0] | Branch (392:50): [True: 0, False: 8.77k] ------------------ 393| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 394| 0| } 395| | 396| 8.77k| curr = lex->data; 397| 8.77k| *curr = '\0'; 398| | 399| 8.77k| prev = NULL; 400| 8.77k| remaining = lex->max_token; 401| | 402| 8.77k|#ifdef HAVE_FLOCKFILE 403| 8.77k| if (source->is_file) { ------------------ | Branch (403:6): [True: 0, False: 8.77k] ------------------ 404| 0| flockfile(source->input); 405| 0| } 406| 8.77k|#endif /* ifdef HAVE_FLOCKFILE */ 407| | 408| 15.8M| do { 409| 15.8M| if (isc_buffer_remaininglength(source->pushback) == 0) { ------------------ | | 159| 15.8M|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (409:7): [True: 15.8M, False: 4.83k] ------------------ 410| 15.8M| if (source->is_file) { ------------------ | Branch (410:8): [True: 0, False: 15.8M] ------------------ 411| 0| stream = source->input; 412| | 413| 0|#if defined(HAVE_FLOCKFILE) && defined(HAVE_GETC_UNLOCKED) 414| 0| 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| 0| if (c == EOF) { ------------------ | Branch (418:9): [True: 0, False: 0] ------------------ 419| 0| if (ferror(stream)) { ------------------ | Branch (419:10): [True: 0, False: 0] ------------------ 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| 0| source->at_eof = true; 427| 0| } 428| 15.8M| } else { 429| 15.8M| buffer = source->input; 430| | 431| 15.8M| if (buffer->current == buffer->used) { ------------------ | Branch (431:9): [True: 1.05k, False: 15.8M] ------------------ 432| 1.05k| c = EOF; 433| 1.05k| source->at_eof = true; 434| 15.8M| } else { 435| 15.8M| c = *((unsigned char *)buffer->base + 436| 15.8M| buffer->current); 437| 15.8M| buffer->current++; 438| 15.8M| } 439| 15.8M| } 440| 15.8M| if (c != EOF) { ------------------ | Branch (440:8): [True: 15.8M, False: 1.05k] ------------------ 441| 15.8M| source->result = pushandgrow(lex, source, c); 442| 15.8M| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (442:9): [True: 0, False: 15.8M] ------------------ 443| 0| result = source->result; 444| 0| goto done; 445| 0| } 446| 15.8M| } 447| 15.8M| } 448| | 449| 15.8M| if (!source->at_eof) { ------------------ | Branch (449:7): [True: 15.8M, False: 1.05k] ------------------ 450| 15.8M| if (state == lexstate_start) { ------------------ | Branch (450:8): [True: 744k, False: 15.1M] ------------------ 451| | /* Token has not started yet. */ 452| 744k| source->ignored = isc_buffer_consumedlength( ------------------ | | 158| 744k|#define isc_buffer_consumedlength(b) ((b)->current) /* b-a */ ------------------ 453| 744k| source->pushback); 454| 744k| } 455| 15.8M| c = isc_buffer_getuint8(source->pushback); 456| 15.8M| } else { 457| 1.05k| c = EOF; 458| 1.05k| } 459| | 460| 15.8M| if (c == '\n') { ------------------ | Branch (460:7): [True: 3.45k, False: 15.8M] ------------------ 461| 3.45k| source->line++; 462| 3.45k| } 463| | 464| 15.8M| if (lex->comment_ok && !no_comments) { ------------------ | Branch (464:7): [True: 15.8M, False: 0] | Branch (464:26): [True: 13.0M, False: 2.83M] ------------------ 465| 13.0M| if (!escaped && c == ';' && ------------------ | Branch (465:8): [True: 13.0M, False: 5.67k] | Branch (465:20): [True: 813, False: 13.0M] ------------------ 466| 813| ((lex->comments & ISC_LEXCOMMENT_DNSMASTERFILE) != ------------------ | | 97| 813|#define ISC_LEXCOMMENT_DNSMASTERFILE 0x08 ------------------ | Branch (466:8): [True: 0, False: 813] ------------------ 467| 813| 0)) 468| 0| { 469| 0| saved_state = state; 470| 0| state = lexstate_eatline; 471| 0| no_comments = true; 472| 0| continue; 473| 13.0M| } else if (c == '/' && ------------------ | Branch (473:15): [True: 379, False: 13.0M] ------------------ 474| 379| (lex->comments & ------------------ | Branch (474:8): [True: 0, False: 379] ------------------ 475| 379| (ISC_LEXCOMMENT_C | ------------------ | | 94| 379|#define ISC_LEXCOMMENT_C 0x01 ------------------ 476| 379| ISC_LEXCOMMENT_CPLUSPLUS)) != 0) ------------------ | | 95| 379|#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| 13.0M| } else if (c == '#' && ((lex->comments & ------------------ | Branch (482:15): [True: 2.18k, False: 13.0M] | Branch (482:27): [True: 0, False: 2.18k] ------------------ 483| 2.18k| ISC_LEXCOMMENT_SHELL) != 0)) ------------------ | | 96| 2.18k|#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| 13.0M| } 491| | 492| 15.8M| no_read: 493| | /* INSIST(c == EOF || (c >= 0 && c <= 255)); */ 494| 15.8M| switch (state) { 495| 744k| case lexstate_start: ------------------ | Branch (495:3): [True: 744k, False: 15.1M] ------------------ 496| 744k| if (c == EOF) { ------------------ | Branch (496:8): [True: 416, False: 744k] ------------------ 497| 416| lex->last_was_eol = false; 498| 416| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && ------------------ | | 77| 416|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (498:9): [True: 416, False: 0] ------------------ 499| 416| lex->paren_count != 0) ------------------ | Branch (499:9): [True: 0, False: 416] ------------------ 500| 0| { 501| 0| lex->paren_count = 0; 502| 0| result = ISC_R_UNBALANCED; 503| 0| goto done; 504| 0| } 505| 416| if ((options & ISC_LEXOPT_BTEXT) != 0 && ------------------ | | 84| 416|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (505:9): [True: 0, False: 416] ------------------ 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| 416| if ((options & ISC_LEXOPT_EOF) == 0) { ------------------ | | 63| 416|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ | Branch (512:9): [True: 0, False: 416] ------------------ 513| 0| result = ISC_R_EOF; 514| 0| goto done; 515| 0| } 516| 416| tokenp->type = isc_tokentype_eof; 517| 416| done = true; 518| 744k| } else if (c == ' ' || c == '\t') { ------------------ | Branch (518:15): [True: 734k, False: 9.46k] | Branch (518:27): [True: 1.10k, False: 8.36k] ------------------ 519| 735k| if (lex->last_was_eol && ------------------ | Branch (519:9): [True: 215, False: 735k] ------------------ 520| 215| (options & ISC_LEXOPT_INITIALWS) != 0) ------------------ | | 64| 215|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ ------------------ | Branch (520:9): [True: 0, False: 215] ------------------ 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| 735k| } else if (c == '\n') { ------------------ | Branch (527:15): [True: 1.64k, False: 6.71k] ------------------ 528| 1.64k| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 1.64k|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (528:9): [True: 1.64k, False: 0] ------------------ 529| 1.64k| tokenp->type = isc_tokentype_eol; 530| 1.64k| done = true; 531| 1.64k| } 532| 1.64k| lex->last_was_eol = true; 533| 6.71k| } else if (c == '\r') { ------------------ | Branch (533:15): [True: 1.61k, False: 5.09k] ------------------ 534| 1.61k| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 1.61k|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (534:9): [True: 1.61k, False: 0] ------------------ 535| 1.61k| state = lexstate_crlf; 536| 1.61k| } 537| 5.09k| } else if (c == '"' && ------------------ | Branch (537:15): [True: 757, False: 4.34k] ------------------ 538| 757| (options & ISC_LEXOPT_QSTRING) != 0) ------------------ | | 66| 757|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ | Branch (538:8): [True: 483, False: 274] ------------------ 539| 483| { 540| 483| lex->last_was_eol = false; 541| 483| no_comments = true; 542| 483| state = lexstate_qstring; 543| 4.61k| } else if (c == '\0') { ------------------ | Branch (543:15): [True: 381, False: 4.23k] ------------------ 544| 381| tokenp->type = isc_tokentype_unknown; 545| 381| tokenp->value.as_char = c; 546| 381| done = true; 547| 4.23k| } else if (lex->specials[c]) { ------------------ | Branch (547:15): [True: 0, False: 4.23k] ------------------ 548| 0| lex->last_was_eol = false; 549| 0| if ((c == '(' || c == ')') && ------------------ | Branch (549:10): [True: 0, False: 0] | Branch (549:22): [True: 0, False: 0] ------------------ 550| 0| (options & ISC_LEXOPT_DNSMULTILINE) != 0) ------------------ | | 77| 0|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (550:9): [True: 0, False: 0] ------------------ 551| 0| { 552| 0| if (c == '(') { ------------------ | Branch (552:10): [True: 0, False: 0] ------------------ 553| 0| if (lex->paren_count == 0) { ------------------ | Branch (553:11): [True: 0, False: 0] ------------------ 554| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 555| 0| } 556| 0| lex->paren_count++; 557| 0| } else { 558| 0| if (lex->paren_count == 0) { ------------------ | Branch (558:11): [True: 0, False: 0] ------------------ 559| 0| result = 560| 0| ISC_R_UNBALANCED; 561| 0| goto done; 562| 0| } 563| 0| lex->paren_count--; 564| 0| if (lex->paren_count == 0) { ------------------ | Branch (564:11): [True: 0, False: 0] ------------------ 565| 0| options = saved_options; 566| 0| } 567| 0| } 568| 0| continue; 569| 0| } else if (c == '{' && ------------------ | Branch (569:16): [True: 0, False: 0] ------------------ 570| 0| (options & ISC_LEXOPT_BTEXT) != 0) ------------------ | | 84| 0|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (570:9): [True: 0, False: 0] ------------------ 571| 0| { 572| 0| if (lex->brace_count != 0) { ------------------ | Branch (572:10): [True: 0, False: 0] ------------------ 573| 0| result = ISC_R_UNBALANCED; 574| 0| goto done; 575| 0| } 576| 0| lex->brace_count++; 577| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 578| 0| state = lexstate_btext; 579| 0| no_comments = true; 580| 0| continue; 581| 0| } 582| 0| tokenp->type = isc_tokentype_special; 583| 0| tokenp->value.as_char = c; 584| 0| done = true; 585| 4.23k| } else if (isdigit((unsigned char)c) && ------------------ | Branch (585:15): [True: 2.46k, False: 1.77k] ------------------ 586| 2.46k| (options & ISC_LEXOPT_NUMBER) != 0) ------------------ | | 65| 2.46k|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ | Branch (586:8): [True: 1.28k, False: 1.17k] ------------------ 587| 1.28k| { 588| 1.28k| lex->last_was_eol = false; 589| 1.28k| if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 1.28k|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (589:9): [True: 0, False: 1.28k] ------------------ 590| 0| (c == '8' || c == '9')) ------------------ | Branch (590:10): [True: 0, False: 0] | Branch (590:22): [True: 0, False: 0] ------------------ 591| 0| { 592| 0| state = lexstate_string; 593| 1.28k| } else { 594| 1.28k| state = lexstate_number; 595| 1.28k| } 596| 1.28k| goto no_read; 597| 2.94k| } else { 598| 2.94k| lex->last_was_eol = false; 599| 2.94k| state = lexstate_string; 600| 2.94k| goto no_read; 601| 2.94k| } 602| 740k| break; 603| 740k| case lexstate_crlf: ------------------ | Branch (603:3): [True: 1.61k, False: 15.8M] ------------------ 604| 1.61k| if (c != '\n') { ------------------ | Branch (604:8): [True: 1.41k, False: 201] ------------------ 605| 1.41k| pushback(source, c); 606| 1.41k| } 607| 1.61k| tokenp->type = isc_tokentype_eol; 608| 1.61k| done = true; 609| 1.61k| lex->last_was_eol = true; 610| 1.61k| break; 611| 1.74M| case lexstate_number: ------------------ | Branch (611:3): [True: 1.74M, False: 14.1M] ------------------ 612| 1.74M| if (c == EOF || !isdigit((unsigned char)c)) { ------------------ | Branch (612:8): [True: 192, False: 1.74M] | Branch (612:20): [True: 1.09k, False: 1.74M] ------------------ 613| 1.28k| if (c == ' ' || c == '\t' || c == '\r' || ------------------ | Branch (613:9): [True: 195, False: 1.09k] | Branch (613:21): [True: 209, False: 884] | Branch (613:34): [True: 195, False: 689] ------------------ 614| 689| c == '\n' || c == '\0' || c == EOF || ------------------ | Branch (614:9): [True: 445, False: 244] | Branch (614:22): [True: 1, False: 243] | Branch (614:35): [True: 192, False: 51] ------------------ 615| 51| lex->specials[c]) ------------------ | Branch (615:9): [True: 0, False: 51] ------------------ 616| 1.23k| { 617| 1.23k| int base; 618| 1.23k| if ((options & ISC_LEXOPT_OCTAL) != 0) { ------------------ | | 83| 1.23k|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (618:10): [True: 0, False: 1.23k] ------------------ 619| 0| base = 8; 620| 1.23k| } else if ((options & ------------------ | Branch (620:17): [True: 0, False: 1.23k] ------------------ 621| 1.23k| ISC_LEXOPT_CNUMBER) != 0) ------------------ | | 80| 1.23k|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ 622| 0| { 623| 0| base = 0; 624| 1.23k| } else { 625| 1.23k| base = 10; 626| 1.23k| } 627| 1.23k| pushback(source, c); 628| | 629| 1.23k| result = isc_parse_uint32( 630| 1.23k| &as_ulong, lex->data, base); 631| 1.23k| if (result == ISC_R_SUCCESS) { ------------------ | Branch (631:10): [True: 1.11k, False: 119] ------------------ 632| 1.11k| tokenp->type = 633| 1.11k| isc_tokentype_number; 634| 1.11k| tokenp->value.as_ulong = 635| 1.11k| as_ulong; 636| 1.11k| } else if (result == ISC_R_BADNUMBER) { ------------------ | Branch (636:17): [True: 0, False: 119] ------------------ 637| 0| isc_tokenvalue_t *v; 638| | 639| 0| tokenp->type = 640| 0| isc_tokentype_string; 641| 0| v = &(tokenp->value); 642| 0| v->as_textregion.base = 643| 0| lex->data; 644| 0| v->as_textregion.length = 645| 0| (unsigned int)(lex->max_token - 646| 0| remaining); 647| 119| } else { 648| 119| goto done; 649| 119| } 650| 1.11k| done = true; 651| 1.11k| continue; 652| 1.23k| } else if ((options & ISC_LEXOPT_CNUMBER) == ------------------ | | 80| 51|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ | Branch (652:16): [True: 51, False: 0] ------------------ 653| 51| 0 || 654| 0| ((c != 'x' && c != 'X') || ------------------ | Branch (654:11): [True: 0, False: 0] | Branch (654:23): [True: 0, False: 0] ------------------ 655| 0| (curr != &lex->data[1]) || ------------------ | Branch (655:10): [True: 0, False: 0] ------------------ 656| 0| (lex->data[0] != '0'))) ------------------ | Branch (656:10): [True: 0, False: 0] ------------------ 657| 51| { 658| | /* Above test supports hex numbers */ 659| 51| state = lexstate_string; 660| 51| } 661| 1.74M| } else if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 1.74M|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (661:15): [True: 0, False: 1.74M] ------------------ 662| 0| (c == '8' || c == '9')) ------------------ | Branch (662:9): [True: 0, False: 0] | Branch (662:21): [True: 0, False: 0] ------------------ 663| 0| { 664| 0| state = lexstate_string; 665| 0| } 666| 1.74M| if (remaining == 0U) { ------------------ | Branch (666:8): [True: 4, False: 1.74M] ------------------ 667| 4| grow_data(lex, &remaining, &curr, &prev); 668| 4| } 669| 1.74M| INSIST(remaining > 0U); ------------------ | | 202| 1.74M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.74M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.74M, False: 0] | | | | ------------------ | | | | 55| 1.74M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 670| 1.74M| *curr++ = c; 671| 1.74M| *curr = '\0'; 672| 1.74M| remaining--; 673| 1.74M| break; 674| 10.5M| case lexstate_string: ------------------ | Branch (674:3): [True: 10.5M, False: 5.33M] ------------------ 675| 10.5M| if (!escaped && c == '=' && ------------------ | Branch (675:8): [True: 10.5M, False: 5.67k] | Branch (675:20): [True: 1.15k, False: 10.5M] ------------------ 676| 1.15k| (options & ISC_LEXOPT_VPAIR) != 0) ------------------ | | 85| 1.15k|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ | Branch (676:8): [True: 950, False: 204] ------------------ 677| 950| { 678| 950| if (remaining == 0U) { ------------------ | Branch (678:9): [True: 0, False: 950] ------------------ 679| 0| grow_data(lex, &remaining, &curr, 680| 0| &prev); 681| 0| } 682| 950| INSIST(remaining > 0U); ------------------ | | 202| 950|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 950| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 950, False: 0] | | | | ------------------ | | | | 55| 950| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 683| 950| *curr++ = c; 684| 950| *curr = '\0'; 685| 950| remaining--; 686| 950| state = lexstate_vpairstart; 687| 950| break; 688| 950| } 689| 10.5M| FALLTHROUGH; ------------------ | | 101| 10.5M|#define FALLTHROUGH [[fallthrough]] ------------------ 690| 10.5M| case lexstate_vpairstart: ------------------ | Branch (690:3): [True: 950, False: 15.8M] ------------------ 691| 10.5M| if (state == lexstate_vpairstart) { ------------------ | Branch (691:8): [True: 950, False: 10.5M] ------------------ 692| 950| if (c == '"' && ------------------ | Branch (692:9): [True: 454, False: 496] ------------------ 693| 454| (options & ISC_LEXOPT_QVPAIR) != 0) ------------------ | | 86| 454|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ | Branch (693:9): [True: 260, False: 194] ------------------ 694| 260| { 695| 260| no_comments = true; 696| 260| state = lexstate_qvpair; 697| 260| break; 698| 260| } 699| 690| state = lexstate_vpair; 700| 690| } 701| 10.5M| FALLTHROUGH; ------------------ | | 101| 10.5M|#define FALLTHROUGH [[fallthrough]] ------------------ 702| 10.5M| case lexstate_vpair: ------------------ | Branch (702:3): [True: 13.4k, False: 15.8M] ------------------ 703| | /* 704| | * EOF needs to be checked before lex->specials[c] 705| | * as lex->specials[EOF] is not a good idea. 706| | */ 707| 10.5M| if (c == '\r' || c == '\n' || c == EOF || ------------------ | Branch (707:8): [True: 650, False: 10.5M] | Branch (707:21): [True: 867, False: 10.5M] | Branch (707:34): [True: 299, False: 10.5M] ------------------ 708| 10.5M| (!escaped && (c == ' ' || c == '\t' || c == '\0' || ------------------ | Branch (708:9): [True: 10.5M, False: 5.44k] | Branch (708:22): [True: 465, False: 10.5M] | Branch (708:34): [True: 423, False: 10.5M] | Branch (708:47): [True: 32, False: 10.5M] ------------------ 709| 10.5M| lex->specials[c]))) ------------------ | Branch (709:8): [True: 0, False: 10.5M] ------------------ 710| 2.73k| { 711| 2.73k| pushback(source, c); 712| 2.73k| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (712:9): [True: 0, False: 2.73k] ------------------ 713| 0| result = source->result; 714| 0| goto done; 715| 0| } 716| 2.73k| if (escaped && c == EOF) { ------------------ | Branch (716:9): [True: 231, False: 2.50k] | Branch (716:20): [True: 10, False: 221] ------------------ 717| 10| result = ISC_R_UNEXPECTEDEND; 718| 10| goto done; 719| 10| } 720| 2.72k| tokenp->type = (state == lexstate_string) ------------------ | Branch (720:20): [True: 2.03k, False: 690] ------------------ 721| 2.72k| ? isc_tokentype_string 722| 2.72k| : isc_tokentype_vpair; 723| 2.72k| tokenp->value.as_textregion.base = lex->data; 724| 2.72k| tokenp->value.as_textregion.length = 725| 2.72k| (unsigned int)(lex->max_token - 726| 2.72k| remaining); 727| 2.72k| done = true; 728| 2.72k| continue; 729| 2.73k| } 730| 10.5M| if ((options & ISC_LEXOPT_ESCAPE) != 0) { ------------------ | | 81| 10.5M|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ | Branch (730:8): [True: 10.5M, False: 0] ------------------ 731| 10.5M| escaped = (!escaped && c == '\\') ? true ------------------ | Branch (731:16): [True: 10.5M, False: 5.44k] | Branch (731:28): [True: 5.67k, False: 10.5M] ------------------ 732| 10.5M| : false; 733| 10.5M| } 734| 10.5M| if (remaining == 0U) { ------------------ | Branch (734:8): [True: 5, False: 10.5M] ------------------ 735| 5| grow_data(lex, &remaining, &curr, &prev); 736| 5| } 737| 10.5M| INSIST(remaining > 0U); ------------------ | | 202| 10.5M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 10.5M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 10.5M, False: 0] | | | | ------------------ | | | | 55| 10.5M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 738| 10.5M| *curr++ = c; 739| 10.5M| *curr = '\0'; 740| 10.5M| remaining--; 741| 10.5M| break; 742| 0| case lexstate_maybecomment: ------------------ | Branch (742:3): [True: 0, False: 15.8M] ------------------ 743| 0| if (c == '*' && (lex->comments & ISC_LEXCOMMENT_C) != 0) ------------------ | | 94| 0|#define ISC_LEXCOMMENT_C 0x01 ------------------ | Branch (743:8): [True: 0, False: 0] | Branch (743:20): [True: 0, False: 0] ------------------ 744| 0| { 745| 0| state = lexstate_ccomment; 746| 0| continue; 747| 0| } else if (c == '/' && (lex->comments & ------------------ | Branch (747:15): [True: 0, False: 0] | Branch (747:27): [True: 0, False: 0] ------------------ 748| 0| ISC_LEXCOMMENT_CPLUSPLUS) != 0) ------------------ | | 95| 0|#define ISC_LEXCOMMENT_CPLUSPLUS 0x02 ------------------ 749| 0| { 750| 0| state = lexstate_eatline; 751| 0| continue; 752| 0| } 753| 0| pushback(source, c); 754| 0| c = '/'; 755| 0| no_comments = false; 756| 0| state = saved_state; 757| 0| goto no_read; 758| 0| case lexstate_ccomment: ------------------ | Branch (758:3): [True: 0, False: 15.8M] ------------------ 759| 0| if (c == EOF) { ------------------ | Branch (759:8): [True: 0, False: 0] ------------------ 760| 0| result = ISC_R_UNEXPECTEDEND; 761| 0| goto done; 762| 0| } 763| 0| if (c == '*') { ------------------ | Branch (763:8): [True: 0, False: 0] ------------------ 764| 0| state = lexstate_ccommentend; 765| 0| } 766| 0| break; 767| 0| case lexstate_ccommentend: ------------------ | Branch (767:3): [True: 0, False: 15.8M] ------------------ 768| 0| if (c == EOF) { ------------------ | Branch (768:8): [True: 0, False: 0] ------------------ 769| 0| result = ISC_R_UNEXPECTEDEND; 770| 0| goto done; 771| 0| } 772| 0| if (c == '/') { ------------------ | Branch (772:8): [True: 0, False: 0] ------------------ 773| | /* 774| | * C-style comments become a single space. 775| | * We do this to ensure that a comment will 776| | * act as a delimiter for strings and 777| | * numbers. 778| | */ 779| 0| c = ' '; 780| 0| no_comments = false; 781| 0| state = saved_state; 782| 0| goto no_read; 783| 0| } else if (c != '*') { ------------------ | Branch (783:15): [True: 0, False: 0] ------------------ 784| 0| state = lexstate_ccomment; 785| 0| } 786| 0| break; 787| 0| case lexstate_eatline: ------------------ | Branch (787:3): [True: 0, False: 15.8M] ------------------ 788| 0| if ((c == '\n') || (c == EOF)) { ------------------ | Branch (788:8): [True: 0, False: 0] | Branch (788:23): [True: 0, False: 0] ------------------ 789| 0| no_comments = false; 790| 0| state = saved_state; 791| 0| goto no_read; 792| 0| } 793| 0| break; 794| 405k| case lexstate_qstring: ------------------ | Branch (794:3): [True: 405k, False: 15.4M] ------------------ 795| 2.83M| case lexstate_qvpair: ------------------ | Branch (795:3): [True: 2.42M, False: 13.4M] ------------------ 796| 2.83M| if (c == EOF) { ------------------ | Branch (796:8): [True: 108, False: 2.83M] ------------------ 797| 108| result = ISC_R_UNEXPECTEDEND; 798| 108| goto done; 799| 108| } 800| 2.83M| if (c == '"') { ------------------ | Branch (800:8): [True: 2.27k, False: 2.83M] ------------------ 801| 2.27k| if (escaped) { ------------------ | Branch (801:9): [True: 1.65k, False: 626] ------------------ 802| 1.65k| escaped = false; 803| | /* 804| | * Overwrite the preceding backslash. 805| | */ 806| 1.65k| INSIST(prev != NULL); ------------------ | | 202| 1.65k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.65k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.65k, False: 0] | | | | ------------------ | | | | 55| 1.65k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 807| 1.65k| *prev = '"'; 808| 1.65k| } else { 809| 626| tokenp->type = 810| 626| (state == lexstate_qstring) ------------------ | Branch (810:7): [True: 387, False: 239] ------------------ 811| 626| ? isc_tokentype_qstring 812| 626| : isc_tokentype_qvpair; 813| 626| tokenp->value.as_textregion.base = 814| 626| lex->data; 815| 626| tokenp->value.as_textregion.length = 816| 626| (unsigned int)(lex->max_token - 817| 626| remaining); 818| 626| no_comments = false; 819| 626| done = true; 820| 626| } 821| 2.83M| } else { 822| 2.83M| if (c == '\n' && !escaped && ------------------ | Branch (822:9): [True: 296, False: 2.83M] | Branch (822:22): [True: 9, False: 287] ------------------ 823| 9| (options & ISC_LEXOPT_QSTRINGMULTILINE) == ------------------ | | 82| 9|#define ISC_LEXOPT_QSTRINGMULTILINE 0x0200 /*%< Allow multiline "" strings */ ------------------ | Branch (823:9): [True: 9, False: 0] ------------------ 824| 9| 0) 825| 9| { 826| 9| pushback(source, c); 827| 9| result = ISC_R_UNBALANCEDQUOTES; 828| 9| goto done; 829| 9| } 830| 2.83M| if (c == '\\' && !escaped) { ------------------ | Branch (830:9): [True: 36.6k, False: 2.79M] | Branch (830:22): [True: 21.8k, False: 14.7k] ------------------ 831| 21.8k| escaped = true; 832| 2.80M| } else { 833| 2.80M| escaped = false; 834| 2.80M| } 835| 2.83M| if (remaining == 0U) { ------------------ | Branch (835:9): [True: 1, False: 2.83M] ------------------ 836| 1| grow_data(lex, &remaining, &curr, 837| 1| &prev); 838| 1| } 839| 2.83M| INSIST(remaining > 0U); ------------------ | | 202| 2.83M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2.83M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2.83M, False: 0] | | | | ------------------ | | | | 55| 2.83M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 840| 2.83M| prev = curr; 841| 2.83M| *curr++ = c; 842| 2.83M| *curr = '\0'; 843| 2.83M| remaining--; 844| 2.83M| } 845| 2.83M| break; 846| 2.83M| case lexstate_btext: ------------------ | Branch (846:3): [True: 0, False: 15.8M] ------------------ 847| 0| if (c == EOF) { ------------------ | Branch (847:8): [True: 0, False: 0] ------------------ 848| 0| result = ISC_R_UNEXPECTEDEND; 849| 0| goto done; 850| 0| } 851| 0| if (c == '{') { ------------------ | Branch (851:8): [True: 0, False: 0] ------------------ 852| 0| if (escaped) { ------------------ | Branch (852:9): [True: 0, False: 0] ------------------ 853| 0| escaped = false; 854| 0| } else { 855| 0| lex->brace_count++; 856| 0| } 857| 0| } else if (c == '}') { ------------------ | Branch (857:15): [True: 0, False: 0] ------------------ 858| 0| if (escaped) { ------------------ | Branch (858:9): [True: 0, False: 0] ------------------ 859| 0| escaped = false; 860| 0| } else { 861| 0| INSIST(lex->brace_count > 0); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 862| 0| lex->brace_count--; 863| 0| } 864| | 865| 0| if (lex->brace_count == 0) { ------------------ | Branch (865:9): [True: 0, False: 0] ------------------ 866| 0| tokenp->type = isc_tokentype_btext; 867| 0| tokenp->value.as_textregion.base = 868| 0| lex->data; 869| 0| tokenp->value.as_textregion.length = 870| 0| (unsigned int)(lex->max_token - 871| 0| remaining); 872| 0| no_comments = false; 873| 0| done = true; 874| 0| break; 875| 0| } 876| 0| } 877| | 878| 0| if (c == '\\' && !escaped) { ------------------ | Branch (878:8): [True: 0, False: 0] | Branch (878:21): [True: 0, False: 0] ------------------ 879| 0| escaped = true; 880| 0| } else { 881| 0| escaped = false; 882| 0| } 883| | 884| 0| if (remaining == 0U) { ------------------ | Branch (884:8): [True: 0, False: 0] ------------------ 885| 0| grow_data(lex, &remaining, &curr, &prev); 886| 0| } 887| 0| INSIST(remaining > 0U); ------------------ | | 202| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 888| 0| prev = curr; 889| 0| *curr++ = c; 890| 0| *curr = '\0'; 891| 0| remaining--; 892| 0| break; 893| 0| default: ------------------ | Branch (893:3): [True: 0, False: 15.8M] ------------------ 894| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 895| 15.8M| } 896| 15.8M| } while (!done); ------------------ | Branch (896:11): [True: 15.8M, False: 8.53k] ------------------ 897| | 898| 8.53k| result = ISC_R_SUCCESS; 899| 8.77k|done: 900| 8.77k|#ifdef HAVE_FLOCKFILE 901| 8.77k| if (source->is_file) { ------------------ | Branch (901:6): [True: 0, False: 8.77k] ------------------ 902| 0| funlockfile(source->input); 903| 0| } 904| 8.77k|#endif /* ifdef HAVE_FLOCKFILE */ 905| 8.77k| return result; 906| 8.53k|} isc_lex_getmastertoken: 910| 8.77k| isc_tokentype_t expect, bool eol) { 911| 8.77k| unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 62| 8.77k|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 63| 8.77k|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ 912| 8.77k| ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 77| 8.77k|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 81| 8.77k|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 913| 8.77k| isc_result_t result; 914| | 915| 8.77k| if (expect == isc_tokentype_vpair) { ------------------ | Branch (915:6): [True: 946, False: 7.83k] ------------------ 916| 946| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 946|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 917| 7.83k| } else if (expect == isc_tokentype_qvpair) { ------------------ | Branch (917:13): [True: 1.41k, False: 6.41k] ------------------ 918| 1.41k| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 1.41k|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 919| 1.41k| options |= ISC_LEXOPT_QVPAIR; ------------------ | | 86| 1.41k|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ 920| 6.41k| } else if (expect == isc_tokentype_qstring) { ------------------ | Branch (920:13): [True: 2.02k, False: 4.38k] ------------------ 921| 2.02k| options |= ISC_LEXOPT_QSTRING; ------------------ | | 66| 2.02k|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ 922| 4.38k| } else if (expect == isc_tokentype_number) { ------------------ | Branch (922:13): [True: 2.05k, False: 2.32k] ------------------ 923| 2.05k| options |= ISC_LEXOPT_NUMBER; ------------------ | | 65| 2.05k|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ 924| 2.05k| } 925| 8.77k| result = isc_lex_gettoken(lex, options, token); 926| 8.77k| if (result == ISC_R_RANGE) { ------------------ | Branch (926:6): [True: 119, False: 8.65k] ------------------ 927| 119| isc_lex_ungettoken(lex, token); 928| 119| } 929| 8.77k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (929:6): [True: 246, False: 8.53k] ------------------ 930| 246| return result; 931| 246| } 932| | 933| 8.53k| if (eol && ((token->type == isc_tokentype_eol) || ------------------ | Branch (933:6): [True: 7.55k, False: 980] | Branch (933:14): [True: 3.03k, False: 4.51k] ------------------ 934| 4.51k| (token->type == isc_tokentype_eof))) ------------------ | Branch (934:7): [True: 331, False: 4.18k] ------------------ 935| 3.36k| { 936| 3.36k| return ISC_R_SUCCESS; 937| 3.36k| } 938| 5.16k| if (token->type == isc_tokentype_string && ------------------ | Branch (938:6): [True: 2.03k, False: 3.13k] ------------------ 939| 2.03k| (expect == isc_tokentype_qstring || expect == isc_tokentype_qvpair)) ------------------ | Branch (939:7): [True: 845, False: 1.19k] | Branch (939:42): [True: 425, False: 766] ------------------ 940| 1.27k| { 941| 1.27k| return ISC_R_SUCCESS; 942| 1.27k| } 943| 3.89k| if (token->type == isc_tokentype_vpair && ------------------ | Branch (943:6): [True: 690, False: 3.20k] ------------------ 944| 690| expect == isc_tokentype_qvpair) ------------------ | Branch (944:6): [True: 232, False: 458] ------------------ 945| 232| { 946| 232| return ISC_R_SUCCESS; 947| 232| } 948| 3.66k| if (token->type != expect) { ------------------ | Branch (948:6): [True: 347, False: 3.31k] ------------------ 949| 347| isc_lex_ungettoken(lex, token); 950| 347| if (token->type == isc_tokentype_eol || ------------------ | Branch (950:7): [True: 3, False: 344] ------------------ 951| 344| token->type == isc_tokentype_eof) ------------------ | Branch (951:7): [True: 84, False: 260] ------------------ 952| 87| { 953| 87| return ISC_R_UNEXPECTEDEND; 954| 87| } 955| 260| if (expect == isc_tokentype_number) { ------------------ | Branch (955:7): [True: 59, False: 201] ------------------ 956| 59| return ISC_R_BADNUMBER; 957| 59| } 958| 201| return ISC_R_UNEXPECTEDTOKEN; 959| 260| } 960| 3.31k| return ISC_R_SUCCESS; 961| 3.66k|} isc_lex_ungettoken: 996| 466|isc_lex_ungettoken(isc_lex_t *lex, isc_token_t *tokenp) { 997| 466| inputsource *source; 998| | /* 999| | * Unget the current token. 1000| | */ 1001| | 1002| 466| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 466|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 932| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 466, False: 0] | | | | | Branch (42:11): [True: 466, False: 0] | | | | ------------------ | | | | 43| 466| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1003| 466| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 466|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 1004| 466| REQUIRE(source != NULL); ------------------ | | 198| 466|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 466| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 466, False: 0] | | | | ------------------ | | | | 43| 466| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1005| 466| REQUIRE(tokenp != NULL); ------------------ | | 198| 466|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 466| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 466, False: 0] | | | | ------------------ | | | | 43| 466| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1006| 466| REQUIRE(isc_buffer_consumedlength(source->pushback) != 0 || ------------------ | | 198| 466|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 546| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 386, False: 80] | | | | | Branch (42:11): [True: 80, False: 0] | | | | ------------------ | | | | 43| 466| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1007| 466| tokenp->type == isc_tokentype_eof); 1008| | 1009| 466| UNUSED(tokenp); ------------------ | | 69| 466|#define UNUSED(x) (void)(x) ------------------ 1010| | 1011| 466| isc_buffer_first(source->pushback); 1012| 466| lex->paren_count = lex->saved_paren_count; 1013| 466| source->line = source->saved_line; 1014| | source->at_eof = false; 1015| 466|} lex.c:new_source: 183| 925| const char *name) { 184| 925| inputsource *source; 185| | 186| 925| source = isc_mem_get(lex->mctx, sizeof(*source)); ------------------ | | 144| 925|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 187| 925| *source = (inputsource){ 188| 925| .is_file = is_file, 189| 925| .need_close = need_close, 190| 925| .last_was_eol = lex->last_was_eol, 191| 925| .input = input, 192| 925| .name = isc_mem_strdup(lex->mctx, name), ------------------ | | 167| 925|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 193| 925| .line = 1, 194| 925| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 925|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 925| { \ | | | | 27| 925| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 925|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 925| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 925|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 925| } | | ------------------ ------------------ 195| 925| }; 196| 925| isc_buffer_allocate(lex->mctx, &source->pushback, 197| 925| (unsigned int)lex->max_token); 198| | ISC_LIST_PREPEND(lex->sources, source, link); ------------------ | | 79| 925| do { \ | | 80| 925| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 925| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 925| do { \ | | | | 68| 925| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 924, False: 1] | | | | ------------------ | | | | 69| 924| (list).head->link.prev = (elt); \ | | | | 70| 924| } else { \ | | | | 71| 1| (list).tail = (elt); \ | | | | 72| 1| } \ | | | | 73| 925| (elt)->link.prev = NULL; \ | | | | 74| 925| (elt)->link.next = (list).head; \ | | | | 75| 925| (list).head = (elt); \ | | | | 76| 925| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 925] | | | | ------------------ | | ------------------ | | 82| 925| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 925] | | ------------------ ------------------ 199| 925|} lex.c:pushandgrow: 309| 15.8M|pushandgrow(isc_lex_t *lex, inputsource *source, int c) { 310| 15.8M| if (isc_buffer_availablelength(source->pushback) == 0) { ------------------ | | 161| 15.8M|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (310:6): [True: 17, False: 15.8M] ------------------ 311| 17| isc_buffer_t *tbuf = NULL; 312| 17| unsigned int oldlen; 313| 17| isc_region_t used; 314| 17| isc_result_t result; 315| | 316| 17| oldlen = isc_buffer_length(source->pushback); ------------------ | | 150| 17|#define isc_buffer_length(b) ((b)->length) /*e*/ ------------------ 317| 17| isc_buffer_allocate(lex->mctx, &tbuf, oldlen * 2); 318| 17| isc_buffer_usedregion(source->pushback, &used); 319| 17| result = isc_buffer_copyregion(tbuf, &used); 320| 17| INSIST(result == ISC_R_SUCCESS); ------------------ | | 202| 17|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 17| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 17, False: 0] | | | | ------------------ | | | | 55| 17| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 321| 17| tbuf->current = source->pushback->current; 322| 17| isc_buffer_free(&source->pushback); 323| 17| source->pushback = tbuf; 324| 17| } 325| 15.8M| isc_buffer_putuint8(source->pushback, (uint8_t)c); 326| 15.8M| return ISC_R_SUCCESS; 327| 15.8M|} lex.c:pushback: 296| 5.39k|pushback(inputsource *source, int c) { 297| 5.39k| REQUIRE(source->pushback->current > 0); ------------------ | | 198| 5.39k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 5.39k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 5.39k, False: 0] | | | | ------------------ | | | | 43| 5.39k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 298| 5.39k| if (c == EOF) { ------------------ | Branch (298:6): [True: 529, False: 4.86k] ------------------ 299| 529| source->at_eof = false; 300| 529| return; 301| 529| } 302| 4.86k| source->pushback->current--; 303| 4.86k| if (c == '\n') { ------------------ | Branch (303:6): [True: 1.32k, False: 3.54k] ------------------ 304| 1.32k| source->line--; 305| 1.32k| } 306| 4.86k|} lex.c:grow_data: 68| 10|grow_data(isc_lex_t *lex, size_t *remainingp, char **currp, char **prevp) { 69| 10| char *tmp; 70| | 71| 10| tmp = isc_mem_get(lex->mctx, lex->max_token * 2 + 1); ------------------ | | 144| 10|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 72| 10| memmove(tmp, lex->data, lex->max_token + 1); 73| 10| *currp = tmp + (*currp - lex->data); 74| 10| if (*prevp != NULL) { ------------------ | Branch (74:6): [True: 1, False: 9] ------------------ 75| 1| *prevp = tmp + (*prevp - lex->data); 76| 1| } 77| | isc_mem_put(lex->mctx, lex->data, lex->max_token + 1); ------------------ | | 171| 10| do { \ | | 172| 10| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 173| 10| (p) = NULL; \ | | 174| 10| } while (0) | | ------------------ | | | Branch (174:11): [Folded, False: 10] | | ------------------ ------------------ 78| 10| lex->data = tmp; 79| 10| *remainingp += lex->max_token; 80| 10| lex->max_token *= 2; 81| 10|} isc__lib_initialize: 46| 4|isc__lib_initialize(void) { 47| 4| if (isc_refcount_increment0(&isc__lib_references) > 0) { ------------------ | | 68| 4| ({ \ | | 69| 4| uint_fast32_t __v; \ | | 70| 4| __v = atomic_fetch_add_release(target, 1); \ | | ------------------ | | | | 52| 4| atomic_fetch_add_explicit((o), (v), memory_order_release) | | ------------------ | | 71| 4| INSIST(__v < UINT32_MAX); \ | | ------------------ | | | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 4| __v; \ | | 73| 4| }) ------------------ | Branch (47:6): [True: 2, False: 2] ------------------ 48| 2| return; 49| 2| } 50| | 51| 4| rcu_register_thread(); 52| 2| isc__os_initialize(); 53| 2| isc__mutex_initialize(); 54| 2| isc__mem_initialize(); 55| 2| isc__log_initialize(); 56| 2| isc__crypto_initialize(); 57| 2| isc__uv_initialize(); 58| 2| isc__xml_initialize(); 59| 2| isc__hash_initialize(); 60| 2| isc__iterated_hash_initialize(); 61| 2| (void)isc_os_ncpus(); 62| 2|} isc_logconfig_create: 328| 2|isc_logconfig_create(isc_logconfig_t **lcfgp) { 329| 2| REQUIRE(lcfgp != NULL && *lcfgp == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 330| 2| REQUIRE(VALID_CONTEXT(isc__lctx)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 331| | 332| 2| int level = ISC_LOG_INFO; ------------------ | | 42| 2|#define ISC_LOG_INFO (-1) ------------------ 333| | 334| 2| isc_logconfig_t *lcfg = isc_mem_get(isc__lctx->mctx, sizeof(*lcfg)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 335| | 336| 2| *lcfg = (isc_logconfig_t){ 337| 2| .magic = LCFG_MAGIC, ------------------ | | 43| 2|#define LCFG_MAGIC ISC_MAGIC('L', 'c', 'f', 'g') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 338| 2| .lctx = isc__lctx, 339| 2| .channels = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 340| 2| .highest_level = level, 341| 2| }; 342| | 343| | /* 344| | * Create the default channels: 345| | * default_syslog, default_stderr, default_debug and null. 346| | */ 347| 2| isc_log_createchannel(lcfg, "default_syslog", ISC_LOG_TOSYSLOG, level, ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ 348| 2| ISC_LOGDESTINATION_SYSLOG(LOG_DAEMON), 0); ------------------ | | 287| 2| (&(isc_logdestination_t){ .facility = (f) }) ------------------ 349| | 350| 2| isc_log_createchannel(lcfg, "default_stderr", ISC_LOG_TOFILEDESC, level, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 351| 2| ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 352| | 353| | /* 354| | * Set the default category's channel to default_stderr, 355| | * which is at the head of the channels list because it was 356| | * just created. 357| | */ 358| 2| default_channel.channel = ISC_LIST_HEAD(lcfg->channels); ------------------ | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 359| | 360| 2| isc_log_createchannel(lcfg, "default_debug", ISC_LOG_TOFILEDESC, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 361| 2| ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ 362| 2| ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 363| | 364| 2| isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ 365| 2| NULL, 0); 366| | 367| 2| *lcfgp = lcfg; 368| 2|} isc_log_createchannel: 473| 8| unsigned int flags) { 474| 8| isc_logchannel_t *channel; 475| 8| isc_mem_t *mctx; 476| 8| unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 69| 8|#define ISC_LOG_PRINTALL 0x0003F ------------------ unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 71| 8|#define ISC_LOG_DEBUGONLY 0x01000 ------------------ 477| 8| ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 70| 8|#define ISC_LOG_BUFFERED 0x00040 ------------------ ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 73| 8|#define ISC_LOG_ISO8601 0x10000 /* if PRINTTIME, use ISO8601 */ ------------------ 478| 8| ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 74| 8|#define ISC_LOG_UTC 0x20000 /* if PRINTTIME, use UTC */ ------------------ ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 75| 8|#define ISC_LOG_TZINFO 0x40000 /* if PRINTTIME, output TZ info */ ------------------ 479| | 480| 8| REQUIRE(VALID_CONFIG(lcfg)); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 481| 8| REQUIRE(name != NULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 482| 8| REQUIRE(type == ISC_LOG_TOSYSLOG || type == ISC_LOG_TOFILE || ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 6] | | | | | Branch (42:11): [True: 0, False: 6] | | | | | Branch (42:11): [True: 4, False: 2] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 483| 8| type == ISC_LOG_TOFILEDESC || type == ISC_LOG_TONULL); 484| 8| REQUIRE(destination != NULL || type == ISC_LOG_TONULL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 2] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 485| 8| REQUIRE(level >= ISC_LOG_CRITICAL); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 486| 8| REQUIRE((flags & ~permitted) == 0); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 487| 8| REQUIRE(!(flags & ISC_LOG_UTC) || !(flags & ISC_LOG_TZINFO)); ------------------ | | 198| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 488| | 489| | /* FIXME: find duplicate names? */ 490| | 491| 8| mctx = lcfg->lctx->mctx; 492| | 493| 8| channel = isc_mem_get(mctx, sizeof(*channel)); ------------------ | | 144| 8|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 494| | 495| 8| channel->name = isc_mem_strdup(mctx, name); ------------------ | | 167| 8|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 496| | 497| 8| channel->type = type; 498| 8| channel->level = level; 499| 8| channel->flags = flags; 500| 8| ISC_LINK_INIT(channel, link); ------------------ | | 57| 8|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 8| do { \ | | | | 54| 8| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 8| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 8| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 501| | 502| 8| switch (type) { 503| 2| case ISC_LOG_TOSYSLOG: ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ | Branch (503:2): [True: 2, False: 6] ------------------ 504| 2| FACILITY(channel) = destination->facility; ------------------ | | 314| 2|#define FACILITY(channel) (channel->destination.facility) ------------------ 505| 2| break; 506| | 507| 0| case ISC_LOG_TOFILE: ------------------ | | 55| 0|#define ISC_LOG_TOFILE 3 ------------------ | Branch (507:2): [True: 0, False: 8] ------------------ 508| | /* 509| | * The file name is copied because greatest_version wants 510| | * to scribble on it, so it needs to be definitely in 511| | * writable memory. 512| | */ 513| 0| FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 315| 0|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 167| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 514| 0| destination->file.name); 515| 0| FILE_STREAM(channel) = NULL; ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 516| 0| FILE_VERSIONS(channel) = destination->file.versions; ------------------ | | 317| 0|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ 517| 0| FILE_SUFFIX(channel) = destination->file.suffix; ------------------ | | 318| 0|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 518| 0| FILE_MAXSIZE(channel) = destination->file.maximum_size; ------------------ | | 319| 0|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 519| 0| FILE_MAXREACHED(channel) = false; ------------------ | | 320| 0|#define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached) ------------------ 520| 0| break; 521| | 522| 4| case ISC_LOG_TOFILEDESC: ------------------ | | 56| 4|#define ISC_LOG_TOFILEDESC 4 ------------------ | Branch (522:2): [True: 4, False: 4] ------------------ 523| 4| FILE_NAME(channel) = NULL; ------------------ | | 315| 4|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ 524| 4| FILE_STREAM(channel) = destination->file.stream; ------------------ | | 316| 4|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 525| 4| FILE_MAXSIZE(channel) = 0; ------------------ | | 319| 4|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 526| 4| FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 317| 4|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 87| 4|#define ISC_LOG_ROLLNEVER (-2) ------------------ 527| 4| FILE_SUFFIX(channel) = isc_log_rollsuffix_increment; ------------------ | | 318| 4|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 528| 4| break; 529| | 530| 2| case ISC_LOG_TONULL: ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ | Branch (530:2): [True: 2, False: 6] ------------------ 531| | /* Nothing. */ 532| 2| break; 533| | 534| 0| default: ------------------ | Branch (534:2): [True: 0, False: 8] ------------------ 535| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 536| 8| } 537| | 538| 8| ISC_LIST_PREPEND(lcfg->channels, channel, link); ------------------ | | 79| 8| do { \ | | 80| 8| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 8| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 8| do { \ | | | | 68| 8| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 6, False: 2] | | | | ------------------ | | | | 69| 6| (list).head->link.prev = (elt); \ | | | | 70| 6| } else { \ | | | | 71| 2| (list).tail = (elt); \ | | | | 72| 2| } \ | | | | 73| 8| (elt)->link.prev = NULL; \ | | | | 74| 8| (elt)->link.next = (list).head; \ | | | | 75| 8| (list).head = (elt); \ | | | | 76| 8| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 8] | | | | ------------------ | | ------------------ | | 82| 8| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 8] | | ------------------ ------------------ 539| | 540| | /* 541| | * If default_stderr was redefined, make the default category 542| | * point to the new default_stderr. 543| | */ 544| 8| if (strcmp(name, "default_stderr") == 0) { ------------------ | Branch (544:6): [True: 2, False: 6] ------------------ 545| 2| default_channel.channel = channel; 546| 2| } 547| 8|} isc__log_initialize: 1532| 2|isc__log_initialize(void) { 1533| 2| REQUIRE(isc__lctx == NULL); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1534| | 1535| 2| isc_mem_t *mctx = NULL; 1536| | 1537| 2| isc_mem_create("log", &mctx); ------------------ | | 236| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 1538| 2| isc_mem_setdebugging(mctx, 0); 1539| | 1540| 2| isc__lctx = isc_mem_get(mctx, sizeof(*isc__lctx)); ------------------ | | 144| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1541| 2| *isc__lctx = (isc_log_t){ 1542| 2| .magic = LCTX_MAGIC, ------------------ | | 40| 2|#define LCTX_MAGIC ISC_MAGIC('L', 'c', 't', 'x') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1543| 2| .mctx = mctx, /* implicit attach */ 1544| 2| }; 1545| | 1546| 2| isc_mutex_init(&isc__lctx->lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 1547| | 1548| | /* Create default logging configuration */ 1549| 2| isc_logconfig_t *lcfg = NULL; 1550| 2| isc_logconfig_create(&lcfg); 1551| | 1552| 2| atomic_init(&isc__lctx->highest_level, lcfg->highest_level); 1553| 2| atomic_init(&isc__lctx->dynamic, lcfg->dynamic); 1554| | 1555| 2| isc__lctx->logconfig = lcfg; 1556| 2|} isc__mem_initialize: 508| 2|isc__mem_initialize(void) { 509| | /* 510| | * Check if the values copied from jemalloc still match; the 511| | * shim defines the MALLOCX_* macros too, so this holds on 512| | * every allocator path. 513| | */ 514| 2| RUNTIME_CHECK(ISC_MEM_ZERO == MALLOCX_ZERO); ------------------ | | 245| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, Folded] | | ------------------ ------------------ 515| 2| RUNTIME_CHECK(ISC_MEM_ALIGN(sizeof(void *)) == ------------------ | | 245| 8| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | | Branch (245:4): [True: 2, Folded] | | | Branch (245:4): [True: 2, Folded] | | ------------------ ------------------ 516| 2| MALLOCX_ALIGN(sizeof(void *))); 517| 2| RUNTIME_CHECK(ISC_MEM_ALIGN(ISC_OS_CACHELINE_SIZE) == ------------------ | | 245| 8| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (245:3): [True: 2, False: 0] | | | Branch (245:4): [True: 2, Folded] | | | Branch (245:4): [True: 2, Folded] | | ------------------ ------------------ 518| 2| MALLOCX_ALIGN(ISC_OS_CACHELINE_SIZE)); 519| | 520| |#ifdef JEMALLOC_API_SUPPORTED 521| | /* 522| | * ignore errors — volumetric-based purge in mem_put handles the rest 523| | * regardless 524| | */ 525| | 526| | (void)mallctl("background_thread", NULL, NULL, &(bool){ true }, 527| | sizeof(bool)); 528| | 529| | (void)mallctl("arenas.dirty_decay_ms", NULL, NULL, 530| | &default_dirty_decay_ms, sizeof(default_dirty_decay_ms)); 531| | 532| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".dirty_decay_ms", 533| | NULL, NULL, &default_dirty_decay_ms, 534| | sizeof(default_dirty_decay_ms)); 535| | 536| |#endif /* JEMALLOC_API_SUPPORTED */ 537| | 538| 2| isc_mutex_init(&contextslock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 539| 2| ISC_LIST_INIT(contexts); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 540| | 541| 2| if (debugging_enabled("ISC_MEM_DEBUGTRACE")) { ------------------ | Branch (541:6): [True: 0, False: 2] ------------------ 542| 0| mem_debugging |= ISC_MEM_DEBUGTRACE; ------------------ | | 41| 0|#define ISC_MEM_DEBUGTRACE 0x00000001U ------------------ 543| 0| } 544| | 545| 2| if (debugging_enabled("ISC_MEM_DEBUGRECORD")) { ------------------ | Branch (545:6): [True: 0, False: 2] ------------------ 546| 0| mem_debugging |= ISC_MEM_DEBUGRECORD; ------------------ | | 42| 0|#define ISC_MEM_DEBUGRECORD 0x00000002U ------------------ 547| 0| } 548| | 549| 2| if (debugging_enabled("ISC_MEM_DEBUGUSAGE")) { ------------------ | Branch (549:6): [True: 0, False: 2] ------------------ 550| 0| mem_debugging |= ISC_MEM_DEBUGUSAGE; ------------------ | | 43| 0|#define ISC_MEM_DEBUGUSAGE 0x00000004U ------------------ 551| 0| } 552| | 553| 2| isc_mem_create("default", &isc_g_mctx); ------------------ | | 236| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 554| 2|} isc_mem_setdebugging: 576| 4|isc_mem_setdebugging(isc_mem_t *ctx, unsigned int debugging) { 577| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 578| 4| REQUIRE(isc_mem_inuse(ctx) == 0); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 579| | 580| 4| ctx->debugging = debugging; 581| 4|} isc__mem_get: 758| 1.89k|isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) { 759| 1.89k| void *ptr = NULL; 760| | 761| 1.89k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 1.89k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.78k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.89k, False: 0] | | | | | Branch (42:11): [True: 1.89k, False: 0] | | | | ------------------ | | | | 43| 1.89k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 762| | 763| 1.89k| ptr = mem_get(ctx, size, flags); 764| | 765| 1.89k| mem_getstats(ctx, size); 766| 1.89k| ADD_TRACE(ctx, ptr, size, func, file, line); 767| | 768| 1.89k| return ptr; 769| 1.89k|} isc__mem_put: 772| 27|isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size, int flags FLARG) { 773| 27| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 27|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 54| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 27, False: 0] | | | | | Branch (42:11): [True: 27, False: 0] | | | | ------------------ | | | | 43| 27| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 27| DELETE_TRACE(ctx, ptr, size, func, file, line); 776| | 777| 27| mem_putstats(ctx, size); 778| 27| mem_put(ctx, ptr, size, flags); 779| 27|} isc__mem_allocate: 850| 933|isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) { 851| 933| void *ptr = NULL; 852| | 853| 933| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 933|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.86k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 933, False: 0] | | | | | Branch (42:11): [True: 933, False: 0] | | | | ------------------ | | | | 43| 933| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 854| | 855| 933| ptr = mem_get(ctx, size, flags); 856| | 857| | /* Recalculate the real allocated size */ 858| 933| size = sallocx(ptr, flags | ctx->jemalloc_flags); 859| | 860| 933| mem_getstats(ctx, size); 861| 933| ADD_TRACE(ctx, ptr, size, func, file, line); 862| | 863| 933| return ptr; 864| 933|} isc__mem_strdup: 946| 933|isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) { 947| 933| size_t len; 948| 933| char *ns = NULL; 949| | 950| 933| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 198| 933|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.86k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 933, False: 0] | | | | | Branch (42:11): [True: 933, False: 0] | | | | ------------------ | | | | 43| 933| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 951| 933| REQUIRE(s != NULL); ------------------ | | 198| 933|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 933| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 933, False: 0] | | | | ------------------ | | | | 43| 933| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 952| | 953| 933| len = strlen(s) + 1; 954| | 955| 933| ns = isc__mem_allocate(mctx, len, 0 FLARG_PASS); 956| | 957| 933| strlcpy(ns, s, len); 958| | 959| 933| return ns; 960| 933|} isc_mem_setdestroycheck: 963| 2|isc_mem_setdestroycheck(isc_mem_t *ctx, bool flag) { 964| 2| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 965| | 966| 2| MCTXLOCK(ctx); ------------------ | | 69| 2|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ ------------------ 967| | 968| 2| ctx->checkfree = flag; 969| | 970| 2| MCTXUNLOCK(ctx); ------------------ | | 70| 2|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 288| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (288:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 228| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 290| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ ------------------ 971| 2|} isc_mem_inuse: 974| 4|isc_mem_inuse(isc_mem_t *ctx) { 975| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 976| | 977| 4| int_fast64_t inuse = 0; 978| | 979| 8| for (ssize_t i = -1; i < isc_tid_count(); i++) { ------------------ | Branch (979:23): [True: 4, False: 4] ------------------ 980| 4| inuse += atomic_load_relaxed(&ctx->stat[i].inuse); ------------------ | | 28| 4|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 981| 4| } 982| 4| INSIST(inuse >= 0); ------------------ | | 202| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 983| | 984| 4| return (size_t)inuse; 985| 4|} isc__mem_create: 1535| 10|isc__mem_create(const char *name, isc_mem_t **mctxp FLARG) { 1536| 10| mem_create(name, mctxp, mem_debugging, 0); 1537| |#if ISC_MEM_TRACKLINES 1538| | if ((mem_debugging & ISC_MEM_DEBUGTRACE) != 0) { 1539| | fprintf(stderr, "create mctx %p func %s file %s line %u\n", 1540| | *mctxp, func, file, line); 1541| | } 1542| |#endif /* ISC_MEM_TRACKLINES */ 1543| 10|} mem.c:debugging_enabled: 491| 6|debugging_enabled(const char *name) { 492| 6| char env_buf[256]; 493| 6| size_t env_size = sizeof(env_buf); 494| | 495| 6| int r = uv_os_getenv(name, env_buf, &env_size); 496| 6| switch (r) { 497| 0| case 0: ------------------ | Branch (497:2): [True: 0, False: 6] ------------------ 498| 0| return true; 499| 6| case UV_ENOENT: ------------------ | Branch (499:2): [True: 6, False: 0] ------------------ 500| 6| return false; 501| 0| default: ------------------ | Branch (501:2): [True: 0, False: 6] ------------------ 502| 0| UV_RUNTIME_CHECK(uv_os_getenv, r); ------------------ | | 50| 0| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 0] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 503| 0| UNREACHABLE(); ------------------ | | 206| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 504| 6| } 505| 6|} mem.c:mem_get: 398| 2.82k|mem_get(isc_mem_t *ctx, size_t size, int flags) { 399| 2.82k| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 390| 2.82k| if (s == 0) { \ | | ------------------ | | | Branch (390:6): [True: 0, False: 2.82k] | | ------------------ | | 391| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 86| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 392| 0| } ------------------ 400| | 401| 2.82k| void *ptr = mallocx(size, flags | ctx->jemalloc_flags); 402| 2.82k| CHECK_OOM(ptr, size); ------------------ | | 244| 2.82k|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (244:37): [True: 2.82k, False: 0] | | | Branch (244:54): [True: 0, False: 0] | | ------------------ ------------------ 403| | 404| 2.82k| return ptr; 405| 2.82k|} mem.c:mem_getstats: 474| 2.82k|mem_getstats(isc_mem_t *ctx, size_t size) { 475| | atomic_fetch_add_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 30| 2.82k| atomic_fetch_add_explicit((o), (v), memory_order_relaxed) ------------------ 476| 2.82k|} mem.c:mem_putstats: 482| 27|mem_putstats(isc_mem_t *ctx, size_t size) { 483| | atomic_fetch_sub_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 32| 27| atomic_fetch_sub_explicit((o), (v), memory_order_relaxed) ------------------ 484| 27|} mem.c:mem_put: 445| 27|mem_put(isc_mem_t *ctx, void *mem, size_t size, int flags) { 446| 27| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 390| 27| if (s == 0) { \ | | ------------------ | | | Branch (390:6): [True: 0, False: 27] | | ------------------ | | 391| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 86| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 392| 0| } ------------------ 447| | 448| 27| sdallocx(mem, size, flags | ctx->jemalloc_flags); 449| | 450| 27| freed_bytes += size; 451| | 452| 27| if (freed_bytes >= purge_threshold) { ------------------ | Branch (452:6): [True: 0, False: 27] ------------------ 453| 0| freed_bytes = 0; 454| 0| mem_purge(); 455| 0| } 456| 27|} mem.c:mem_create: 611| 10| unsigned int jemalloc_flags) { 612| 10| isc_mem_t *ctx = NULL; 613| | 614| 10| REQUIRE(ctxp != NULL && *ctxp == NULL); ------------------ | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 615| 10| REQUIRE(name != NULL); ------------------ | | 198| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 616| | 617| 10| ctx = mallocx(sizeof(*ctx), 618| 10| jemalloc_flags | ISC_MEM_ALIGN(isc_os_cacheline())); ------------------ | | 138| 10| ((int)(((size_t)(a) < (size_t)INT_MAX) \ | | ------------------ | | | Branch (138:9): [True: 10, False: 0] | | ------------------ | | 139| 10| ? ffs((int)(a)) - 1 \ | | 140| 10| : ffs((int)(((size_t)(a)) >> 32)) + 31)) ------------------ 619| 10| CHECK_OOM(ctx, sizeof(*ctx)); ------------------ | | 244| 10|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (244:37): [True: 10, False: 0] | | | Branch (244:54): [True: 0, False: 0] | | ------------------ ------------------ 620| | 621| 10| *ctx = (isc_mem_t){ 622| 10| .magic = MEM_MAGIC, ------------------ | | 121| 10|#define MEM_MAGIC ISC_MAGIC('M', 'e', 'm', 'C') | | ------------------ | | | | 31| 10|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 623| 10| .debugging = debugging, 624| 10| .jemalloc_flags = jemalloc_flags, 625| 10| .checkfree = true, 626| 10| .name = strdup(name), 627| 10| }; 628| | 629| 10| isc_mutex_init(&ctx->lock); ------------------ | | 68| 10|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 10| { \ | | | | 80| 10| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 10| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 288| 10| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (288:6): [True: 0, False: 10] | | | | | | ------------------ | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 223| 0| { \ | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 228| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 290| 0| } | | | | ------------------ | | | | 82| 10| } | | ------------------ ------------------ 630| 10| isc_refcount_init(&ctx->references, 1); ------------------ | | 44| 10|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 631| | 632| 5.14k| for (size_t i = 0; i < ARRAY_SIZE(ctx->stat_s); i++) { ------------------ | | 98| 5.14k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (632:21): [True: 5.13k, False: 10] ------------------ 633| 5.13k| atomic_init(&ctx->stat_s[i].inuse, 0); 634| 5.13k| } 635| | 636| | /* Reserve the [-1] index for ISC_TID_UNKNOWN */ 637| 10| ctx->stat = &ctx->stat_s[1]; 638| | 639| 10| atomic_init(&ctx->hi_water, 0); 640| 10| atomic_init(&ctx->lo_water, 0); 641| | 642| 10| ISC_LIST_INIT(ctx->pools); ------------------ | | 43| 10| do { \ | | 44| 10| (list).head = NULL; \ | | 45| 10| (list).tail = NULL; \ | | 46| 10| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 10] | | ------------------ ------------------ 643| | 644| |#if ISC_MEM_TRACKLINES 645| | if ((ctx->debugging & ISC_MEM_DEBUGRECORD) != 0) { 646| | unsigned int i; 647| | size_t debuglist_size = ISC_CHECKED_MUL(DEBUG_TABLE_COUNT, 648| | sizeof(debuglist_t)); 649| | 650| | ctx->debuglist = mallocx(debuglist_size, jemalloc_flags); 651| | CHECK_OOM(ctx->debuglist, debuglist_size); 652| | 653| | for (i = 0; i < DEBUG_TABLE_COUNT; i++) { 654| | ISC_LIST_INIT(ctx->debuglist[i]); 655| | } 656| | } 657| |#endif /* if ISC_MEM_TRACKLINES */ 658| | 659| 10| LOCK(&contextslock); ------------------ | | 26| 10| { \ | | 27| 10| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 10| __FILE__, __LINE__)); \ | | 29| 10| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 10|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 10| { \ | | | | | | 86| 10| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 10| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 288| 10| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 10] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 88| 10| } | | | | ------------------ | | ------------------ | | 30| 10| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 10| __FILE__, __LINE__)); \ | | 32| 10| } ------------------ 660| 10| ISC_LIST_INITANDAPPEND(contexts, ctx, link); ------------------ | | 106| 10| __ISC_LIST_APPENDUNSAFE(list, elt, link) | | ------------------ | | | | 88| 10| do { \ | | | | 89| 10| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 8, False: 2] | | | | ------------------ | | | | 90| 8| (list).tail->link.next = (elt); \ | | | | 91| 8| } else { \ | | | | 92| 2| (list).head = (elt); \ | | | | 93| 2| } \ | | | | 94| 10| (elt)->link.prev = (list).tail; \ | | | | 95| 10| (elt)->link.next = NULL; \ | | | | 96| 10| (list).tail = (elt); \ | | | | 97| 10| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 10] | | | | ------------------ | | ------------------ ------------------ 661| 10| UNLOCK(&contextslock); ------------------ | | 34| 10| { \ | | 35| 10| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 10|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 10| { \ | | | | | | 92| 10| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 10| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 288| 10| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (288:6): [True: 0, False: 10] | | | | | | | | ------------------ | | | | | | | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 223| 0| { \ | | | | | | | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 228| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 290| 0| } | | | | | | ------------------ | | | | | | 94| 10| } | | | | ------------------ | | ------------------ | | 36| 10| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 10| __FILE__, __LINE__)); \ | | 38| 10| } ------------------ 662| | 663| 10| *ctxp = ctx; 664| 10|} 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| 20|isc_os_cacheline(void) { 205| 20| return isc__os_cacheline; 206| 20|} 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_load_rsa_public_from_components: 727| 12| EVP_PKEY **pkeyp) { 728| 12| OSSL_PARAM_BLD *bld = NULL; 729| 12| EVP_PKEY_CTX *pctx = NULL; 730| 12| OSSL_PARAM *params = NULL; 731| 12| isc_result_t result; 732| | 733| 12| REQUIRE(pkeyp != NULL && *pkeyp == NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 12, False: 0] | | | | | Branch (42:11): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 734| 12| REQUIRE(c != NULL && c->n != NULL && c->e != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 48| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 12, False: 0] | | | | | Branch (42:11): [True: 12, False: 0] | | | | | Branch (42:11): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 735| | 736| 12| bld = OSSL_PARAM_BLD_new(); 737| 12| if (bld == NULL) { ------------------ | Branch (737:6): [True: 0, False: 12] ------------------ 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| 12| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, c->n) != 1) { ------------------ | Branch (741:6): [True: 0, False: 12] ------------------ 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| 12| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, c->e) != 1) { ------------------ | Branch (745:6): [True: 0, False: 12] ------------------ 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| 12| params = OSSL_PARAM_BLD_to_param(bld); 750| 12| if (params == NULL) { ------------------ | Branch (750:6): [True: 0, False: 12] ------------------ 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| 12| pctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); 755| 12| if (pctx == NULL) { ------------------ | Branch (755:6): [True: 0, False: 12] ------------------ 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| 12| if (EVP_PKEY_fromdata_init(pctx) != 1) { ------------------ | Branch (759:6): [True: 0, False: 12] ------------------ 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| 12| if (EVP_PKEY_fromdata(pctx, pkeyp, EVP_PKEY_PUBLIC_KEY, params) != 1) { ------------------ | Branch (763:6): [True: 0, False: 12] ------------------ 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| 12| result = ISC_R_SUCCESS; 768| | 769| 12|cleanup: 770| 12| EVP_PKEY_CTX_free(pctx); 771| 12| OSSL_PARAM_free(params); 772| 12| OSSL_PARAM_BLD_free(bld); 773| 12| return result; 774| 12|} isc_ossl_wrap_rsa_components_cleanup: 23| 12|isc_ossl_wrap_rsa_components_cleanup(isc_ossl_wrap_rsa_components_t *c) { 24| 12| REQUIRE(c != NULL); ------------------ | | 198| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 25| | 26| 12| if (!c->needs_cleanup) { ------------------ | Branch (26:6): [True: 0, False: 12] ------------------ 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| 12| BN_free(c->e); 37| 12| BN_free(c->n); 38| 12| BN_clear_free(c->d); 39| 12| BN_clear_free(c->p); 40| 12| BN_clear_free(c->q); 41| 12| BN_clear_free(c->dmp1); 42| 12| BN_clear_free(c->dmq1); 43| 12| BN_clear_free(c->iqmp); 44| | 45| | c->needs_cleanup = false; 46| 12|} isc_parse_uint32: 26| 1.23k|isc_parse_uint32(uint32_t *uip, const char *string, int base) { 27| 1.23k| unsigned long n; 28| 1.23k| uint32_t r; 29| 1.23k| char *e; 30| 1.23k| if (!isalnum((unsigned char)(string[0]))) { ------------------ | Branch (30:6): [True: 0, False: 1.23k] ------------------ 31| 0| return ISC_R_BADNUMBER; 32| 0| } 33| 1.23k| errno = 0; 34| 1.23k| n = strtoul(string, &e, base); 35| 1.23k| if (*e != '\0') { ------------------ | Branch (35:6): [True: 0, False: 1.23k] ------------------ 36| 0| return ISC_R_BADNUMBER; 37| 0| } 38| | /* 39| | * Where long is 64 bits we need to convert to 32 bits then test for 40| | * equality. This is a no-op on 32 bit machines and a good compiler 41| | * will optimise it away. 42| | */ 43| 1.23k| r = (uint32_t)n; 44| 1.23k| if ((n == ULONG_MAX && errno == ERANGE) || (n != (unsigned long)r)) { ------------------ | Branch (44:7): [True: 20, False: 1.21k] | Branch (44:25): [True: 19, False: 1] | Branch (44:45): [True: 100, False: 1.11k] ------------------ 45| 119| return ISC_R_RANGE; 46| 119| } 47| 1.11k| *uip = r; 48| 1.11k| return ISC_R_SUCCESS; 49| 1.23k|} isc_rwlock_init: 315| 2.05k|isc_rwlock_init(isc_rwlock_t *rwl) { 316| 2.05k| REQUIRE(rwl != NULL); ------------------ | | 198| 2.05k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2.05k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2.05k, False: 0] | | | | ------------------ | | | | 43| 2.05k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 317| | 318| 2.05k| atomic_init(&rwl->writers_lock, ISC_RWLOCK_UNLOCKED); ------------------ | | 69| 2.05k|#define ISC_RWLOCK_UNLOCKED false ------------------ 319| 2.05k| atomic_init(&rwl->writers_barrier, 0); 320| 2.05k| atomic_init(&rwl->readers_ingress, 0); 321| | atomic_init(&rwl->readers_egress, 0); 322| 2.05k| LIBISC_RWLOCK_INIT(rwl); 323| 2.05k|} isc_thread_getstacksize: 171| 2|isc_thread_getstacksize(void) { 172| 2| size_t stacksize = 0; 173| | 174| 2|#if HAVE_PTHREAD_ATTR_GETSTACKSIZE 175| 2| int ret = pthread_attr_getstacksize(&isc__thread_attr, &stacksize); 176| 2| PTHREADS_RUNTIME_CHECK(pthread_attr_getstacksize, ret); ------------------ | | 288| 2| if ((ret) != 0) { \ | | ------------------ | | | Branch (288:6): [True: 0, False: 2] | | ------------------ | | 289| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | ------------------ | | | | 234| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | ------------------ | | | | | | 223| 0| { \ | | | | | | 224| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | 225| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | ------------------ | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | ------------------ | | | | | | 226| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | 227| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | 228| 0| } | | | | ------------------ | | ------------------ | | 290| 0| } ------------------ 177| 2|#endif /* HAVE_PTHREAD_ATTR_GETSTACKSIZE */ 178| | 179| 2| return stacksize; 180| 2|} isc_tid_count: 57| 8|isc_tid_count(void) { 58| 8| return tid_count; 59| 8|} 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|} 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|}