LLVMFuzzerInitialize: 37| 2|LLVMFuzzerInitialize(int *argc ISC_ATTR_UNUSED, char ***argv ISC_ATTR_UNUSED) { 38| 2| isc_mem_create("fuzz", &mctx); ------------------ | | 198| 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| 890|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 46| 890| isc_buffer_t buf; 47| 890| isc_result_t result; 48| 890| isc_token_t token; 49| 890| isc_tokentype_t expect; 50| 890| bool eol; 51| | 52| 890| if (size < sizeof(expect) + sizeof(eol)) { ------------------ | Branch (52:6): [True: 4, False: 886] ------------------ 53| 4| return 0; 54| 4| } 55| | 56| 886| (void)memmove(&expect, data, sizeof(expect)); 57| 886| data += sizeof(expect); 58| 886| size -= sizeof(expect); 59| | 60| 886| eol = *data != 0; 61| 886| data += 1; 62| 886| size -= 1; 63| | 64| 886| isc_buffer_constinit(&buf, data, size); ------------------ | | 557| 886| do { \ | | 558| 886| union { \ | | 559| 886| void *_var; \ | | 560| 886| const void *_const; \ | | 561| 886| } _deconst; \ | | 562| 886| _deconst._const = (_d); \ | | 563| 886| isc_buffer_init((_b), _deconst._var, (_l)); \ | | 564| 886| } while (0) | | ------------------ | | | Branch (564:11): [Folded, False: 886] | | ------------------ ------------------ 65| 886| isc_buffer_add(&buf, size); 66| 886| isc_buffer_setactive(&buf, size); 67| | 68| 886| CHECK(isc_lex_openbuffer(lex, &buf)); ------------------ | | 255| 886| { \ | | 256| 886| result = (r); \ | | 257| 886| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (257:7): [True: 0, False: 886] | | ------------------ | | 258| 0| goto cleanup; \ | | 259| 0| } \ | | 260| 886| } ------------------ 69| | 70| 17.0k| do { 71| 17.0k| result = isc_lex_getmastertoken(lex, &token, expect, eol); 72| 17.0k| } while (result == ISC_R_SUCCESS && token.type != isc_tokentype_eof); ------------------ | Branch (72:11): [True: 16.5k, False: 522] | Branch (72:38): [True: 16.1k, False: 364] ------------------ 73| | 74| 886|cleanup: 75| 886| return 0; 76| 886|} 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); ------------------ | | 198| 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: 644| 4|dst__openssleddsa_init(dst_func_t **funcp, unsigned char algorithm) { 645| 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))) | | ------------------ ------------------ 646| | 647| 4| if (*funcp == NULL) { ------------------ | Branch (647:6): [True: 4, False: 0] ------------------ 648| 4| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (648:7): [True: 4, False: 0] ------------------ 649| 4| *funcp = &openssleddsa_functions; 650| 4| } 651| 4| } 652| 4|} openssleddsa_link.c:check_algorithm: 584| 4|check_algorithm(unsigned char algorithm) { 585| 4| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 586| 4| EVP_PKEY *pkey = NULL; 587| 4| const eddsa_alginfo_t *alginfo = NULL; 588| 4| const unsigned char *key = NULL; 589| 4| const unsigned char *sig = NULL; 590| 4| const unsigned char test[] = "test"; 591| 4| isc_result_t result = ISC_R_SUCCESS; 592| 4| size_t key_len, sig_len; 593| | 594| 4| if (evp_md_ctx == NULL) { ------------------ | Branch (594:6): [True: 0, False: 4] ------------------ 595| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 596| 0| } 597| | 598| 4| switch (algorithm) { 599| 0|#if HAVE_OPENSSL_ED448 600| 2| case DST_ALG_ED448: ------------------ | Branch (600:2): [True: 2, False: 2] ------------------ 601| 2| sig = ed448_sig; 602| 2| sig_len = sizeof(ed448_sig) - 1; 603| 2| key = ed448_pub; 604| 2| key_len = sizeof(ed448_pub) - 1; 605| 2| alginfo = openssleddsa_alg_info(algorithm); 606| 2| break; 607| 0|#endif /* HAVE_OPENSSL_ED448 */ 608| 2| case DST_ALG_ED25519: ------------------ | Branch (608:2): [True: 2, False: 2] ------------------ 609| 2| sig = ed25519_sig; 610| 2| sig_len = sizeof(ed25519_sig) - 1; 611| 2| key = ed25519_pub; 612| 2| key_len = sizeof(ed25519_pub) - 1; 613| 2| alginfo = openssleddsa_alg_info(algorithm); 614| 2| break; 615| 0| default: ------------------ | Branch (615:2): [True: 0, False: 4] ------------------ 616| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 617| 4| } 618| | 619| 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))) | | ------------------ ------------------ 620| 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| } ------------------ 621| | 622| | /* 623| | * Check that we can verify the signature. 624| | */ 625| 4| if (EVP_DigestVerifyInit(evp_md_ctx, NULL, NULL, NULL, pkey) != 1 || ------------------ | Branch (625:6): [True: 0, False: 4] ------------------ 626| 4| EVP_DigestVerify(evp_md_ctx, sig, sig_len, test, ------------------ | Branch (626:6): [True: 0, False: 4] ------------------ 627| 4| sizeof(test) - 1) != 1) 628| 0| { 629| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 630| 0| } 631| | 632| 4|cleanup: 633| 4| if (pkey != NULL) { ------------------ | Branch (633:6): [True: 4, False: 0] ------------------ 634| 4| EVP_PKEY_free(pkey); 635| 4| } 636| 4| if (evp_md_ctx != NULL) { ------------------ | Branch (636:6): [True: 4, False: 0] ------------------ 637| | EVP_MD_CTX_destroy(evp_md_ctx); 638| 4| } 639| 4| ERR_clear_error(); 640| 4| return result; 641| 4|} openssleddsa_link.c:openssleddsa_alg_info: 54| 4|openssleddsa_alg_info(unsigned int key_alg) { 55| 4| if (key_alg == DST_ALG_ED25519) { ------------------ | Branch (55:6): [True: 2, False: 2] ------------------ 56| 2| static const eddsa_alginfo_t ed25519_alginfo = { 57| 2| .pkey_type = EVP_PKEY_ED25519, 58| 2| .nid = NID_ED25519, 59| 2| .key_size = DNS_KEY_ED25519SIZE, ------------------ | | 74| 2|#define DNS_KEY_ED25519SIZE 32 ------------------ 60| 2| .sig_size = DNS_SIG_ED25519SIZE, ------------------ | | 75| 2|#define DNS_SIG_ED25519SIZE 64 ------------------ 61| 2| }; 62| 2| return &ed25519_alginfo; 63| 2| } 64| 2|#if HAVE_OPENSSL_ED448 65| 2| if (key_alg == DST_ALG_ED448) { ------------------ | Branch (65:6): [True: 2, False: 0] ------------------ 66| 2| static const eddsa_alginfo_t ed448_alginfo = { 67| 2| .pkey_type = EVP_PKEY_ED448, 68| 2| .nid = NID_ED448, 69| 2| .key_size = DNS_KEY_ED448SIZE, ------------------ | | 77| 2|#define DNS_KEY_ED448SIZE 57 ------------------ 70| 2| .sig_size = DNS_SIG_ED448SIZE, ------------------ | | 78| 2|#define DNS_SIG_ED448SIZE 114 ------------------ 71| 2| }; 72| 2| return &ed448_alginfo; 73| 2| } 74| 0|#endif /* HAVE_OPENSSL_ED448 */ 75| 0| return NULL; 76| 2|} openssleddsa_link.c:raw_key_to_ossl: 80| 4| const unsigned char *key, size_t *key_len, EVP_PKEY **pkey) { 81| 4| isc_result_t result; 82| 4| int pkey_type = alginfo->pkey_type; 83| 4| size_t len = alginfo->key_size; 84| | 85| 4| result = (private ? DST_R_INVALIDPRIVATEKEY : DST_R_INVALIDPUBLICKEY); ------------------ | Branch (85:12): [True: 0, False: 4] ------------------ 86| 4| if (*key_len < len) { ------------------ | Branch (86:6): [True: 0, False: 4] ------------------ 87| 0| return result; 88| 0| } 89| | 90| 4| if (private) { ------------------ | Branch (90:6): [True: 0, False: 4] ------------------ 91| 0| *pkey = EVP_PKEY_new_raw_private_key(pkey_type, NULL, key, len); 92| 4| } else { 93| 4| *pkey = EVP_PKEY_new_raw_public_key(pkey_type, NULL, key, len); 94| 4| } 95| 4| if (*pkey == NULL) { ------------------ | Branch (95:6): [True: 0, False: 4] ------------------ 96| 0| return dst__openssl_toresult(result); ------------------ | | 28| 0| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 0| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 0| __FILE__, __LINE__) ------------------ 97| 0| } 98| | 99| 4| *key_len = len; 100| 4| return ISC_R_SUCCESS; 101| 4|} dst__opensslrsa_init: 955| 12|dst__opensslrsa_init(dst_func_t **funcp, unsigned short algorithm) { 956| 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))) | | ------------------ ------------------ 957| | 958| 12| if (*funcp == NULL) { ------------------ | Branch (958:6): [True: 12, False: 0] ------------------ 959| 12| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (959:7): [True: 12, False: 0] ------------------ 960| 12| *funcp = &opensslrsa_functions; 961| 12| } 962| 12| } 963| | 964| 12| if (rsa_exponent_min == NULL) { ------------------ | Branch (964:6): [True: 2, False: 10] ------------------ 965| 2| rsa_exponent_min = BN_new(); 966| 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))) | | ------------------ ------------------ 967| | 968| 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] | | ------------------ ------------------ 969| 2| } 970| | 971| 12| if (rsa_exponent_max == NULL) { ------------------ | Branch (971:6): [True: 2, False: 10] ------------------ 972| 2| rsa_exponent_max = BN_new(); 973| 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))) | | ------------------ ------------------ 974| | 975| 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] | | ------------------ ------------------ 976| 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] | | ------------------ ------------------ 977| 2| } 978| 12|} opensslrsa_link.c:check_algorithm: 895| 12|check_algorithm(unsigned short algorithm) { 896| 12| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 897| 12| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 898| 12| EVP_PKEY *pkey = NULL; 899| 12| const EVP_MD *type = NULL; 900| 12| const unsigned char *sig = NULL; 901| 12| isc_result_t result = ISC_R_SUCCESS; 902| 12| size_t len; 903| | 904| 12| switch (algorithm) { 905| 2| case DST_ALG_RSASHA1: ------------------ | Branch (905:2): [True: 2, False: 10] ------------------ 906| 4| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (906:2): [True: 2, False: 10] ------------------ 907| 4| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 908| 4| sig = sha1_sig; 909| 4| len = sizeof(sha1_sig) - 1; 910| 4| break; 911| 2| case DST_ALG_RSASHA256: ------------------ | Branch (911:2): [True: 2, False: 10] ------------------ 912| 4| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (912:2): [True: 2, False: 10] ------------------ 913| 4| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 914| 4| sig = sha256_sig; 915| 4| len = sizeof(sha256_sig) - 1; 916| 4| break; 917| 2| case DST_ALG_RSASHA512: ------------------ | Branch (917:2): [True: 2, False: 10] ------------------ 918| 4| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (918:2): [True: 2, False: 10] ------------------ 919| 4| type = isc__crypto_md[ISC_MD_SHA512]; 920| 4| sig = sha512_sig; 921| 4| len = sizeof(sha512_sig) - 1; 922| 4| break; 923| 0| default: ------------------ | Branch (923:2): [True: 0, False: 12] ------------------ 924| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 925| 12| } 926| | 927| | /* 928| | * Construct pkey. 929| | */ 930| 12| c.e = BN_bin2bn(e_bytes, sizeof(e_bytes) - 1, NULL); 931| 12| c.n = BN_bin2bn(n_bytes, sizeof(n_bytes) - 1, NULL); 932| | 933| 12| result = isc_ossl_wrap_load_rsa_public_from_components(&c, &pkey); 934| 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))) | | ------------------ ------------------ 935| | 936| | /* 937| | * Check that we can verify the signature. 938| | */ 939| 12| if (EVP_DigestInit_ex(evp_md_ctx, type, NULL) != 1 || ------------------ | Branch (939:6): [True: 0, False: 12] ------------------ 940| 12| EVP_DigestUpdate(evp_md_ctx, "test", 4) != 1 || ------------------ | Branch (940:6): [True: 0, False: 12] ------------------ 941| 12| EVP_VerifyFinal(evp_md_ctx, sig, len, pkey) != 1) ------------------ | Branch (941:6): [True: 0, False: 12] ------------------ 942| 0| { 943| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 266| 0| { \ | | 267| 0| result = (r); \ | | 268| 0| goto cleanup; \ | | 269| 0| } ------------------ 944| 0| } 945| | 946| 12|cleanup: 947| 12| isc_ossl_wrap_rsa_components_cleanup(&c); 948| 12| EVP_PKEY_free(pkey); 949| | EVP_MD_CTX_destroy(evp_md_ctx); 950| 12| ERR_clear_error(); 951| 12| return result; 952| 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: 471| 2|dns__qpzone_initialize(void) { 472| 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 (472:23): [True: 2.04k, False: 2] ------------------ 473| 2.04k| NODE_INITLOCK(&qpzone_buckets_g[idx].lock); ------------------ | | 28| 2.04k|#define NODE_INITLOCK(l) isc_rwlock_init((l)) ------------------ 474| 2.04k| } 475| 2|} dns__zone_keymgmt_initialize: 16143| 2|dns__zone_keymgmt_initialize(void) { 16144| 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 (16144:23): [True: 2.04k, False: 2] ------------------ 16145| 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| } | | ------------------ ------------------ 16146| 2.04k| } 16147| 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: 910| 2|isc_crypto_fips_mode(void) { 911| | return EVP_default_properties_is_fips_enabled(NULL) != 0; 912| 2|} isc__crypto_initialize: 964| 2|isc__crypto_initialize(void) { 965| | /* 966| | * We call OPENSSL_cleanup() manually, in a correct order, thus disable 967| | * the automatic atexit() handler. 968| | */ 969| 2| uint64_t opts = OPENSSL_INIT_LOAD_CONFIG | OPENSSL_INIT_NO_ATEXIT; 970| | 971| 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] | | ------------------ ------------------ 972| | 973| 2| register_algorithms(); 974| | 975| |#if defined(ENABLE_FIPS_MODE) 976| | if (isc_crypto_fips_enable() != ISC_R_SUCCESS) { 977| | ERR_clear_error(); 978| | FATAL_ERROR("Failed to toggle FIPS mode but is " 979| | "required for this build"); 980| | } 981| |#endif 982| | 983| | /* Protect ourselves against unseeded PRNG */ 984| 2| if (RAND_status() != 1) { ------------------ | Branch (984:6): [True: 0, False: 2] ------------------ 985| 0| isc_ossl_wrap_logged_toresult( ------------------ | | 26| 0| isc__ossl_wrap_logged_toresult(category, module, funcname, fallback, \ | | 27| 0| __FILE__, __LINE__) ------------------ 986| 0| ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_CRYPTO, 987| 0| "RAND_status", ISC_R_CRYPTOFAILURE); 988| 0| FATAL_ERROR("OpenSSL pseudorandom number generator " ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 989| 0| "cannot be initialized (see the `PRNG not " 990| 0| "seeded' message in the OpenSSL FAQ)"); 991| 0| } 992| 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| 886| const unsigned int length) { 525| 886| REQUIRE(b != NULL); ------------------ | | 198| 886|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 886| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 886, False: 0] | | | | ------------------ | | | | 43| 886| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 886| *b = (isc_buffer_t){ 528| 886| .base = base, 529| 886| .length = length, 530| 886| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 886|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 886| { \ | | | | 27| 886| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 886|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 886| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 886|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 886| } | | ------------------ ------------------ 531| 886| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 886|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 886| }; 533| 886|} isc_lex_getmastertoken.c:isc_buffer_add: 652| 886|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 886| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 886|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.77k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 886, False: 0] | | | | | Branch (42:11): [True: 886, False: 0] | | | | ------------------ | | | | 43| 886| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 886| REQUIRE(b->used + n <= b->length); ------------------ | | 198| 886|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 886| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 886, False: 0] | | | | ------------------ | | | | 43| 886| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 886| b->used += n; 657| 886|} isc_lex_getmastertoken.c:isc_buffer_setactive: 771| 886|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 886| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 886|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.77k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 886, False: 0] | | | | | Branch (42:11): [True: 886, False: 0] | | | | ------------------ | | | | 43| 886| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 886| REQUIRE(b->current + n <= b->used); ------------------ | | 198| 886|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 886| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 886, False: 0] | | | | ------------------ | | | | 43| 886| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 886| b->active = b->current + n; 776| 886|} lex.c:isc_buffer_allocate: 1077| 903| const unsigned int length) { 1078| 903| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 198| 903|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.80k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 903, False: 0] | | | | | Branch (42:11): [True: 903, False: 0] | | | | ------------------ | | | | 43| 903| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1079| | 1080| 903| isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length); ------------------ | | 128| 903|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1081| 903| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1082| | 1083| 903| isc_buffer_init(dbuf, bdata, length); 1084| 903| dbuf->extra = length; 1085| 903| isc_buffer_setmctx(dbuf, mctx); 1086| | 1087| 903| *dbufp = dbuf; 1088| 903|} lex.c:isc_buffer_init: 524| 903| const unsigned int length) { 525| 903| REQUIRE(b != NULL); ------------------ | | 198| 903|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 903| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 903, False: 0] | | | | ------------------ | | | | 43| 903| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 903| *b = (isc_buffer_t){ 528| 903| .base = base, 529| 903| .length = length, 530| 903| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 903|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 903| { \ | | | | 27| 903| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 903|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 903| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 903|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 903| } | | ------------------ ------------------ 531| 903| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 903|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 903| }; 533| 903|} lex.c:isc_buffer_setmctx: 1091| 903|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1092| 903| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 903|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.80k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 903, False: 0] | | | | | Branch (42:11): [True: 903, False: 0] | | | | ------------------ | | | | 43| 903| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1093| | 1094| 903| b->mctx = mctx; 1095| 903|} 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); ------------------ | | 148| 17| do { \ | | 149| 17| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 150| 17| (p) = NULL; \ | | 151| 17| } while (0) | | ------------------ | | | Branch (151: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); ------------------ | | 148| 0| do { \ | | 149| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 150| 0| (p) = NULL; \ | | 151| 0| } while (0) | | ------------------ | | | Branch (151: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| 17.0k|isc_buffer_compact(isc_buffer_t *restrict b) { 1049| 17.0k| unsigned int length; 1050| 17.0k| 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| 17.0k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 17.0k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 17.0k, False: 0] | | | | | Branch (42:11): [True: 17.0k, False: 0] | | | | ------------------ | | | | 43| 17.0k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1059| | 1060| 17.0k| src = isc_buffer_current(b); ------------------ | | 145| 17.0k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1061| 17.0k| length = isc_buffer_remaininglength(b); ------------------ | | 159| 17.0k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 1062| 17.0k| if (length > 0U) { ------------------ | Branch (1062:6): [True: 12.5k, False: 4.56k] ------------------ 1063| 12.5k| (void)memmove(b->base, src, (size_t)length); 1064| 12.5k| } 1065| | 1066| 17.0k| if (b->active > b->current) { ------------------ | Branch (1066:6): [True: 0, False: 17.0k] ------------------ 1067| 0| b->active -= b->current; 1068| 17.0k| } else { 1069| 17.0k| b->active = 0; 1070| 17.0k| } 1071| 17.0k| b->current = 0; 1072| 17.0k| b->used = length; 1073| 17.0k|} 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| 22.5M|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1111| 22.5M| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 198| 22.5M|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 45.1M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 22.5M, False: 0] | | | | | Branch (42:11): [True: 22.5M, False: 0] | | | | ------------------ | | | | 43| 22.5M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1112| | 1113| 22.5M| size_t len; 1114| | 1115| 22.5M| len = dbuf->length; 1116| 22.5M| if ((len - dbuf->used) >= size) { ------------------ | Branch (1116:6): [True: 22.5M, False: 0] ------------------ 1117| 22.5M| return ISC_R_SUCCESS; 1118| 22.5M| } 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); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1140| 0| if (old_base != NULL) { ------------------ | Branch (1140:7): [True: 0, False: 0] ------------------ 1141| 0| memmove(dbuf->base, old_base, dbuf->used); 1142| 0| } 1143| 0| dbuf->dynamic = true; 1144| 0| } else { 1145| 0| dbuf->base = isc_mem_creget(dbuf->mctx, dbuf->base, ------------------ | | 135| 0| isc__mem_reget((c), (p), ISC_CHECKED_MUL((o), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 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| }) | | ------------------ | | 136| 0| ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 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| }) | | ------------------ | | 137| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1146| 0| dbuf->length, len, sizeof(char)); 1147| 0| } 1148| 0| dbuf->length = (unsigned int)len; 1149| | 1150| 0| return ISC_R_SUCCESS; 1151| 0|} lex.c:isc_buffer_putuint8: 869| 22.5M|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 22.5M| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 22.5M| { \ | | 858| 22.5M| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 22.5M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 45.1M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 22.5M, False: 0] | | | | | | | Branch (42:11): [True: 22.5M, False: 0] | | | | | | ------------------ | | | | | | 43| 22.5M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 22.5M| \ | | 860| 22.5M| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 22.5M, False: 0] | | ------------------ | | 861| 22.5M| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 22.5M| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 200| 22.5M|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 22.5M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 22.5M, False: 0] | | | | | | ------------------ | | | | | | 49| 22.5M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 22.5M| } \ | | 864| 22.5M| \ | | 865| 22.5M| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 198| 22.5M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 22.5M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 22.5M, False: 0] | | | | | | ------------------ | | | | | | 43| 22.5M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 22.5M| } ------------------ 871| | 872| 22.5M| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 22.5M| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 22.5M| b->used += sizeof(val); 874| 22.5M| cp[0] = val; 875| 22.5M|} lex.c:isc_buffer_getuint8: 848| 22.5M|isc_buffer_getuint8(isc_buffer_t *restrict b) { 849| 22.5M| uint8_t val = 0; 850| 22.5M| isc_result_t result = isc_buffer_peekuint8(b, &val); 851| 22.5M| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 200| 22.5M|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 22.5M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 22.5M, False: 0] | | | | ------------------ | | | | 49| 22.5M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 852| 22.5M| b->current += sizeof(val); 853| 22.5M| return val; 854| 22.5M|} lex.c:isc_buffer_peekuint8: 839| 22.5M|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 840| 22.5M| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 22.5M| { \ | | 832| 22.5M| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 198| 22.5M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 45.1M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 22.5M, False: 0] | | | | | | | Branch (42:11): [True: 22.5M, False: 0] | | | | | | ------------------ | | | | | | 43| 22.5M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 22.5M| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 22.5M] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 22.5M| } ------------------ 841| | 842| 22.5M| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 22.5M| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 843| | SET_IF_NOT_NULL(valp, (uint8_t)(cp[0])); ------------------ | | 104| 22.5M| if ((obj) != NULL) { \ | | ------------------ | | | Branch (104:6): [True: 22.5M, False: 0] | | ------------------ | | 105| 22.5M| *(obj) = (val); \ | | 106| 22.5M| } ------------------ 844| 22.5M| return ISC_R_SUCCESS; 845| 22.5M|} lex.c:isc_buffer_first: 790| 401|isc_buffer_first(isc_buffer_t *restrict b) { 791| 401| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 198| 401|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 802| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 401, False: 0] | | | | | Branch (42:11): [True: 401, False: 0] | | | | ------------------ | | | | 43| 401| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 792| | 793| 401| b->current = 0; 794| 401|} isc_lib_initialize: 57| 2|isc_lib_initialize(void) { 58| 2| isc__lib_initialize(); 59| 2|} mem.c:isc_tid: 39| 2.73k|isc_tid(void) { 40| 2.73k| return isc__tid_local; 41| 2.73k|} 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: 66| 2.71k|mallocx(size_t size, int flags) { 67| 2.71k| void *ptr = malloc(size); 68| 2.71k| INSIST(ptr != NULL); ------------------ | | 202| 2.71k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2.71k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2.71k, False: 0] | | | | ------------------ | | | | 55| 2.71k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 69| | 70| 2.71k| if ((flags & MALLOCX_ZERO) != 0) { ------------------ | | 32| 2.71k|#define MALLOCX_ZERO ((int)0x40) ------------------ | Branch (70:6): [True: 0, False: 2.71k] ------------------ 71| 0| memset(ptr, 0, size); 72| 0| } 73| | 74| 2.71k| return ptr; 75| 2.71k|} mem.c:sdallocx: 78| 27|sdallocx(void *ptr, size_t size ISC_ATTR_UNUSED, int flags ISC_ATTR_UNUSED) { 79| 27| free(ptr); 80| 27|} mem.c:sallocx: 59| 894|sallocx(void *ptr, int flags ISC_ATTR_UNUSED) { 60| 894| return malloc_usable_size(ptr); 61| 894|} 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)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 97| 2| lex->data = isc_mem_get(mctx, max_token + 1); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 98| 2| lex->mctx = mctx; 99| 2| lex->max_token = max_token; 100| 2| lex->comments = 0; 101| 2| lex->comment_ok = true; 102| 2| lex->last_was_eol = true; 103| 2| lex->brace_count = 0; 104| 2| lex->paren_count = 0; 105| 2| lex->saved_paren_count = 0; 106| 2| memset(lex->specials, 0, 256); 107| 2| ISC_LIST_INIT(lex->sources); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 108| 2| lex->magic = LEX_MAGIC; ------------------ | | 48| 2|#define LEX_MAGIC ISC_MAGIC('L', 'e', 'x', '!') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 109| | 110| 2| *lexp = lex; 111| 2|} isc_lex_openbuffer: 233| 886|isc_lex_openbuffer(isc_lex_t *lex, isc_buffer_t *buffer) { 234| 886| char name[128]; 235| | 236| | /* 237| | * Make 'buffer' the current input source for 'lex'. 238| | */ 239| | 240| 886| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 886|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.77k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 886, False: 0] | | | | | Branch (42:11): [True: 886, False: 0] | | | | ------------------ | | | | 43| 886| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 241| | 242| 886| snprintf(name, sizeof(name), "buffer-%p", buffer); 243| | 244| 886| new_source(lex, false, false, buffer, name); 245| 886| return ISC_R_SUCCESS; 246| 886|} isc_lex_gettoken: 330| 17.0k|isc_lex_gettoken(isc_lex_t *lex, unsigned int options, isc_token_t *tokenp) { 331| 17.0k| inputsource *source; 332| 17.0k| int c; 333| 17.0k| bool done = false; 334| 17.0k| bool no_comments = false; 335| 17.0k| bool escaped = false; 336| 17.0k| lexstate state = lexstate_start; 337| 17.0k| lexstate saved_state = lexstate_start; 338| 17.0k| isc_buffer_t *buffer; 339| 17.0k| FILE *stream; 340| 17.0k| char *curr, *prev; 341| 17.0k| size_t remaining; 342| 17.0k| uint32_t as_ulong; 343| 17.0k| unsigned int saved_options; 344| 17.0k| isc_result_t result; 345| | 346| | /* 347| | * Get the next token. 348| | */ 349| | 350| 17.0k| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 17.0k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 34.1k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 17.0k, False: 0] | | | | | Branch (42:11): [True: 17.0k, False: 0] | | | | ------------------ | | | | 43| 17.0k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 351| 17.0k| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 17.0k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 352| 17.0k| REQUIRE(tokenp != NULL); ------------------ | | 198| 17.0k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 17.0k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 17.0k, False: 0] | | | | ------------------ | | | | 43| 17.0k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 353| | 354| 17.0k| if (source == NULL) { ------------------ | Branch (354:6): [True: 0, False: 17.0k] ------------------ 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| 17.0k| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (362:6): [True: 0, False: 17.0k] ------------------ 363| 0| return source->result; 364| 0| } 365| | 366| 17.0k| lex->saved_paren_count = lex->paren_count; 367| 17.0k| source->saved_line = source->line; 368| | 369| 17.0k| if (isc_buffer_remaininglength(source->pushback) == 0 && source->at_eof) ------------------ | | 159| 17.0k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (369:6): [True: 4.56k, False: 12.5k] | Branch (369:59): [True: 0, False: 4.56k] ------------------ 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| 17.0k| isc_buffer_compact(source->pushback); 390| | 391| 17.0k| saved_options = options; 392| 17.0k| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && lex->paren_count > 0) { ------------------ | | 77| 17.0k|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (392:6): [True: 17.0k, False: 0] | Branch (392:50): [True: 0, False: 17.0k] ------------------ 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| 17.0k| curr = lex->data; 397| 17.0k| *curr = '\0'; 398| | 399| 17.0k| prev = NULL; 400| 17.0k| remaining = lex->max_token; 401| | 402| 17.0k|#ifdef HAVE_FLOCKFILE 403| 17.0k| if (source->is_file) { ------------------ | Branch (403:6): [True: 0, False: 17.0k] ------------------ 404| 0| flockfile(source->input); 405| 0| } 406| 17.0k|#endif /* ifdef HAVE_FLOCKFILE */ 407| | 408| 22.5M| do { 409| 22.5M| if (isc_buffer_remaininglength(source->pushback) == 0) { ------------------ | | 159| 22.5M|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (409:7): [True: 22.5M, False: 12.5k] ------------------ 410| 22.5M| if (source->is_file) { ------------------ | Branch (410:8): [True: 0, False: 22.5M] ------------------ 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| 22.5M| } else { 429| 22.5M| buffer = source->input; 430| | 431| 22.5M| if (buffer->current == buffer->used) { ------------------ | Branch (431:9): [True: 1.08k, False: 22.5M] ------------------ 432| 1.08k| c = EOF; 433| 1.08k| source->at_eof = true; 434| 22.5M| } else { 435| 22.5M| c = *((unsigned char *)buffer->base + 436| 22.5M| buffer->current); 437| 22.5M| buffer->current++; 438| 22.5M| } 439| 22.5M| } 440| 22.5M| if (c != EOF) { ------------------ | Branch (440:8): [True: 22.5M, False: 1.08k] ------------------ 441| 22.5M| source->result = pushandgrow(lex, source, c); 442| 22.5M| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (442:9): [True: 0, False: 22.5M] ------------------ 443| 0| result = source->result; 444| 0| goto done; 445| 0| } 446| 22.5M| } 447| 22.5M| } 448| | 449| 22.5M| if (!source->at_eof) { ------------------ | Branch (449:7): [True: 22.5M, False: 1.08k] ------------------ 450| 22.5M| if (state == lexstate_start) { ------------------ | Branch (450:8): [True: 458k, False: 22.1M] ------------------ 451| | /* Token has not started yet. */ 452| 458k| source->ignored = isc_buffer_consumedlength( ------------------ | | 158| 458k|#define isc_buffer_consumedlength(b) ((b)->current) /* b-a */ ------------------ 453| 458k| source->pushback); 454| 458k| } 455| 22.5M| c = isc_buffer_getuint8(source->pushback); 456| 22.5M| } else { 457| 1.08k| c = EOF; 458| 1.08k| } 459| | 460| 22.5M| if (c == '\n') { ------------------ | Branch (460:7): [True: 4.89k, False: 22.5M] ------------------ 461| 4.89k| source->line++; 462| 4.89k| } 463| | 464| 22.5M| if (lex->comment_ok && !no_comments) { ------------------ | Branch (464:7): [True: 22.5M, False: 0] | Branch (464:26): [True: 19.5M, False: 3.00M] ------------------ 465| 19.5M| if (!escaped && c == ';' && ------------------ | Branch (465:8): [True: 19.5M, False: 21.0k] | Branch (465:20): [True: 2.69k, False: 19.5M] ------------------ 466| 2.69k| ((lex->comments & ISC_LEXCOMMENT_DNSMASTERFILE) != ------------------ | | 97| 2.69k|#define ISC_LEXCOMMENT_DNSMASTERFILE 0x08 ------------------ | Branch (466:8): [True: 0, False: 2.69k] ------------------ 467| 2.69k| 0)) 468| 0| { 469| 0| saved_state = state; 470| 0| state = lexstate_eatline; 471| 0| no_comments = true; 472| 0| continue; 473| 19.5M| } else if (c == '/' && ------------------ | Branch (473:15): [True: 1.07k, False: 19.5M] ------------------ 474| 1.07k| (lex->comments & ------------------ | Branch (474:8): [True: 0, False: 1.07k] ------------------ 475| 1.07k| (ISC_LEXCOMMENT_C | ------------------ | | 94| 1.07k|#define ISC_LEXCOMMENT_C 0x01 ------------------ 476| 1.07k| ISC_LEXCOMMENT_CPLUSPLUS)) != 0) ------------------ | | 95| 1.07k|#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| 19.5M| } else if (c == '#' && ((lex->comments & ------------------ | Branch (482:15): [True: 4.82k, False: 19.5M] | Branch (482:27): [True: 0, False: 4.82k] ------------------ 483| 4.82k| ISC_LEXCOMMENT_SHELL) != 0)) ------------------ | | 96| 4.82k|#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| 19.5M| } 491| | 492| 22.5M| no_read: 493| | /* INSIST(c == EOF || (c >= 0 && c <= 255)); */ 494| 22.5M| switch (state) { 495| 459k| case lexstate_start: ------------------ | Branch (495:3): [True: 459k, False: 22.1M] ------------------ 496| 459k| if (c == EOF) { ------------------ | Branch (496:8): [True: 446, False: 458k] ------------------ 497| 446| lex->last_was_eol = false; 498| 446| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && ------------------ | | 77| 446|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (498:9): [True: 446, False: 0] ------------------ 499| 446| lex->paren_count != 0) ------------------ | Branch (499:9): [True: 0, False: 446] ------------------ 500| 0| { 501| 0| lex->paren_count = 0; 502| 0| result = ISC_R_UNBALANCED; 503| 0| goto done; 504| 0| } 505| 446| if ((options & ISC_LEXOPT_BTEXT) != 0 && ------------------ | | 84| 446|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (505:9): [True: 0, False: 446] ------------------ 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| 446| if ((options & ISC_LEXOPT_EOF) == 0) { ------------------ | | 63| 446|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ | Branch (512:9): [True: 0, False: 446] ------------------ 513| 0| result = ISC_R_EOF; 514| 0| goto done; 515| 0| } 516| 446| tokenp->type = isc_tokentype_eof; 517| 446| done = true; 518| 458k| } else if (c == ' ' || c == '\t') { ------------------ | Branch (518:15): [True: 440k, False: 18.5k] | Branch (518:27): [True: 1.88k, False: 16.6k] ------------------ 519| 442k| if (lex->last_was_eol && ------------------ | Branch (519:9): [True: 562, False: 441k] ------------------ 520| 562| (options & ISC_LEXOPT_INITIALWS) != 0) ------------------ | | 64| 562|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ ------------------ | Branch (520:9): [True: 0, False: 562] ------------------ 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| 442k| } else if (c == '\n') { ------------------ | Branch (527:15): [True: 2.48k, False: 14.1k] ------------------ 528| 2.48k| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 2.48k|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (528:9): [True: 2.48k, False: 0] ------------------ 529| 2.48k| tokenp->type = isc_tokentype_eol; 530| 2.48k| done = true; 531| 2.48k| } 532| 2.48k| lex->last_was_eol = true; 533| 14.1k| } else if (c == '\r') { ------------------ | Branch (533:15): [True: 6.73k, False: 7.40k] ------------------ 534| 6.73k| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 6.73k|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (534:9): [True: 6.73k, False: 0] ------------------ 535| 6.73k| state = lexstate_crlf; 536| 6.73k| } 537| 7.40k| } else if (c == '"' && ------------------ | Branch (537:15): [True: 760, False: 6.64k] ------------------ 538| 760| (options & ISC_LEXOPT_QSTRING) != 0) ------------------ | | 66| 760|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ | Branch (538:8): [True: 477, False: 283] ------------------ 539| 477| { 540| 477| lex->last_was_eol = false; 541| 477| no_comments = true; 542| 477| state = lexstate_qstring; 543| 6.93k| } else if (lex->specials[c]) { ------------------ | Branch (543:15): [True: 0, False: 6.93k] ------------------ 544| 0| lex->last_was_eol = false; 545| 0| if ((c == '(' || c == ')') && ------------------ | Branch (545:10): [True: 0, False: 0] | Branch (545:22): [True: 0, False: 0] ------------------ 546| 0| (options & ISC_LEXOPT_DNSMULTILINE) != 0) ------------------ | | 77| 0|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (546:9): [True: 0, False: 0] ------------------ 547| 0| { 548| 0| if (c == '(') { ------------------ | Branch (548:10): [True: 0, False: 0] ------------------ 549| 0| if (lex->paren_count == 0) { ------------------ | Branch (549:11): [True: 0, False: 0] ------------------ 550| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 551| 0| } 552| 0| lex->paren_count++; 553| 0| } else { 554| 0| if (lex->paren_count == 0) { ------------------ | Branch (554:11): [True: 0, False: 0] ------------------ 555| 0| result = 556| 0| ISC_R_UNBALANCED; 557| 0| goto done; 558| 0| } 559| 0| lex->paren_count--; 560| 0| if (lex->paren_count == 0) { ------------------ | Branch (560:11): [True: 0, False: 0] ------------------ 561| 0| options = saved_options; 562| 0| } 563| 0| } 564| 0| continue; 565| 0| } else if (c == '{' && ------------------ | Branch (565:16): [True: 0, False: 0] ------------------ 566| 0| (options & ISC_LEXOPT_BTEXT) != 0) ------------------ | | 84| 0|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (566:9): [True: 0, False: 0] ------------------ 567| 0| { 568| 0| if (lex->brace_count != 0) { ------------------ | Branch (568:10): [True: 0, False: 0] ------------------ 569| 0| result = ISC_R_UNBALANCED; 570| 0| goto done; 571| 0| } 572| 0| lex->brace_count++; 573| 0| options &= ~IWSEOL; ------------------ | | 293| 0|#define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 64| 0|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ | | ------------------ | | #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL) | | ------------------ | | | | 62| 0|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ | | ------------------ ------------------ 574| 0| state = lexstate_btext; 575| 0| no_comments = true; 576| 0| continue; 577| 0| } 578| 0| tokenp->type = isc_tokentype_special; 579| 0| tokenp->value.as_char = c; 580| 0| done = true; 581| 6.93k| } else if (isdigit((unsigned char)c) && ------------------ | Branch (581:15): [True: 2.82k, False: 4.10k] ------------------ 582| 2.82k| (options & ISC_LEXOPT_NUMBER) != 0) ------------------ | | 65| 2.82k|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ | Branch (582:8): [True: 1.27k, False: 1.55k] ------------------ 583| 1.27k| { 584| 1.27k| lex->last_was_eol = false; 585| 1.27k| if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 1.27k|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (585:9): [True: 0, False: 1.27k] ------------------ 586| 0| (c == '8' || c == '9')) ------------------ | Branch (586:10): [True: 0, False: 0] | Branch (586:22): [True: 0, False: 0] ------------------ 587| 0| { 588| 0| state = lexstate_string; 589| 1.27k| } else { 590| 1.27k| state = lexstate_number; 591| 1.27k| } 592| 1.27k| goto no_read; 593| 5.66k| } else { 594| 5.66k| lex->last_was_eol = false; 595| 5.66k| state = lexstate_string; 596| 5.66k| goto no_read; 597| 5.66k| } 598| 452k| break; 599| 452k| case lexstate_crlf: ------------------ | Branch (599:3): [True: 6.73k, False: 22.5M] ------------------ 600| 6.73k| if (c != '\n') { ------------------ | Branch (600:8): [True: 6.51k, False: 218] ------------------ 601| 6.51k| pushback(source, c); 602| 6.51k| } 603| 6.73k| tokenp->type = isc_tokentype_eol; 604| 6.73k| done = true; 605| 6.73k| lex->last_was_eol = true; 606| 6.73k| break; 607| 1.17M| case lexstate_number: ------------------ | Branch (607:3): [True: 1.17M, False: 21.4M] ------------------ 608| 1.17M| if (c == EOF || !isdigit((unsigned char)c)) { ------------------ | Branch (608:8): [True: 192, False: 1.16M] | Branch (608:20): [True: 1.07k, False: 1.16M] ------------------ 609| 1.27k| if (c == ' ' || c == '\t' || c == '\r' || ------------------ | Branch (609:9): [True: 198, False: 1.07k] | Branch (609:21): [True: 206, False: 866] | Branch (609:34): [True: 204, False: 662] ------------------ 610| 662| c == '\n' || c == EOF || lex->specials[c]) ------------------ | Branch (610:9): [True: 435, False: 227] | Branch (610:22): [True: 192, False: 35] | Branch (610:34): [True: 0, False: 35] ------------------ 611| 1.23k| { 612| 1.23k| int base; 613| 1.23k| if ((options & ISC_LEXOPT_OCTAL) != 0) { ------------------ | | 83| 1.23k|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (613:10): [True: 0, False: 1.23k] ------------------ 614| 0| base = 8; 615| 1.23k| } else if ((options & ------------------ | Branch (615:17): [True: 0, False: 1.23k] ------------------ 616| 1.23k| ISC_LEXOPT_CNUMBER) != 0) ------------------ | | 80| 1.23k|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ 617| 0| { 618| 0| base = 0; 619| 1.23k| } else { 620| 1.23k| base = 10; 621| 1.23k| } 622| 1.23k| pushback(source, c); 623| | 624| 1.23k| result = isc_parse_uint32( 625| 1.23k| &as_ulong, lex->data, base); 626| 1.23k| if (result == ISC_R_SUCCESS) { ------------------ | Branch (626:10): [True: 1.11k, False: 124] ------------------ 627| 1.11k| tokenp->type = 628| 1.11k| isc_tokentype_number; 629| 1.11k| tokenp->value.as_ulong = 630| 1.11k| as_ulong; 631| 1.11k| } else if (result == ISC_R_BADNUMBER) { ------------------ | Branch (631:17): [True: 0, False: 124] ------------------ 632| 0| isc_tokenvalue_t *v; 633| | 634| 0| tokenp->type = 635| 0| isc_tokentype_string; 636| 0| v = &(tokenp->value); 637| 0| v->as_textregion.base = 638| 0| lex->data; 639| 0| v->as_textregion.length = 640| 0| (unsigned int)(lex->max_token - 641| 0| remaining); 642| 124| } else { 643| 124| goto done; 644| 124| } 645| 1.11k| done = true; 646| 1.11k| continue; 647| 1.23k| } else if ((options & ISC_LEXOPT_CNUMBER) == ------------------ | | 80| 35|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ | Branch (647:16): [True: 35, False: 0] ------------------ 648| 35| 0 || 649| 0| ((c != 'x' && c != 'X') || ------------------ | Branch (649:11): [True: 0, False: 0] | Branch (649:23): [True: 0, False: 0] ------------------ 650| 0| (curr != &lex->data[1]) || ------------------ | Branch (650:10): [True: 0, False: 0] ------------------ 651| 0| (lex->data[0] != '0'))) ------------------ | Branch (651:10): [True: 0, False: 0] ------------------ 652| 35| { 653| | /* Above test supports hex numbers */ 654| 35| state = lexstate_string; 655| 35| } 656| 1.16M| } else if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 1.16M|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (656:15): [True: 0, False: 1.16M] ------------------ 657| 0| (c == '8' || c == '9')) ------------------ | Branch (657:9): [True: 0, False: 0] | Branch (657:21): [True: 0, False: 0] ------------------ 658| 0| { 659| 0| state = lexstate_string; 660| 0| } 661| 1.16M| if (remaining == 0U) { ------------------ | Branch (661:8): [True: 1, False: 1.16M] ------------------ 662| 1| grow_data(lex, &remaining, &curr, &prev); 663| 1| } 664| 1.16M| INSIST(remaining > 0U); ------------------ | | 202| 1.16M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.16M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.16M, False: 0] | | | | ------------------ | | | | 55| 1.16M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 665| 1.16M| *curr++ = c; 666| 1.16M| *curr = '\0'; 667| 1.16M| remaining--; 668| 1.16M| break; 669| 16.0M| case lexstate_string: ------------------ | Branch (669:3): [True: 16.0M, False: 6.51M] ------------------ 670| 16.0M| if (!escaped && c == '=' && ------------------ | Branch (670:8): [True: 16.0M, False: 16.3k] | Branch (670:20): [True: 2.00k, False: 16.0M] ------------------ 671| 2.00k| (options & ISC_LEXOPT_VPAIR) != 0) ------------------ | | 85| 2.00k|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ | Branch (671:8): [True: 1.20k, False: 796] ------------------ 672| 1.20k| { 673| 1.20k| if (remaining == 0U) { ------------------ | Branch (673:9): [True: 1, False: 1.20k] ------------------ 674| 1| grow_data(lex, &remaining, &curr, 675| 1| &prev); 676| 1| } 677| 1.20k| INSIST(remaining > 0U); ------------------ | | 202| 1.20k|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 1.20k, False: 0] | | | | ------------------ | | | | 55| 1.20k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 678| 1.20k| *curr++ = c; 679| 1.20k| *curr = '\0'; 680| 1.20k| remaining--; 681| 1.20k| state = lexstate_vpairstart; 682| 1.20k| break; 683| 1.20k| } 684| 16.0M| FALLTHROUGH; ------------------ | | 101| 16.0M|#define FALLTHROUGH [[fallthrough]] ------------------ 685| 16.0M| case lexstate_vpairstart: ------------------ | Branch (685:3): [True: 1.20k, False: 22.5M] ------------------ 686| 16.0M| if (state == lexstate_vpairstart) { ------------------ | Branch (686:8): [True: 1.20k, False: 16.0M] ------------------ 687| 1.20k| if (c == '"' && ------------------ | Branch (687:9): [True: 585, False: 623] ------------------ 688| 585| (options & ISC_LEXOPT_QVPAIR) != 0) ------------------ | | 86| 585|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ | Branch (688:9): [True: 391, False: 194] ------------------ 689| 391| { 690| 391| no_comments = true; 691| 391| state = lexstate_qvpair; 692| 391| break; 693| 391| } 694| 817| state = lexstate_vpair; 695| 817| } 696| 16.0M| FALLTHROUGH; ------------------ | | 101| 16.0M|#define FALLTHROUGH [[fallthrough]] ------------------ 697| 17.9M| case lexstate_vpair: ------------------ | Branch (697:3): [True: 1.87M, False: 20.7M] ------------------ 698| | /* 699| | * EOF needs to be checked before lex->specials[c] 700| | * as lex->specials[EOF] is not a good idea. 701| | */ 702| 17.9M| if (c == '\r' || c == '\n' || c == EOF || ------------------ | Branch (702:8): [True: 1.88k, False: 17.9M] | Branch (702:21): [True: 1.49k, False: 17.9M] | Branch (702:34): [True: 302, False: 17.9M] ------------------ 703| 17.9M| (!escaped && ------------------ | Branch (703:9): [True: 17.9M, False: 20.3k] ------------------ 704| 17.9M| (c == ' ' || c == '\t' || lex->specials[c]))) ------------------ | Branch (704:10): [True: 823, False: 17.9M] | Branch (704:22): [True: 808, False: 17.9M] | Branch (704:35): [True: 0, False: 17.9M] ------------------ 705| 5.30k| { 706| 5.30k| pushback(source, c); 707| 5.30k| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (707:9): [True: 0, False: 5.30k] ------------------ 708| 0| result = source->result; 709| 0| goto done; 710| 0| } 711| 5.30k| if (escaped && c == EOF) { ------------------ | Branch (711:9): [True: 696, False: 4.61k] | Branch (711:20): [True: 8, False: 688] ------------------ 712| 8| result = ISC_R_UNEXPECTEDEND; 713| 8| goto done; 714| 8| } 715| 5.29k| tokenp->type = (state == lexstate_string) ------------------ | Branch (715:20): [True: 4.48k, False: 817] ------------------ 716| 5.29k| ? isc_tokentype_string 717| 5.29k| : isc_tokentype_vpair; 718| 5.29k| tokenp->value.as_textregion.base = lex->data; 719| 5.29k| tokenp->value.as_textregion.length = 720| 5.29k| (unsigned int)(lex->max_token - 721| 5.29k| remaining); 722| 5.29k| done = true; 723| 5.29k| continue; 724| 5.30k| } 725| 17.9M| if ((options & ISC_LEXOPT_ESCAPE) != 0) { ------------------ | | 81| 17.9M|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ | Branch (725:8): [True: 17.9M, False: 0] ------------------ 726| 17.9M| escaped = (!escaped && c == '\\') ? true ------------------ | Branch (726:16): [True: 17.9M, False: 20.3k] | Branch (726:28): [True: 21.0k, False: 17.9M] ------------------ 727| 17.9M| : false; 728| 17.9M| } 729| 17.9M| if (remaining == 0U) { ------------------ | Branch (729:8): [True: 8, False: 17.9M] ------------------ 730| 8| grow_data(lex, &remaining, &curr, &prev); 731| 8| } 732| 17.9M| INSIST(remaining > 0U); ------------------ | | 202| 17.9M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 17.9M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 17.9M, False: 0] | | | | ------------------ | | | | 55| 17.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 733| 17.9M| *curr++ = c; 734| 17.9M| *curr = '\0'; 735| 17.9M| remaining--; 736| 17.9M| break; 737| 0| case lexstate_maybecomment: ------------------ | Branch (737:3): [True: 0, False: 22.5M] ------------------ 738| 0| if (c == '*' && (lex->comments & ISC_LEXCOMMENT_C) != 0) ------------------ | | 94| 0|#define ISC_LEXCOMMENT_C 0x01 ------------------ | Branch (738:8): [True: 0, False: 0] | Branch (738:20): [True: 0, False: 0] ------------------ 739| 0| { 740| 0| state = lexstate_ccomment; 741| 0| continue; 742| 0| } else if (c == '/' && (lex->comments & ------------------ | Branch (742:15): [True: 0, False: 0] | Branch (742:27): [True: 0, False: 0] ------------------ 743| 0| ISC_LEXCOMMENT_CPLUSPLUS) != 0) ------------------ | | 95| 0|#define ISC_LEXCOMMENT_CPLUSPLUS 0x02 ------------------ 744| 0| { 745| 0| state = lexstate_eatline; 746| 0| continue; 747| 0| } 748| 0| pushback(source, c); 749| 0| c = '/'; 750| 0| no_comments = false; 751| 0| state = saved_state; 752| 0| goto no_read; 753| 0| case lexstate_ccomment: ------------------ | Branch (753:3): [True: 0, False: 22.5M] ------------------ 754| 0| if (c == EOF) { ------------------ | Branch (754:8): [True: 0, False: 0] ------------------ 755| 0| result = ISC_R_UNEXPECTEDEND; 756| 0| goto done; 757| 0| } 758| 0| if (c == '*') { ------------------ | Branch (758:8): [True: 0, False: 0] ------------------ 759| 0| state = lexstate_ccommentend; 760| 0| } 761| 0| break; 762| 0| case lexstate_ccommentend: ------------------ | Branch (762:3): [True: 0, False: 22.5M] ------------------ 763| 0| if (c == EOF) { ------------------ | Branch (763:8): [True: 0, False: 0] ------------------ 764| 0| result = ISC_R_UNEXPECTEDEND; 765| 0| goto done; 766| 0| } 767| 0| if (c == '/') { ------------------ | Branch (767:8): [True: 0, False: 0] ------------------ 768| | /* 769| | * C-style comments become a single space. 770| | * We do this to ensure that a comment will 771| | * act as a delimiter for strings and 772| | * numbers. 773| | */ 774| 0| c = ' '; 775| 0| no_comments = false; 776| 0| state = saved_state; 777| 0| goto no_read; 778| 0| } else if (c != '*') { ------------------ | Branch (778:15): [True: 0, False: 0] ------------------ 779| 0| state = lexstate_ccomment; 780| 0| } 781| 0| break; 782| 0| case lexstate_eatline: ------------------ | Branch (782:3): [True: 0, False: 22.5M] ------------------ 783| 0| if ((c == '\n') || (c == EOF)) { ------------------ | Branch (783:8): [True: 0, False: 0] | Branch (783:23): [True: 0, False: 0] ------------------ 784| 0| no_comments = false; 785| 0| state = saved_state; 786| 0| goto no_read; 787| 0| } 788| 0| break; 789| 81.7k| case lexstate_qstring: ------------------ | Branch (789:3): [True: 81.7k, False: 22.5M] ------------------ 790| 3.00M| case lexstate_qvpair: ------------------ | Branch (790:3): [True: 2.92M, False: 19.6M] ------------------ 791| 3.00M| if (c == EOF) { ------------------ | Branch (791:8): [True: 99, False: 3.00M] ------------------ 792| 99| result = ISC_R_UNEXPECTEDEND; 793| 99| goto done; 794| 99| } 795| 3.00M| if (c == '"') { ------------------ | Branch (795:8): [True: 1.47k, False: 3.00M] ------------------ 796| 1.47k| if (escaped) { ------------------ | Branch (796:9): [True: 721, False: 755] ------------------ 797| 721| escaped = false; 798| | /* 799| | * Overwrite the preceding backslash. 800| | */ 801| 721| INSIST(prev != NULL); ------------------ | | 202| 721|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 721| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 721, False: 0] | | | | ------------------ | | | | 55| 721| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 802| 721| *prev = '"'; 803| 755| } else { 804| 755| tokenp->type = 805| 755| (state == lexstate_qstring) ------------------ | Branch (805:7): [True: 393, False: 362] ------------------ 806| 755| ? isc_tokentype_qstring 807| 755| : isc_tokentype_qvpair; 808| 755| tokenp->value.as_textregion.base = 809| 755| lex->data; 810| 755| tokenp->value.as_textregion.length = 811| 755| (unsigned int)(lex->max_token - 812| 755| remaining); 813| 755| no_comments = false; 814| 755| done = true; 815| 755| } 816| 3.00M| } else { 817| 3.00M| if (c == '\n' && !escaped && ------------------ | Branch (817:9): [True: 267, False: 3.00M] | Branch (817:22): [True: 14, False: 253] ------------------ 818| 14| (options & ISC_LEXOPT_QSTRINGMULTILINE) == ------------------ | | 82| 14|#define ISC_LEXOPT_QSTRINGMULTILINE 0x0200 /*%< Allow multiline "" strings */ ------------------ | Branch (818:9): [True: 14, False: 0] ------------------ 819| 14| 0) 820| 14| { 821| 14| pushback(source, c); 822| 14| result = ISC_R_UNBALANCEDQUOTES; 823| 14| goto done; 824| 14| } 825| 3.00M| if (c == '\\' && !escaped) { ------------------ | Branch (825:9): [True: 20.6k, False: 2.98M] | Branch (825:22): [True: 11.9k, False: 8.73k] ------------------ 826| 11.9k| escaped = true; 827| 2.99M| } else { 828| 2.99M| escaped = false; 829| 2.99M| } 830| 3.00M| if (remaining == 0U) { ------------------ | Branch (830:9): [True: 0, False: 3.00M] ------------------ 831| 0| grow_data(lex, &remaining, &curr, 832| 0| &prev); 833| 0| } 834| 3.00M| INSIST(remaining > 0U); ------------------ | | 202| 3.00M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 3.00M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 3.00M, False: 0] | | | | ------------------ | | | | 55| 3.00M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 835| 3.00M| prev = curr; 836| 3.00M| *curr++ = c; 837| 3.00M| *curr = '\0'; 838| 3.00M| remaining--; 839| 3.00M| } 840| 3.00M| break; 841| 3.00M| case lexstate_btext: ------------------ | Branch (841:3): [True: 0, False: 22.5M] ------------------ 842| 0| if (c == EOF) { ------------------ | Branch (842:8): [True: 0, False: 0] ------------------ 843| 0| result = ISC_R_UNEXPECTEDEND; 844| 0| goto done; 845| 0| } 846| 0| if (c == '{') { ------------------ | Branch (846:8): [True: 0, False: 0] ------------------ 847| 0| if (escaped) { ------------------ | Branch (847:9): [True: 0, False: 0] ------------------ 848| 0| escaped = false; 849| 0| } else { 850| 0| lex->brace_count++; 851| 0| } 852| 0| } else if (c == '}') { ------------------ | Branch (852:15): [True: 0, False: 0] ------------------ 853| 0| if (escaped) { ------------------ | Branch (853:9): [True: 0, False: 0] ------------------ 854| 0| escaped = false; 855| 0| } else { 856| 0| INSIST(lex->brace_count > 0); ------------------ | | 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))) | | ------------------ ------------------ 857| 0| lex->brace_count--; 858| 0| } 859| | 860| 0| if (lex->brace_count == 0) { ------------------ | Branch (860:9): [True: 0, False: 0] ------------------ 861| 0| tokenp->type = isc_tokentype_btext; 862| 0| tokenp->value.as_textregion.base = 863| 0| lex->data; 864| 0| tokenp->value.as_textregion.length = 865| 0| (unsigned int)(lex->max_token - 866| 0| remaining); 867| 0| no_comments = false; 868| 0| done = true; 869| 0| break; 870| 0| } 871| 0| } 872| | 873| 0| if (c == '\\' && !escaped) { ------------------ | Branch (873:8): [True: 0, False: 0] | Branch (873:21): [True: 0, False: 0] ------------------ 874| 0| escaped = true; 875| 0| } else { 876| 0| escaped = false; 877| 0| } 878| | 879| 0| if (remaining == 0U) { ------------------ | Branch (879:8): [True: 0, False: 0] ------------------ 880| 0| grow_data(lex, &remaining, &curr, &prev); 881| 0| } 882| 0| INSIST(remaining > 0U); ------------------ | | 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))) | | ------------------ ------------------ 883| 0| prev = curr; 884| 0| *curr++ = c; 885| 0| *curr = '\0'; 886| 0| remaining--; 887| 0| break; 888| 0| default: ------------------ | Branch (888:3): [True: 0, False: 22.5M] ------------------ 889| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 890| 22.5M| } 891| 22.5M| } while (!done); ------------------ | Branch (891:11): [True: 22.5M, False: 16.8k] ------------------ 892| | 893| 16.8k| result = ISC_R_SUCCESS; 894| 17.0k|done: 895| 17.0k|#ifdef HAVE_FLOCKFILE 896| 17.0k| if (source->is_file) { ------------------ | Branch (896:6): [True: 0, False: 17.0k] ------------------ 897| 0| funlockfile(source->input); 898| 0| } 899| 17.0k|#endif /* ifdef HAVE_FLOCKFILE */ 900| 17.0k| return result; 901| 16.8k|} isc_lex_getmastertoken: 905| 17.0k| isc_tokentype_t expect, bool eol) { 906| 17.0k| unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 62| 17.0k|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF | ------------------ | | 63| 17.0k|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ 907| 17.0k| ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 77| 17.0k|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE; ------------------ | | 81| 17.0k|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ 908| 17.0k| isc_result_t result; 909| | 910| 17.0k| if (expect == isc_tokentype_vpair) { ------------------ | Branch (910:6): [True: 944, False: 16.1k] ------------------ 911| 944| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 944|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 912| 16.1k| } else if (expect == isc_tokentype_qvpair) { ------------------ | Branch (912:13): [True: 9.99k, False: 6.13k] ------------------ 913| 9.99k| options |= ISC_LEXOPT_VPAIR; ------------------ | | 85| 9.99k|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ 914| 9.99k| options |= ISC_LEXOPT_QVPAIR; ------------------ | | 86| 9.99k|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ 915| 9.99k| } else if (expect == isc_tokentype_qstring) { ------------------ | Branch (915:13): [True: 1.91k, False: 4.21k] ------------------ 916| 1.91k| options |= ISC_LEXOPT_QSTRING; ------------------ | | 66| 1.91k|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ 917| 4.21k| } else if (expect == isc_tokentype_number) { ------------------ | Branch (917:13): [True: 2.16k, False: 2.05k] ------------------ 918| 2.16k| options |= ISC_LEXOPT_NUMBER; ------------------ | | 65| 2.16k|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ 919| 2.16k| } 920| 17.0k| result = isc_lex_gettoken(lex, options, token); 921| 17.0k| if (result == ISC_R_RANGE) { ------------------ | Branch (921:6): [True: 124, False: 16.9k] ------------------ 922| 124| isc_lex_ungettoken(lex, token); 923| 124| } 924| 17.0k| if (result != ISC_R_SUCCESS) { ------------------ | Branch (924:6): [True: 245, False: 16.8k] ------------------ 925| 245| return result; 926| 245| } 927| | 928| 16.8k| if (eol && ((token->type == isc_tokentype_eol) || ------------------ | Branch (928:6): [True: 16.0k, False: 817] | Branch (928:14): [True: 8.84k, False: 7.16k] ------------------ 929| 7.16k| (token->type == isc_tokentype_eof))) ------------------ | Branch (929:7): [True: 363, False: 6.80k] ------------------ 930| 9.20k| { 931| 9.20k| return ISC_R_SUCCESS; 932| 9.20k| } 933| 7.62k| if (token->type == isc_tokentype_string && ------------------ | Branch (933:6): [True: 4.48k, False: 3.14k] ------------------ 934| 4.48k| (expect == isc_tokentype_qstring || expect == isc_tokentype_qvpair)) ------------------ | Branch (934:7): [True: 871, False: 3.61k] | Branch (934:42): [True: 2.87k, False: 740] ------------------ 935| 3.74k| { 936| 3.74k| return ISC_R_SUCCESS; 937| 3.74k| } 938| 3.88k| if (token->type == isc_tokentype_vpair && ------------------ | Branch (938:6): [True: 817, False: 3.06k] ------------------ 939| 817| expect == isc_tokentype_qvpair) ------------------ | Branch (939:6): [True: 403, False: 414] ------------------ 940| 403| { 941| 403| return ISC_R_SUCCESS; 942| 403| } 943| 3.47k| if (token->type != expect) { ------------------ | Branch (943:6): [True: 277, False: 3.20k] ------------------ 944| 277| isc_lex_ungettoken(lex, token); 945| 277| if (token->type == isc_tokentype_eol || ------------------ | Branch (945:7): [True: 3, False: 274] ------------------ 946| 274| token->type == isc_tokentype_eof) ------------------ | Branch (946:7): [True: 82, False: 192] ------------------ 947| 85| { 948| 85| return ISC_R_UNEXPECTEDEND; 949| 85| } 950| 192| if (expect == isc_tokentype_number) { ------------------ | Branch (950:7): [True: 40, False: 152] ------------------ 951| 40| return ISC_R_BADNUMBER; 952| 40| } 953| 152| return ISC_R_UNEXPECTEDTOKEN; 954| 192| } 955| 3.20k| return ISC_R_SUCCESS; 956| 3.47k|} isc_lex_ungettoken: 991| 401|isc_lex_ungettoken(isc_lex_t *lex, isc_token_t *tokenp) { 992| 401| inputsource *source; 993| | /* 994| | * Unget the current token. 995| | */ 996| | 997| 401| REQUIRE(VALID_LEX(lex)); ------------------ | | 198| 401|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 802| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 401, False: 0] | | | | | Branch (42:11): [True: 401, False: 0] | | | | ------------------ | | | | 43| 401| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 998| 401| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 401|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 999| 401| REQUIRE(source != NULL); ------------------ | | 198| 401|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 401| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 401, False: 0] | | | | ------------------ | | | | 43| 401| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1000| 401| REQUIRE(tokenp != NULL); ------------------ | | 198| 401|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 401| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 401, False: 0] | | | | ------------------ | | | | 43| 401| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1001| 401| REQUIRE(isc_buffer_consumedlength(source->pushback) != 0 || ------------------ | | 198| 401|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 478| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 324, False: 77] | | | | | Branch (42:11): [True: 77, False: 0] | | | | ------------------ | | | | 43| 401| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1002| 401| tokenp->type == isc_tokentype_eof); 1003| | 1004| 401| UNUSED(tokenp); ------------------ | | 69| 401|#define UNUSED(x) (void)(x) ------------------ 1005| | 1006| 401| isc_buffer_first(source->pushback); 1007| 401| lex->paren_count = lex->saved_paren_count; 1008| 401| source->line = source->saved_line; 1009| | source->at_eof = false; 1010| 401|} lex.c:new_source: 183| 886| const char *name) { 184| 886| inputsource *source; 185| | 186| 886| source = isc_mem_get(lex->mctx, sizeof(*source)); ------------------ | | 128| 886|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 187| 886| *source = (inputsource){ 188| 886| .is_file = is_file, 189| 886| .need_close = need_close, 190| 886| .last_was_eol = lex->last_was_eol, 191| 886| .input = input, 192| 886| .name = isc_mem_strdup(lex->mctx, name), ------------------ | | 144| 886|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 193| 886| .line = 1, 194| 886| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 886|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 886| { \ | | | | 27| 886| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 886|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 886| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 886|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 886| } | | ------------------ ------------------ 195| 886| }; 196| 886| isc_buffer_allocate(lex->mctx, &source->pushback, 197| 886| (unsigned int)lex->max_token); 198| | ISC_LIST_PREPEND(lex->sources, source, link); ------------------ | | 79| 886| do { \ | | 80| 886| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 886| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 886| do { \ | | | | 68| 886| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 885, False: 1] | | | | ------------------ | | | | 69| 885| (list).head->link.prev = (elt); \ | | | | 70| 885| } else { \ | | | | 71| 1| (list).tail = (elt); \ | | | | 72| 1| } \ | | | | 73| 886| (elt)->link.prev = NULL; \ | | | | 74| 886| (elt)->link.next = (list).head; \ | | | | 75| 886| (list).head = (elt); \ | | | | 76| 886| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 886] | | | | ------------------ | | ------------------ | | 82| 886| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 886] | | ------------------ ------------------ 199| 886|} lex.c:pushandgrow: 309| 22.5M|pushandgrow(isc_lex_t *lex, inputsource *source, int c) { 310| 22.5M| if (isc_buffer_availablelength(source->pushback) == 0) { ------------------ | | 161| 22.5M|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (310:6): [True: 17, False: 22.5M] ------------------ 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| 22.5M| isc_buffer_putuint8(source->pushback, (uint8_t)c); 326| 22.5M| return ISC_R_SUCCESS; 327| 22.5M|} lex.c:pushback: 296| 13.0k|pushback(inputsource *source, int c) { 297| 13.0k| REQUIRE(source->pushback->current > 0); ------------------ | | 198| 13.0k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 13.0k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 13.0k, False: 0] | | | | ------------------ | | | | 43| 13.0k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 298| 13.0k| if (c == EOF) { ------------------ | Branch (298:6): [True: 537, False: 12.5k] ------------------ 299| 537| source->at_eof = false; 300| 537| return; 301| 537| } 302| 12.5k| source->pushback->current--; 303| 12.5k| if (c == '\n') { ------------------ | Branch (303:6): [True: 1.93k, False: 10.5k] ------------------ 304| 1.93k| source->line--; 305| 1.93k| } 306| 12.5k|} 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); ------------------ | | 128| 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: 0, False: 10] ------------------ 75| 0| *prevp = tmp + (*prevp - lex->data); 76| 0| } 77| | isc_mem_put(lex->mctx, lex->data, lex->max_token + 1); ------------------ | | 148| 10| do { \ | | 149| 10| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 150| 10| (p) = NULL; \ | | 151| 10| } while (0) | | ------------------ | | | Branch (151: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)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 335| | 336| 2| *lcfg = (isc_logconfig_t){ 337| 2| .magic = LCFG_MAGIC, ------------------ | | 43| 2|#define LCFG_MAGIC ISC_MAGIC('L', 'c', 'f', 'g') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 338| 2| .lctx = isc__lctx, 339| 2| .channels = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 340| 2| .highest_level = level, 341| 2| }; 342| | 343| | /* 344| | * Create the default channels: 345| | * default_syslog, default_stderr, default_debug and null. 346| | */ 347| 2| isc_log_createchannel(lcfg, "default_syslog", ISC_LOG_TOSYSLOG, level, ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ 348| 2| ISC_LOGDESTINATION_SYSLOG(LOG_DAEMON), 0); ------------------ | | 287| 2| (&(isc_logdestination_t){ .facility = (f) }) ------------------ 349| | 350| 2| isc_log_createchannel(lcfg, "default_stderr", ISC_LOG_TOFILEDESC, level, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 351| 2| ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 352| | 353| | /* 354| | * Set the default category's channel to default_stderr, 355| | * which is at the head of the channels list because it was 356| | * just created. 357| | */ 358| 2| default_channel.channel = ISC_LIST_HEAD(lcfg->channels); ------------------ | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 359| | 360| 2| isc_log_createchannel(lcfg, "default_debug", ISC_LOG_TOFILEDESC, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 361| 2| ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ 362| 2| ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 363| | 364| 2| isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ 365| 2| NULL, 0); 366| | 367| 2| *lcfgp = lcfg; 368| 2|} isc_log_createchannel: 473| 8| unsigned int flags) { 474| 8| isc_logchannel_t *channel; 475| 8| isc_mem_t *mctx; 476| 8| unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 69| 8|#define ISC_LOG_PRINTALL 0x0003F ------------------ unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 71| 8|#define ISC_LOG_DEBUGONLY 0x01000 ------------------ 477| 8| ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 70| 8|#define ISC_LOG_BUFFERED 0x00040 ------------------ ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 73| 8|#define ISC_LOG_ISO8601 0x10000 /* if PRINTTIME, use ISO8601 */ ------------------ 478| 8| ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 74| 8|#define ISC_LOG_UTC 0x20000 /* if PRINTTIME, use UTC */ ------------------ ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 75| 8|#define ISC_LOG_TZINFO 0x40000 /* if PRINTTIME, output TZ info */ ------------------ 479| | 480| 8| REQUIRE(VALID_CONFIG(lcfg)); ------------------ | | 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)); ------------------ | | 128| 8|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 494| | 495| 8| channel->name = isc_mem_strdup(mctx, name); ------------------ | | 144| 8|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 496| | 497| 8| channel->type = type; 498| 8| channel->level = level; 499| 8| channel->flags = flags; 500| 8| ISC_LINK_INIT(channel, link); ------------------ | | 57| 8|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 8| do { \ | | | | 54| 8| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 8| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 8| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 501| | 502| 8| switch (type) { 503| 2| case ISC_LOG_TOSYSLOG: ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ | Branch (503:2): [True: 2, False: 6] ------------------ 504| 2| FACILITY(channel) = destination->facility; ------------------ | | 314| 2|#define FACILITY(channel) (channel->destination.facility) ------------------ 505| 2| break; 506| | 507| 0| case ISC_LOG_TOFILE: ------------------ | | 55| 0|#define ISC_LOG_TOFILE 3 ------------------ | Branch (507:2): [True: 0, False: 8] ------------------ 508| | /* 509| | * The file name is copied because greatest_version wants 510| | * to scribble on it, so it needs to be definitely in 511| | * writable memory. 512| | */ 513| 0| FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 315| 0|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 514| 0| destination->file.name); 515| 0| FILE_STREAM(channel) = NULL; ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 516| 0| FILE_VERSIONS(channel) = destination->file.versions; ------------------ | | 317| 0|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ 517| 0| FILE_SUFFIX(channel) = destination->file.suffix; ------------------ | | 318| 0|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 518| 0| FILE_MAXSIZE(channel) = destination->file.maximum_size; ------------------ | | 319| 0|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 519| 0| FILE_MAXREACHED(channel) = false; ------------------ | | 320| 0|#define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached) ------------------ 520| 0| break; 521| | 522| 4| case ISC_LOG_TOFILEDESC: ------------------ | | 56| 4|#define ISC_LOG_TOFILEDESC 4 ------------------ | Branch (522:2): [True: 4, False: 4] ------------------ 523| 4| FILE_NAME(channel) = NULL; ------------------ | | 315| 4|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ 524| 4| FILE_STREAM(channel) = destination->file.stream; ------------------ | | 316| 4|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 525| 4| FILE_MAXSIZE(channel) = 0; ------------------ | | 319| 4|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 526| 4| FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 317| 4|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 87| 4|#define ISC_LOG_ROLLNEVER (-2) ------------------ 527| 4| FILE_SUFFIX(channel) = isc_log_rollsuffix_increment; ------------------ | | 318| 4|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 528| 4| break; 529| | 530| 2| case ISC_LOG_TONULL: ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ | Branch (530:2): [True: 2, False: 6] ------------------ 531| | /* Nothing. */ 532| 2| break; 533| | 534| 0| default: ------------------ | Branch (534:2): [True: 0, False: 8] ------------------ 535| 0| UNREACHABLE(); ------------------ | | 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); ------------------ | | 198| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 1538| 2| isc_mem_setdebugging(mctx, 0); 1539| | 1540| 2| isc__lctx = isc_mem_get(mctx, sizeof(*isc__lctx)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1541| 2| *isc__lctx = (isc_log_t){ 1542| 2| .magic = LCTX_MAGIC, ------------------ | | 40| 2|#define LCTX_MAGIC ISC_MAGIC('L', 'c', 't', 'x') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1543| 2| .mctx = mctx, /* implicit attach */ 1544| 2| }; 1545| | 1546| 2| isc_mutex_init(&isc__lctx->lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 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: 505| 2|isc__mem_initialize(void) { 506| |/* 507| | * Check if the values copied from jemalloc still match 508| | */ 509| |#ifdef JEMALLOC_API_SUPPORTED 510| | RUNTIME_CHECK(ISC__MEM_ZERO == MALLOCX_ZERO); 511| | 512| | /* 513| | * ignore errors — volumetric-based purge in mem_put handles the rest 514| | * regardless 515| | */ 516| | 517| | (void)mallctl("background_thread", NULL, NULL, &(bool){ true }, 518| | sizeof(bool)); 519| | 520| | (void)mallctl("arenas.dirty_decay_ms", NULL, NULL, 521| | &default_dirty_decay_ms, sizeof(default_dirty_decay_ms)); 522| | 523| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".dirty_decay_ms", 524| | NULL, NULL, &default_dirty_decay_ms, 525| | sizeof(default_dirty_decay_ms)); 526| | 527| |#endif /* JEMALLOC_API_SUPPORTED */ 528| | 529| 2| isc_mutex_init(&contextslock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 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| } | | ------------------ ------------------ 530| 2| ISC_LIST_INIT(contexts); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 531| | 532| 2| if (debugging_enabled("ISC_MEM_DEBUGTRACE")) { ------------------ | Branch (532:6): [True: 0, False: 2] ------------------ 533| 0| mem_debugging |= ISC_MEM_DEBUGTRACE; ------------------ | | 39| 0|#define ISC_MEM_DEBUGTRACE 0x00000001U ------------------ 534| 0| } 535| | 536| 2| if (debugging_enabled("ISC_MEM_DEBUGRECORD")) { ------------------ | Branch (536:6): [True: 0, False: 2] ------------------ 537| 0| mem_debugging |= ISC_MEM_DEBUGRECORD; ------------------ | | 40| 0|#define ISC_MEM_DEBUGRECORD 0x00000002U ------------------ 538| 0| } 539| | 540| 2| if (debugging_enabled("ISC_MEM_DEBUGUSAGE")) { ------------------ | Branch (540:6): [True: 0, False: 2] ------------------ 541| 0| mem_debugging |= ISC_MEM_DEBUGUSAGE; ------------------ | | 41| 0|#define ISC_MEM_DEBUGUSAGE 0x00000004U ------------------ 542| 0| } 543| | 544| 2| isc_mem_create("default", &isc_g_mctx); ------------------ | | 198| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 545| 2|} isc_mem_setdebugging: 567| 4|isc_mem_setdebugging(isc_mem_t *ctx, unsigned int debugging) { 568| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 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))) | | ------------------ ------------------ 569| 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))) | | ------------------ ------------------ 570| | 571| 4| ctx->debugging = debugging; 572| 4|} isc__mem_get: 747| 1.81k|isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) { 748| 1.81k| void *ptr = NULL; 749| | 750| 1.81k| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 1.81k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 3.63k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 1.81k, False: 0] | | | | | Branch (42:11): [True: 1.81k, False: 0] | | | | ------------------ | | | | 43| 1.81k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 751| | 752| 1.81k| ptr = mem_get(ctx, size, flags); 753| | 754| 1.81k| mem_getstats(ctx, size); 755| 1.81k| ADD_TRACE(ctx, ptr, size, func, file, line); 756| | 757| 1.81k| return ptr; 758| 1.81k|} isc__mem_put: 761| 27|isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size, int flags FLARG) { 762| 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))) | | ------------------ ------------------ 763| | 764| 27| DELETE_TRACE(ctx, ptr, size, func, file, line); 765| | 766| 27| mem_putstats(ctx, size); 767| 27| mem_put(ctx, ptr, size, flags); 768| 27|} isc__mem_allocate: 839| 894|isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) { 840| 894| void *ptr = NULL; 841| | 842| 894| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 198| 894|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.78k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 894, False: 0] | | | | | Branch (42:11): [True: 894, False: 0] | | | | ------------------ | | | | 43| 894| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 843| | 844| 894| ptr = mem_get(ctx, size, flags); 845| | 846| | /* Recalculate the real allocated size */ 847| 894| size = sallocx(ptr, flags | ctx->jemalloc_flags); 848| | 849| 894| mem_getstats(ctx, size); 850| 894| ADD_TRACE(ctx, ptr, size, func, file, line); 851| | 852| 894| return ptr; 853| 894|} isc__mem_strdup: 947| 894|isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) { 948| 894| size_t len; 949| 894| char *ns = NULL; 950| | 951| 894| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 198| 894|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.78k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 894, False: 0] | | | | | Branch (42:11): [True: 894, False: 0] | | | | ------------------ | | | | 43| 894| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 952| 894| REQUIRE(s != NULL); ------------------ | | 198| 894|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 894| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 894, False: 0] | | | | ------------------ | | | | 43| 894| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 953| | 954| 894| len = strlen(s) + 1; 955| | 956| 894| ns = isc__mem_allocate(mctx, len, 0 FLARG_PASS); 957| | 958| 894| strlcpy(ns, s, len); 959| | 960| 894| return ns; 961| 894|} isc_mem_setdestroycheck: 964| 2|isc_mem_setdestroycheck(isc_mem_t *ctx, bool flag) { 965| 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))) | | ------------------ ------------------ 966| | 967| 2| MCTXLOCK(ctx); ------------------ | | 66| 2|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 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| } | | ------------------ ------------------ 968| | 969| 2| ctx->checkfree = flag; 970| | 971| 2| MCTXUNLOCK(ctx); ------------------ | | 67| 2|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 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| } | | ------------------ ------------------ 972| 2|} isc_mem_inuse: 975| 4|isc_mem_inuse(isc_mem_t *ctx) { 976| 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))) | | ------------------ ------------------ 977| | 978| 4| int_fast64_t inuse = 0; 979| | 980| 8| for (ssize_t i = -1; i < isc_tid_count(); i++) { ------------------ | Branch (980:23): [True: 4, False: 4] ------------------ 981| 4| inuse += atomic_load_relaxed(&ctx->stat[i].inuse); ------------------ | | 28| 4|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 982| 4| } 983| 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))) | | ------------------ ------------------ 984| | 985| 4| return (size_t)inuse; 986| 4|} isc__mem_create: 1536| 10|isc__mem_create(const char *name, isc_mem_t **mctxp FLARG) { 1537| 10| mem_create(name, mctxp, mem_debugging, 0); 1538| |#if ISC_MEM_TRACKLINES 1539| | if ((mem_debugging & ISC_MEM_DEBUGTRACE) != 0) { 1540| | fprintf(stderr, "create mctx %p func %s file %s line %u\n", 1541| | *mctxp, func, file, line); 1542| | } 1543| |#endif /* ISC_MEM_TRACKLINES */ 1544| 10|} mem.c:debugging_enabled: 488| 6|debugging_enabled(const char *name) { 489| 6| char env_buf[256]; 490| 6| size_t env_size = sizeof(env_buf); 491| | 492| 6| int r = uv_os_getenv(name, env_buf, &env_size); 493| 6| switch (r) { 494| 0| case 0: ------------------ | Branch (494:2): [True: 0, False: 6] ------------------ 495| 0| return true; 496| 6| case UV_ENOENT: ------------------ | Branch (496:2): [True: 6, False: 0] ------------------ 497| 6| return false; 498| 0| default: ------------------ | Branch (498:2): [True: 0, False: 6] ------------------ 499| 0| UV_RUNTIME_CHECK(uv_os_getenv, r); ------------------ | | 50| 0| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 0] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 220| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 500| 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()) | | ------------------ ------------------ 501| 6| } 502| 6|} mem.c:mem_get: 395| 2.70k|mem_get(isc_mem_t *ctx, size_t size, int flags) { 396| 2.70k| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 387| 2.70k| if (s == 0) { \ | | ------------------ | | | Branch (387:6): [True: 0, False: 2.70k] | | ------------------ | | 388| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 83| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 389| 0| } ------------------ 397| | 398| 2.70k| void *ptr = mallocx(size, flags | ctx->jemalloc_flags); 399| 2.70k| CHECK_OOM(ptr, size); ------------------ | | 241| 2.70k|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (241:37): [True: 2.70k, False: 0] | | | Branch (241:54): [True: 0, False: 0] | | ------------------ ------------------ 400| | 401| 2.70k| return ptr; 402| 2.70k|} mem.c:mem_getstats: 471| 2.70k|mem_getstats(isc_mem_t *ctx, size_t size) { 472| | atomic_fetch_add_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 30| 2.70k| atomic_fetch_add_explicit((o), (v), memory_order_relaxed) ------------------ 473| 2.70k|} mem.c:mem_putstats: 479| 27|mem_putstats(isc_mem_t *ctx, size_t size) { 480| | atomic_fetch_sub_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 32| 27| atomic_fetch_sub_explicit((o), (v), memory_order_relaxed) ------------------ 481| 27|} mem.c:mem_put: 442| 27|mem_put(isc_mem_t *ctx, void *mem, size_t size, int flags) { 443| 27| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 387| 27| if (s == 0) { \ | | ------------------ | | | Branch (387:6): [True: 0, False: 27] | | ------------------ | | 388| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 83| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 389| 0| } ------------------ 444| | 445| 27| sdallocx(mem, size, flags | ctx->jemalloc_flags); 446| | 447| 27| freed_bytes += size; 448| | 449| 27| if (freed_bytes >= purge_threshold) { ------------------ | Branch (449:6): [True: 0, False: 27] ------------------ 450| 0| freed_bytes = 0; 451| 0| mem_purge(); 452| 0| } 453| 27|} mem.c:mem_create: 602| 10| unsigned int jemalloc_flags) { 603| 10| isc_mem_t *ctx = NULL; 604| | 605| 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))) | | ------------------ ------------------ 606| 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))) | | ------------------ ------------------ 607| | 608| 10| ctx = mallocx(sizeof(*ctx), jemalloc_flags); 609| 10| CHECK_OOM(ctx, sizeof(*ctx)); ------------------ | | 241| 10|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (241:37): [True: 10, False: 0] | | | Branch (241:54): [True: 0, False: 0] | | ------------------ ------------------ 610| | 611| 10| *ctx = (isc_mem_t){ 612| 10| .magic = MEM_MAGIC, ------------------ | | 118| 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)) | | ------------------ ------------------ 613| 10| .debugging = debugging, 614| 10| .jemalloc_flags = jemalloc_flags, 615| 10| .checkfree = true, 616| 10| .name = strdup(name), 617| 10| }; 618| | 619| 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| } | | ------------------ ------------------ 620| 10| isc_refcount_init(&ctx->references, 1); ------------------ | | 44| 10|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 621| | 622| 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 (622:21): [True: 5.13k, False: 10] ------------------ 623| 5.13k| atomic_init(&ctx->stat_s[i].inuse, 0); 624| 5.13k| } 625| | 626| | /* Reserve the [-1] index for ISC_TID_UNKNOWN */ 627| 10| ctx->stat = &ctx->stat_s[1]; 628| | 629| 10| atomic_init(&ctx->hi_water, 0); 630| 10| atomic_init(&ctx->lo_water, 0); 631| | 632| 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] | | ------------------ ------------------ 633| | 634| |#if ISC_MEM_TRACKLINES 635| | if ((ctx->debugging & ISC_MEM_DEBUGRECORD) != 0) { 636| | unsigned int i; 637| | size_t debuglist_size = ISC_CHECKED_MUL(DEBUG_TABLE_COUNT, 638| | sizeof(debuglist_t)); 639| | 640| | ctx->debuglist = mallocx(debuglist_size, jemalloc_flags); 641| | CHECK_OOM(ctx->debuglist, debuglist_size); 642| | 643| | for (i = 0; i < DEBUG_TABLE_COUNT; i++) { 644| | ISC_LIST_INIT(ctx->debuglist[i]); 645| | } 646| | } 647| |#endif /* if ISC_MEM_TRACKLINES */ 648| | 649| 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| } ------------------ 650| 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] | | | | ------------------ | | ------------------ ------------------ 651| 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| } ------------------ 652| | 653| 10| *ctxp = ctx; 654| 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_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: 23, False: 1.21k] | Branch (44:25): [True: 22, False: 1] | Branch (44:45): [True: 102, False: 1.11k] ------------------ 45| 124| return ISC_R_RANGE; 46| 124| } 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); ------------------ | | 198| 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|}