LLVMFuzzerInitialize: 30| 2|LLVMFuzzerInitialize(int *argc ISC_ATTR_UNUSED, char ***argv ISC_ATTR_UNUSED) { 31| 2| isc_mem_create("fuzz", &mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 32| 2| isc_lex_create(mctx, 1024, &lex); 33| | 34| 2| return 0; 35| 2|} LLVMFuzzerTestOneInput: 38| 255|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 39| 255| isc_buffer_t buf; 40| 255| isc_result_t result; 41| | 42| 255| isc_buffer_constinit(&buf, data, size); ------------------ | | 557| 255| do { \ | | 558| 255| union { \ | | 559| 255| void *_var; \ | | 560| 255| const void *_const; \ | | 561| 255| } _deconst; \ | | 562| 255| _deconst._const = (_d); \ | | 563| 255| isc_buffer_init((_b), _deconst._var, (_l)); \ | | 564| 255| } while (0) | | ------------------ | | | Branch (564:11): [Folded, False: 255] | | ------------------ ------------------ 43| 255| isc_buffer_add(&buf, size); 44| 255| isc_buffer_setactive(&buf, size); 45| | 46| 255| CHECK(isc_lex_openbuffer(lex, &buf)); ------------------ | | 251| 255| { \ | | 252| 255| result = (r); \ | | 253| 255| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 255] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 255| } ------------------ 47| | 48| 4.80k| do { 49| 4.80k| isc_token_t token; 50| 4.80k| result = isc_lex_gettoken(lex, 0, &token); 51| 4.80k| } while (result == ISC_R_SUCCESS); ------------------ | Branch (51:11): [True: 4.55k, False: 255] ------------------ 52| | 53| 255|cleanup: 54| 255| return 0; 55| 255|} dns__acl_initialize: 502| 2|dns__acl_initialize(void) { 503| 2| isc_mutex_init(&insecure_prefix_lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 504| 2|} dns__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); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 200| | 201| 2| dst__hmacmd5_init(&dst_t_func[DST_ALG_HMACMD5]); 202| 2| dst__hmacsha1_init(&dst_t_func[DST_ALG_HMACSHA1]); 203| 2| dst__hmacsha224_init(&dst_t_func[DST_ALG_HMACSHA224]); 204| 2| dst__hmacsha256_init(&dst_t_func[DST_ALG_HMACSHA256]); 205| 2| dst__hmacsha384_init(&dst_t_func[DST_ALG_HMACSHA384]); 206| 2| dst__hmacsha512_init(&dst_t_func[DST_ALG_HMACSHA512]); 207| | 208| | /* RSASHA1 (NSEC3RSASHA1) is verify only in FIPS mode. */ 209| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA1], DST_ALG_RSASHA1); 210| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_NSEC3RSASHA1], 211| 2| DST_ALG_NSEC3RSASHA1); 212| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA256], DST_ALG_RSASHA256); 213| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA512], DST_ALG_RSASHA512); 214| 2| dst__opensslecdsa_init(&dst_t_func[DST_ALG_ECDSA256]); 215| 2| dst__opensslecdsa_init(&dst_t_func[DST_ALG_ECDSA384]); 216| 2| dst__openssleddsa_init(&dst_t_func[DST_ALG_ED25519], DST_ALG_ED25519); 217| 2|#ifdef HAVE_OPENSSL_ED448 218| 2| dst__openssleddsa_init(&dst_t_func[DST_ALG_ED448], DST_ALG_ED448); 219| 2|#endif /* ifdef HAVE_OPENSSL_ED448 */ 220| | 221| |#if HAVE_GSSAPI 222| | dst__gssapi_init(&dst_t_func[DST_ALG_GSSAPI]); 223| |#endif /* HAVE_GSSAPI */ 224| | /* 225| | * RSASHA256 using assigned OID 1.2.840.113549.1.1.11 as 226| | * a private OID example. 227| | */ 228| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA256PRIVATEOID], 229| 2| DST_ALG_RSASHA256PRIVATEOID); 230| | /* 231| | * RSASHA512 using assigned OID 1.2.840.113549.1.1.13 as 232| | * a private OID example. 233| | */ 234| 2| dst__opensslrsa_init(&dst_t_func[DST_ALG_RSASHA512PRIVATEOID], 235| 2| DST_ALG_RSASHA512PRIVATEOID); 236| 2|} dns__dyndb_initialize: 55| 2|dns__dyndb_initialize(void) { 56| 2| isc_mutex_init(&dyndb_lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 57| | ISC_LIST_INIT(dyndb_implementations); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 58| 2|} dns_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); \ | | ------------------ | | | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 2| __v; \ | | 73| 2| }) ------------------ | Branch (45:6): [True: 0, False: 2] ------------------ 46| 0| return; 47| 0| } 48| | 49| 2| dst__lib_initialize(); 50| 2| dns__acl_initialize(); 51| 2| dns__dlz_initialize(); 52| 2| dns__db_initialize(); 53| 2| dns__dyndb_initialize(); 54| 2| dns__qp_initialize(); 55| 2| dns__qpzone_initialize(); 56| 2| dns__zone_keymgmt_initialize(); 57| 2|} dst__opensslecdsa_init: 668| 4|dst__opensslecdsa_init(dst_func_t **funcp) { 669| 4| REQUIRE(funcp != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 670| | 671| 4| if (*funcp == NULL) { ------------------ | Branch (671:6): [True: 4, False: 0] ------------------ 672| 4| *funcp = &opensslecdsa_functions; 673| 4| } 674| 4|} dst__openssleddsa_init: 644| 4|dst__openssleddsa_init(dst_func_t **funcp, unsigned char algorithm) { 645| 4| REQUIRE(funcp != NULL); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 646| | 647| 4| if (*funcp == NULL) { ------------------ | Branch (647:6): [True: 4, False: 0] ------------------ 648| 4| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (648:7): [True: 4, False: 0] ------------------ 649| 4| *funcp = &openssleddsa_functions; 650| 4| } 651| 4| } 652| 4|} openssleddsa_link.c:check_algorithm: 584| 4|check_algorithm(unsigned char algorithm) { 585| 4| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 586| 4| EVP_PKEY *pkey = NULL; 587| 4| const eddsa_alginfo_t *alginfo = NULL; 588| 4| const unsigned char *key = NULL; 589| 4| const unsigned char *sig = NULL; 590| 4| const unsigned char test[] = "test"; 591| 4| isc_result_t result = ISC_R_SUCCESS; 592| 4| size_t key_len, sig_len; 593| | 594| 4| if (evp_md_ctx == NULL) { ------------------ | Branch (594:6): [True: 0, False: 4] ------------------ 595| 0| CLEANUP(ISC_R_NOMEMORY); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 596| 0| } 597| | 598| 4| switch (algorithm) { 599| 0|#if HAVE_OPENSSL_ED448 600| 2| case DST_ALG_ED448: ------------------ | Branch (600:2): [True: 2, False: 2] ------------------ 601| 2| sig = ed448_sig; 602| 2| sig_len = sizeof(ed448_sig) - 1; 603| 2| key = ed448_pub; 604| 2| key_len = sizeof(ed448_pub) - 1; 605| 2| alginfo = openssleddsa_alg_info(algorithm); 606| 2| break; 607| 0|#endif /* HAVE_OPENSSL_ED448 */ 608| 2| case DST_ALG_ED25519: ------------------ | Branch (608:2): [True: 2, False: 2] ------------------ 609| 2| sig = ed25519_sig; 610| 2| sig_len = sizeof(ed25519_sig) - 1; 611| 2| key = ed25519_pub; 612| 2| key_len = sizeof(ed25519_pub) - 1; 613| 2| alginfo = openssleddsa_alg_info(algorithm); 614| 2| break; 615| 0| default: ------------------ | Branch (615:2): [True: 0, False: 4] ------------------ 616| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 617| 4| } 618| | 619| 4| INSIST(alginfo != NULL); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 620| 4| CHECK(raw_key_to_ossl(alginfo, 0, key, &key_len, &pkey)); ------------------ | | 251| 4| { \ | | 252| 4| result = (r); \ | | 253| 4| if (result != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (253:7): [True: 0, False: 4] | | ------------------ | | 254| 0| goto cleanup; \ | | 255| 0| } \ | | 256| 4| } ------------------ 621| | 622| | /* 623| | * Check that we can verify the signature. 624| | */ 625| 4| if (EVP_DigestVerifyInit(evp_md_ctx, NULL, NULL, NULL, pkey) != 1 || ------------------ | Branch (625:6): [True: 0, False: 4] ------------------ 626| 4| EVP_DigestVerify(evp_md_ctx, sig, sig_len, test, ------------------ | Branch (626:6): [True: 0, False: 4] ------------------ 627| 4| sizeof(test) - 1) != 1) 628| 0| { 629| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 630| 0| } 631| | 632| 4|cleanup: 633| 4| if (pkey != NULL) { ------------------ | Branch (633:6): [True: 4, False: 0] ------------------ 634| 4| EVP_PKEY_free(pkey); 635| 4| } 636| 4| if (evp_md_ctx != NULL) { ------------------ | Branch (636:6): [True: 4, False: 0] ------------------ 637| | EVP_MD_CTX_destroy(evp_md_ctx); 638| 4| } 639| 4| ERR_clear_error(); 640| 4| return result; 641| 4|} openssleddsa_link.c:openssleddsa_alg_info: 54| 4|openssleddsa_alg_info(unsigned int key_alg) { 55| 4| if (key_alg == DST_ALG_ED25519) { ------------------ | Branch (55:6): [True: 2, False: 2] ------------------ 56| 2| static const eddsa_alginfo_t ed25519_alginfo = { 57| 2| .pkey_type = EVP_PKEY_ED25519, 58| 2| .nid = NID_ED25519, 59| 2| .key_size = DNS_KEY_ED25519SIZE, ------------------ | | 74| 2|#define DNS_KEY_ED25519SIZE 32 ------------------ 60| 2| .sig_size = DNS_SIG_ED25519SIZE, ------------------ | | 75| 2|#define DNS_SIG_ED25519SIZE 64 ------------------ 61| 2| }; 62| 2| return &ed25519_alginfo; 63| 2| } 64| 2|#if HAVE_OPENSSL_ED448 65| 2| if (key_alg == DST_ALG_ED448) { ------------------ | Branch (65:6): [True: 2, False: 0] ------------------ 66| 2| static const eddsa_alginfo_t ed448_alginfo = { 67| 2| .pkey_type = EVP_PKEY_ED448, 68| 2| .nid = NID_ED448, 69| 2| .key_size = DNS_KEY_ED448SIZE, ------------------ | | 77| 2|#define DNS_KEY_ED448SIZE 57 ------------------ 70| 2| .sig_size = DNS_SIG_ED448SIZE, ------------------ | | 78| 2|#define DNS_SIG_ED448SIZE 114 ------------------ 71| 2| }; 72| 2| return &ed448_alginfo; 73| 2| } 74| 0|#endif /* HAVE_OPENSSL_ED448 */ 75| 0| return NULL; 76| 2|} openssleddsa_link.c:raw_key_to_ossl: 80| 4| const unsigned char *key, size_t *key_len, EVP_PKEY **pkey) { 81| 4| isc_result_t result; 82| 4| int pkey_type = alginfo->pkey_type; 83| 4| size_t len = alginfo->key_size; 84| | 85| 4| result = (private ? DST_R_INVALIDPRIVATEKEY : DST_R_INVALIDPUBLICKEY); ------------------ | Branch (85:12): [True: 0, False: 4] ------------------ 86| 4| if (*key_len < len) { ------------------ | Branch (86:6): [True: 0, False: 4] ------------------ 87| 0| return result; 88| 0| } 89| | 90| 4| if (private) { ------------------ | Branch (90:6): [True: 0, False: 4] ------------------ 91| 0| *pkey = EVP_PKEY_new_raw_private_key(pkey_type, NULL, key, len); 92| 4| } else { 93| 4| *pkey = EVP_PKEY_new_raw_public_key(pkey_type, NULL, key, len); 94| 4| } 95| 4| if (*pkey == NULL) { ------------------ | Branch (95:6): [True: 0, False: 4] ------------------ 96| 0| return dst__openssl_toresult(result); ------------------ | | 28| 0| isc__ossl_wrap_logged_toresult(ISC_LOGCATEGORY_INVALID, \ | | 29| 0| ISC_LOGMODULE_INVALID, NULL, fallback, \ | | 30| 0| __FILE__, __LINE__) ------------------ 97| 0| } 98| | 99| 4| *key_len = len; 100| 4| return ISC_R_SUCCESS; 101| 4|} dst__opensslrsa_init: 921| 12|dst__opensslrsa_init(dst_func_t **funcp, unsigned short algorithm) { 922| 12| REQUIRE(funcp != NULL); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 923| | 924| 12| if (*funcp == NULL) { ------------------ | Branch (924:6): [True: 12, False: 0] ------------------ 925| 12| if (check_algorithm(algorithm) == ISC_R_SUCCESS) { ------------------ | Branch (925:7): [True: 12, False: 0] ------------------ 926| 12| *funcp = &opensslrsa_functions; 927| 12| } 928| 12| } 929| 12|} opensslrsa_link.c:check_algorithm: 861| 12|check_algorithm(unsigned short algorithm) { 862| 12| isc_ossl_wrap_rsa_components_t c = { .needs_cleanup = true }; 863| 12| EVP_MD_CTX *evp_md_ctx = EVP_MD_CTX_create(); 864| 12| EVP_PKEY *pkey = NULL; 865| 12| const EVP_MD *type = NULL; 866| 12| const unsigned char *sig = NULL; 867| 12| isc_result_t result = ISC_R_SUCCESS; 868| 12| size_t len; 869| | 870| 12| switch (algorithm) { 871| 2| case DST_ALG_RSASHA1: ------------------ | Branch (871:2): [True: 2, False: 10] ------------------ 872| 4| case DST_ALG_NSEC3RSASHA1: ------------------ | Branch (872:2): [True: 2, False: 10] ------------------ 873| 4| type = isc__crypto_md[ISC_MD_SHA1]; /* SHA1 + RSA */ 874| 4| sig = sha1_sig; 875| 4| len = sizeof(sha1_sig) - 1; 876| 4| break; 877| 2| case DST_ALG_RSASHA256: ------------------ | Branch (877:2): [True: 2, False: 10] ------------------ 878| 4| case DST_ALG_RSASHA256PRIVATEOID: ------------------ | Branch (878:2): [True: 2, False: 10] ------------------ 879| 4| type = isc__crypto_md[ISC_MD_SHA256]; /* SHA256 + RSA */ 880| 4| sig = sha256_sig; 881| 4| len = sizeof(sha256_sig) - 1; 882| 4| break; 883| 2| case DST_ALG_RSASHA512: ------------------ | Branch (883:2): [True: 2, False: 10] ------------------ 884| 4| case DST_ALG_RSASHA512PRIVATEOID: ------------------ | Branch (884:2): [True: 2, False: 10] ------------------ 885| 4| type = isc__crypto_md[ISC_MD_SHA512]; 886| 4| sig = sha512_sig; 887| 4| len = sizeof(sha512_sig) - 1; 888| 4| break; 889| 0| default: ------------------ | Branch (889:2): [True: 0, False: 12] ------------------ 890| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 891| 12| } 892| | 893| | /* 894| | * Construct pkey. 895| | */ 896| 12| c.e = BN_bin2bn(e_bytes, sizeof(e_bytes) - 1, NULL); 897| 12| c.n = BN_bin2bn(n_bytes, sizeof(n_bytes) - 1, NULL); 898| | 899| 12| result = isc_ossl_wrap_load_rsa_public_from_components(&c, &pkey); 900| 12| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 12|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 12, False: 0] | | | | ------------------ | | | | 55| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 901| | 902| | /* 903| | * Check that we can verify the signature. 904| | */ 905| 12| if (EVP_DigestInit_ex(evp_md_ctx, type, NULL) != 1 || ------------------ | Branch (905:6): [True: 0, False: 12] ------------------ 906| 12| EVP_DigestUpdate(evp_md_ctx, "test", 4) != 1 || ------------------ | Branch (906:6): [True: 0, False: 12] ------------------ 907| 12| EVP_VerifyFinal(evp_md_ctx, sig, len, pkey) != 1) ------------------ | Branch (907:6): [True: 0, False: 12] ------------------ 908| 0| { 909| 0| CLEANUP(ISC_R_NOTIMPLEMENTED); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 910| 0| } 911| | 912| 12|cleanup: 913| 12| isc_ossl_wrap_rsa_components_cleanup(&c); 914| 12| EVP_PKEY_free(pkey); 915| | EVP_MD_CTX_destroy(evp_md_ctx); 916| 12| ERR_clear_error(); 917| 12| return result; 918| 12|} dns__qp_initialize: 180| 2|dns__qp_initialize(void) { 181| | /* zero common character marker not a valid shift position */ 182| 2| INSIST(0 < SHIFT_BITMAP); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, Folded] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 183| | /* first bit is common byte or escape byte */ 184| 2| dns_qpshift_t bit_one = SHIFT_BITMAP; 185| | /* second bit is position in escaped range */ 186| 2| dns_qpshift_t bit_two = SHIFT_BITMAP; 187| 2| bool escaping = true; 188| | 189| 514| for (unsigned int byte = 0; byte < BYTE_VALUES; byte++) { ------------------ | | 132| 514|#define BYTE_VALUES (UINT8_MAX + 1) ------------------ | Branch (189:30): [True: 512, False: 2] ------------------ 190| 512| if (qp_common_character(byte)) { ------------------ | Branch (190:7): [True: 82, False: 430] ------------------ 191| 82| escaping = false; 192| 82| bit_one++; 193| 82| dns_qp_byte_for_bit[bit_one] = byte; 194| 82| dns_qp_bits_for_byte[byte] = bit_one; 195| 430| } else if ('A' <= byte && byte <= 'Z') { ------------------ | Branch (195:14): [True: 326, False: 104] | Branch (195:29): [True: 52, False: 274] ------------------ 196| | /* map upper case to lower case */ 197| 52| dns_qpshift_t after_esc = bit_one + 1; 198| 52| dns_qpshift_t skip_punct = 'a' - '_'; 199| 52| dns_qpshift_t letter = byte - 'A'; 200| 52| dns_qpshift_t bit = after_esc + skip_punct + letter; 201| 52| dns_qp_bits_for_byte[byte] = bit; 202| | /* to simplify reverse conversion */ 203| 52| bit_two++; 204| 378| } else { 205| | /* non-hostname characters need to be escaped */ 206| 378| if (!escaping || bit_two >= SHIFT_OFFSET) { ------------------ | Branch (206:8): [True: 4, False: 374] | Branch (206:21): [True: 4, False: 370] ------------------ 207| 8| escaping = true; 208| 8| bit_one++; 209| 8| dns_qp_byte_for_bit[bit_one] = byte; 210| 8| bit_two = SHIFT_BITMAP; 211| 8| } 212| 378| dns_qp_bits_for_byte[byte] = bit_two << 8 | bit_one; 213| 378| bit_two++; 214| 378| } 215| 512| } 216| 2| ENSURE(bit_one < SHIFT_OFFSET); ------------------ | | 196| 2|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 2, False: 0] | | | | ------------------ | | | | 49| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 217| 2|} 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) { ------------------ | | 94| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (472:23): [True: 2.04k, False: 2] ------------------ 473| 2.04k| NODE_INITLOCK(&qpzone_buckets_g[idx].lock); ------------------ | | 28| 2.04k|#define NODE_INITLOCK(l) isc_rwlock_init((l)) ------------------ 474| 2.04k| } 475| 2|} dns__zone_keymgmt_initialize: 16017| 2|dns__zone_keymgmt_initialize(void) { 16018| 2.05k| for (size_t idx = 0; idx < ARRAY_SIZE(keymgmt_buckets_g); ++idx) { ------------------ | | 94| 2.05k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (16018:23): [True: 2.04k, False: 2] ------------------ 16019| 2.04k| isc_mutex_init(&keymgmt_buckets_g[idx].lock); ------------------ | | 68| 2.04k|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2.04k| { \ | | | | 80| 2.04k| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2.04k| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2.04k| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2.04k] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2.04k| } | | ------------------ ------------------ 16020| 2.04k| } 16021| 2|} isc_hmac: 140| 12| unsigned int *digestlen) { 141| 12| EVP_MAC_CTX *ctx; 142| 12| size_t maclen; 143| | 144| 12| REQUIRE(type < ISC_MD_MAX); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 145| | 146| 12| if (isc__crypto_md[type] == NULL) { ------------------ | Branch (146:6): [True: 0, False: 12] ------------------ 147| 0| return ISC_R_NOTIMPLEMENTED; 148| 0| } 149| | 150| 12| ctx = EVP_MAC_CTX_new(evp_hmac); 151| 12| RUNTIME_CHECK(ctx != NULL); ------------------ | | 241| 12| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 12, False: 0] | | ------------------ ------------------ 152| | 153| 12| if (EVP_MAC_init(ctx, key, keylen, md_to_hmac_params[type]) != 1) { ------------------ | Branch (153:6): [True: 0, False: 12] ------------------ 154| 0| goto fail; 155| 0| } 156| | 157| 12| if (EVP_MAC_update(ctx, buf, len) != 1) { ------------------ | Branch (157:6): [True: 0, False: 12] ------------------ 158| 0| goto fail; 159| 0| } 160| | 161| 12| maclen = *digestlen; 162| 12| if (EVP_MAC_final(ctx, digest, &maclen, maclen) != 1) { ------------------ | Branch (162:6): [True: 0, False: 12] ------------------ 163| 0| goto fail; 164| 0| } 165| | 166| 12| *digestlen = maclen; 167| | 168| 12| EVP_MAC_CTX_free(ctx); 169| 12| return ISC_R_SUCCESS; 170| | 171| 0|fail: 172| 0| ERR_clear_error(); 173| 0| EVP_MAC_CTX_free(ctx); 174| 0| return ISC_R_CRYPTOFAILURE; 175| 12|} isc_crypto_fips_mode: 322| 2|isc_crypto_fips_mode(void) { 323| | return EVP_default_properties_is_fips_enabled(NULL) != 0; 324| 2|} isc__crypto_initialize: 376| 2|isc__crypto_initialize(void) { 377| | /* 378| | * We call OPENSSL_cleanup() manually, in a correct order, thus disable 379| | * the automatic atexit() handler. 380| | */ 381| 2| uint64_t opts = OPENSSL_INIT_LOAD_CONFIG | OPENSSL_INIT_NO_ATEXIT; 382| | 383| 2| RUNTIME_CHECK(OPENSSL_init_ssl(opts, NULL) == 1); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 384| | 385| 2| register_algorithms(); 386| | 387| |#if defined(ENABLE_FIPS_MODE) 388| | if (isc_crypto_fips_enable() != ISC_R_SUCCESS) { 389| | ERR_clear_error(); 390| | FATAL_ERROR("Failed to toggle FIPS mode but is " 391| | "required for this build"); 392| | } 393| |#endif 394| | 395| | /* Protect ourselves against unseeded PRNG */ 396| 2| if (RAND_status() != 1) { ------------------ | Branch (396:6): [True: 0, False: 2] ------------------ 397| 0| isc_ossl_wrap_logged_toresult( ------------------ | | 26| 0| isc__ossl_wrap_logged_toresult(category, module, funcname, fallback, \ | | 27| 0| __FILE__, __LINE__) ------------------ 398| 0| ISC_LOGCATEGORY_GENERAL, ISC_LOGMODULE_CRYPTO, 399| 0| "RAND_status", ISC_R_CRYPTOFAILURE); 400| 0| FATAL_ERROR("OpenSSL pseudorandom number generator " ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 401| 0| "cannot be initialized (see the `PRNG not " 402| 0| "seeded' message in the OpenSSL FAQ)"); 403| 0| } 404| 2|} ossl3.c:register_algorithms: 89| 2|register_algorithms(void) { 90| 2| if (!isc_crypto_fips_mode()) { ------------------ | Branch (90:6): [True: 2, False: 0] ------------------ 91| 2| md_register_algorithm(MD5); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 92| 2| } 93| | 94| 2| md_register_algorithm(SHA1); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 95| 2| md_register_algorithm(SHA224); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 96| 2| md_register_algorithm(SHA256); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 97| 2| md_register_algorithm(SHA384); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 98| 2| md_register_algorithm(SHA512); ------------------ | | 80| 2| { \ | | 81| 2| REQUIRE(isc__crypto_md[ISC_MD_##alg] == NULL); \ | | ------------------ | | | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 2| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 2, False: 0] | | | | | | ------------------ | | | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 82| 2| isc__crypto_md[ISC_MD_##alg] = EVP_MD_fetch(NULL, #alg, NULL); \ | | 83| 2| if (isc__crypto_md[ISC_MD_##alg] == NULL) { \ | | ------------------ | | | Branch (83:7): [True: 0, False: 2] | | ------------------ | | 84| 0| ERR_clear_error(); \ | | 85| 0| } \ | | 86| 2| } ------------------ 99| | 100| | /* We _must_ have HMAC */ 101| 2| evp_hmac = EVP_MAC_fetch(NULL, "HMAC", NULL); 102| 2| if (evp_hmac == NULL) { ------------------ | Branch (102:6): [True: 0, False: 2] ------------------ 103| 0| ERR_clear_error(); 104| 0| FATAL_ERROR("OpenSSL failed to find an HMAC implementation. " ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 105| 0| "Please make sure the default provider has an " 106| 0| "EVP_MAC-HMAC implementation"); 107| 0| } 108| | 109| 2| return ISC_R_SUCCESS; 110| 2|} isc__hash_initialize: 30| 2|isc__hash_initialize(void) { 31| | /* 32| | * Set a constant key to help in problem reproduction should 33| | * fuzzing find a crash or a hang. 34| | */ 35| 2| uint8_t key[16] = { 1 }; 36| |#if !FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 37| | isc_random_buf(key, sizeof(key)); 38| |#endif /* if FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */ 39| 2| STATIC_ASSERT(sizeof(key) >= sizeof(isc_hash_key), ------------------ | | 150| 2|#define STATIC_ASSERT(cond, msg) _Static_assert(cond, msg) ------------------ 40| 2| "sizeof(key) < sizeof(isc_hash_key)"); 41| 2| memmove(isc_hash_key, key, sizeof(isc_hash_key)); 42| 2|} isc_lex_gettoken.c:isc_buffer_init: 524| 255| const unsigned int length) { 525| 255| REQUIRE(b != NULL); ------------------ | | 194| 255|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 255| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 255, False: 0] | | | | ------------------ | | | | 43| 255| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 255| *b = (isc_buffer_t){ 528| 255| .base = base, 529| 255| .length = length, 530| 255| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 255|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 255| { \ | | | | 27| 255| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 255|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 255| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 255|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 255| } | | ------------------ ------------------ 531| 255| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 255|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 255| }; 533| 255|} isc_lex_gettoken.c:isc_buffer_add: 652| 255|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 255| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 255|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 510| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 255, False: 0] | | | | | Branch (42:11): [True: 255, False: 0] | | | | ------------------ | | | | 43| 255| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 255| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 255|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 255| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 255, False: 0] | | | | ------------------ | | | | 43| 255| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 255| b->used += n; 657| 255|} isc_lex_gettoken.c:isc_buffer_setactive: 771| 255|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 255| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 255|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 510| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 255, False: 0] | | | | | Branch (42:11): [True: 255, False: 0] | | | | ------------------ | | | | 43| 255| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 255| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 255|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 255| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 255, False: 0] | | | | ------------------ | | | | 43| 255| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 255| b->active = b->current + n; 776| 255|} lex.c:isc_buffer_allocate: 1077| 270| const unsigned int length) { 1078| 270| REQUIRE(dbufp != NULL && *dbufp == NULL); ------------------ | | 194| 270|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 540| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 270, False: 0] | | | | | Branch (42:11): [True: 270, False: 0] | | | | ------------------ | | | | 43| 270| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1079| | 1080| 270| isc_buffer_t *dbuf = isc_mem_get(mctx, sizeof(*dbuf) + length); ------------------ | | 128| 270|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1081| 270| uint8_t *bdata = (uint8_t *)dbuf + sizeof(*dbuf); 1082| | 1083| 270| isc_buffer_init(dbuf, bdata, length); 1084| 270| dbuf->extra = length; 1085| 270| isc_buffer_setmctx(dbuf, mctx); 1086| | 1087| 270| *dbufp = dbuf; 1088| 270|} lex.c:isc_buffer_init: 524| 270| const unsigned int length) { 525| 270| REQUIRE(b != NULL); ------------------ | | 194| 270|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 270| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 270, False: 0] | | | | ------------------ | | | | 43| 270| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 270| *b = (isc_buffer_t){ 528| 270| .base = base, 529| 270| .length = length, 530| 270| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 270|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 270| { \ | | | | 27| 270| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 270|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 270| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 270|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 270| } | | ------------------ ------------------ 531| 270| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 270|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 270| }; 533| 270|} lex.c:isc_buffer_setmctx: 1091| 270|isc_buffer_setmctx(isc_buffer_t *restrict b, isc_mem_t *mctx) { 1092| 270| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 270|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 540| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 270, False: 0] | | | | | Branch (42:11): [True: 270, False: 0] | | | | ------------------ | | | | 43| 270| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1093| | 1094| 270| b->mctx = mctx; 1095| 270|} lex.c:isc_buffer_free: 1154| 15|isc_buffer_free(isc_buffer_t **restrict dbufp) { 1155| 15| REQUIRE(dbufp != NULL && ISC_BUFFER_VALID(*dbufp)); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 60| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 15, False: 0] | | | | | Branch (42:11): [True: 15, False: 0] | | | | | Branch (42:11): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1156| 15| REQUIRE((*dbufp)->mctx != NULL); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 15| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1157| | 1158| 15| isc_buffer_t *dbuf = *dbufp; 1159| 15| isc_mem_t *mctx = dbuf->mctx; 1160| 15| unsigned int extra = dbuf->extra; 1161| | 1162| 15| *dbufp = NULL; /* destroy external reference */ 1163| | 1164| 15| isc_buffer_clearmctx(dbuf); 1165| | 1166| 15| isc_buffer_invalidate(dbuf); 1167| | isc_mem_put(mctx, dbuf, sizeof(*dbuf) + extra); ------------------ | | 150| 15| do { \ | | 151| 15| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 15| (p) = NULL; \ | | 153| 15| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 15] | | ------------------ ------------------ 1168| 15|} lex.c:isc_buffer_clearmctx: 1098| 15|isc_buffer_clearmctx(isc_buffer_t *restrict b) { 1099| 15| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 30| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 15, False: 0] | | | | | Branch (42:11): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1100| | 1101| 15| if (b->dynamic) { ------------------ | Branch (1101:6): [True: 0, False: 15] ------------------ 1102| 0| isc_mem_put(b->mctx, b->base, b->length); ------------------ | | 150| 0| do { \ | | 151| 0| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 0| (p) = NULL; \ | | 153| 0| } while (0) | | ------------------ | | | Branch (153:11): [Folded, False: 0] | | ------------------ ------------------ 1103| 0| b->dynamic = false; 1104| 0| } 1105| | 1106| | b->mctx = NULL; 1107| 15|} lex.c:isc_buffer_invalidate: 577| 15|isc_buffer_invalidate(isc_buffer_t *restrict b) { 578| 15| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 30| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 15, False: 0] | | | | | Branch (42:11): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 579| 15| REQUIRE(!ISC_LINK_LINKED(b, link)); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 15| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 580| 15| REQUIRE(b->mctx == NULL); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 15| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 581| | 582| 15| *b = (isc_buffer_t){ 583| 15| .magic = 0, 584| 15| }; 585| 15|} lex.c:isc_buffer_compact: 1048| 4.80k|isc_buffer_compact(isc_buffer_t *restrict b) { 1049| 4.80k| unsigned int length; 1050| 4.80k| 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| 4.80k| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 4.80k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.61k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.80k, False: 0] | | | | | Branch (42:11): [True: 4.80k, False: 0] | | | | ------------------ | | | | 43| 4.80k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1059| | 1060| 4.80k| src = isc_buffer_current(b); ------------------ | | 145| 4.80k| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1061| 4.80k| length = isc_buffer_remaininglength(b); ------------------ | | 159| 4.80k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ 1062| 4.80k| if (length > 0U) { ------------------ | Branch (1062:6): [True: 4.40k, False: 401] ------------------ 1063| 4.40k| (void)memmove(b->base, src, (size_t)length); 1064| 4.40k| } 1065| | 1066| 4.80k| if (b->active > b->current) { ------------------ | Branch (1066:6): [True: 0, False: 4.80k] ------------------ 1067| 0| b->active -= b->current; 1068| 4.80k| } else { 1069| 4.80k| b->active = 0; 1070| 4.80k| } 1071| 4.80k| b->current = 0; 1072| 4.80k| b->used = length; 1073| 4.80k|} lex.c:isc_buffer_usedregion: 616| 15| isc_region_t *restrict r) { 617| 15| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 30| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 15, False: 0] | | | | | Branch (42:11): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 618| 15| REQUIRE(r != NULL); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 15| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 619| | 620| 15| r->base = b->base; 621| 15| r->length = b->used; 622| 15|} lex.c:isc_buffer_copyregion: 1192| 15| const isc_region_t *restrict r) { 1193| 15| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 30| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 15, False: 0] | | | | | Branch (42:11): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1194| 15| REQUIRE(r != NULL); ------------------ | | 194| 15|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 15| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 15, False: 0] | | | | ------------------ | | | | 43| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1195| | 1196| 15| if (b->mctx) { ------------------ | Branch (1196:6): [True: 15, False: 0] ------------------ 1197| 15| RETERR(isc_buffer_reserve(b, r->length)); ------------------ | | 272| 15| { \ | | 273| 15| isc_result_t _r = (x); \ | | 274| 15| if (_r != ISC_R_SUCCESS) { \ | | ------------------ | | | Branch (274:7): [True: 0, False: 15] | | ------------------ | | 275| 0| return ((_r)); \ | | 276| 0| } \ | | 277| 15| } ------------------ 1198| 15| } 1199| | 1200| 15| if (r->length > isc_buffer_availablelength(b)) { ------------------ | | 161| 15|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (1200:6): [True: 0, False: 15] ------------------ 1201| 0| return ISC_R_NOSPACE; 1202| 0| } 1203| | 1204| 15| if (r->length > 0U) { ------------------ | Branch (1204:6): [True: 15, False: 0] ------------------ 1205| 15| memmove(isc_buffer_used(b), r->base, r->length); ------------------ | | 149| 15| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1206| 15| b->used += r->length; 1207| 15| } 1208| | 1209| 15| return ISC_R_SUCCESS; 1210| 15|} lex.c:isc_buffer_reserve: 1110| 15.9M|isc_buffer_reserve(isc_buffer_t *restrict dbuf, const unsigned int size) { 1111| 15.9M| REQUIRE(ISC_BUFFER_VALID(dbuf)); ------------------ | | 194| 15.9M|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 31.8M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 15.9M, False: 0] | | | | | Branch (42:11): [True: 15.9M, False: 0] | | | | ------------------ | | | | 43| 15.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1112| | 1113| 15.9M| size_t len; 1114| | 1115| 15.9M| len = dbuf->length; 1116| 15.9M| if ((len - dbuf->used) >= size) { ------------------ | Branch (1116:6): [True: 15.9M, False: 0] ------------------ 1117| 15.9M| return ISC_R_SUCCESS; 1118| 15.9M| } 1119| | 1120| 0| if (dbuf->mctx == NULL) { ------------------ | Branch (1120:6): [True: 0, False: 0] ------------------ 1121| 0| return ISC_R_NOSPACE; 1122| 0| } 1123| | 1124| | /* Round to nearest buffer size increment */ 1125| 0| len = size + dbuf->used; 1126| 0| len = ISC_ALIGN(len, ISC_BUFFER_INCR); ------------------ | | 292| 0|#define ISC_ALIGN(x, a) (((x) + (a) - 1) & ~((typeof(x))(a) - 1)) ------------------ 1127| | 1128| | /* Cap at UINT_MAX */ 1129| 0| if (len > UINT_MAX) { ------------------ | Branch (1129:6): [True: 0, False: 0] ------------------ 1130| 0| len = UINT_MAX; 1131| 0| } 1132| | 1133| 0| if ((len - dbuf->used) < size) { ------------------ | Branch (1133:6): [True: 0, False: 0] ------------------ 1134| 0| return ISC_R_NOMEMORY; 1135| 0| } 1136| | 1137| 0| if (!dbuf->dynamic) { ------------------ | Branch (1137:6): [True: 0, False: 0] ------------------ 1138| 0| void *old_base = dbuf->base; 1139| 0| dbuf->base = isc_mem_get(dbuf->mctx, len); ------------------ | | 128| 0|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1140| 0| if (old_base != NULL) { ------------------ | Branch (1140:7): [True: 0, False: 0] ------------------ 1141| 0| memmove(dbuf->base, old_base, dbuf->used); 1142| 0| } 1143| 0| dbuf->dynamic = true; 1144| 0| } else { 1145| 0| dbuf->base = isc_mem_creget(dbuf->mctx, dbuf->base, ------------------ | | 135| 0| isc__mem_reget((c), (p), ISC_CHECKED_MUL((o), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 136| 0| ISC_CHECKED_MUL((n), (s)), \ | | ------------------ | | | | 32| 0| ({ \ | | | | 33| 0| typeof(a) _c; \ | | | | 34| 0| bool _overflow = ckd_mul(&_c, a, b); \ | | | | 35| 0| INSIST(!_overflow); \ | | | | ------------------ | | | | | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | | | | | ------------------ | | | | | | | | 54| 0| ((void)((cond) || \ | | | | | | | | ------------------ | | | | | | | | | Branch (54:10): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | | | ------------------ | | | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | | | 57| 0| 0))) | | | | | | ------------------ | | | | ------------------ | | | | 36| 0| _c; \ | | | | 37| 0| }) | | ------------------ | | 137| 0| ISC__MEM_ZERO _ISC_MEM_FILELINE) | | ------------------ | | | | 126| 0|#define ISC__MEM_ZERO ((int)0x40) | | ------------------ ------------------ 1146| 0| dbuf->length, len, sizeof(char)); 1147| 0| } 1148| 0| dbuf->length = (unsigned int)len; 1149| | 1150| 0| return ISC_R_SUCCESS; 1151| 0|} lex.c:isc_buffer_putuint8: 869| 15.9M|isc_buffer_putuint8(isc_buffer_t *restrict b, const uint8_t val) { 870| 15.9M| ISC_BUFFER_PUT_RESERVE(b, val, sizeof(val)); ------------------ | | 857| 15.9M| { \ | | 858| 15.9M| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 15.9M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 31.8M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 15.9M, False: 0] | | | | | | | Branch (42:11): [True: 15.9M, False: 0] | | | | | | ------------------ | | | | | | 43| 15.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 859| 15.9M| \ | | 860| 15.9M| if (b->mctx) { \ | | ------------------ | | | Branch (860:7): [True: 15.9M, False: 0] | | ------------------ | | 861| 15.9M| isc_result_t result = isc_buffer_reserve(b, s); \ | | 862| 15.9M| ENSURE(result == ISC_R_SUCCESS); \ | | ------------------ | | | | 196| 15.9M|#define ENSURE(e) ISC_ENSURE(e) | | | | ------------------ | | | | | | 48| 15.9M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (48:10): [True: 15.9M, False: 0] | | | | | | ------------------ | | | | | | 49| 15.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (49:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | | | 51| 0| 0))) | | | | ------------------ | | ------------------ | | 863| 15.9M| } \ | | 864| 15.9M| \ | | 865| 15.9M| REQUIRE(isc_buffer_availablelength(b) >= s); \ | | ------------------ | | | | 194| 15.9M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 15.9M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:10): [True: 15.9M, False: 0] | | | | | | ------------------ | | | | | | 43| 15.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 866| 15.9M| } ------------------ 871| | 872| 15.9M| uint8_t *cp = isc_buffer_used(b); ------------------ | | 149| 15.9M| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 873| 15.9M| b->used += sizeof(val); 874| 15.9M| cp[0] = val; 875| 15.9M|} lex.c:isc_buffer_getuint8: 848| 15.9M|isc_buffer_getuint8(isc_buffer_t *restrict b) { 849| 15.9M| uint8_t val = 0; 850| 15.9M| isc_result_t result = isc_buffer_peekuint8(b, &val); 851| 15.9M| ENSURE(result == ISC_R_SUCCESS); ------------------ | | 196| 15.9M|#define ENSURE(e) ISC_ENSURE(e) | | ------------------ | | | | 48| 15.9M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (48:10): [True: 15.9M, False: 0] | | | | ------------------ | | | | 49| 15.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (49:3): [True: 0, False: 0] | | | | ------------------ | | | | 50| 0| isc_assertiontype_ensure, #cond), \ | | | | 51| 0| 0))) | | ------------------ ------------------ 852| 15.9M| b->current += sizeof(val); 853| 15.9M| return val; 854| 15.9M|} lex.c:isc_buffer_peekuint8: 839| 15.9M|isc_buffer_peekuint8(const isc_buffer_t *restrict b, uint8_t *valp) { 840| 15.9M| ISC_BUFFER_PEEK_CHECK(b, sizeof(*valp)); ------------------ | | 831| 15.9M| { \ | | 832| 15.9M| REQUIRE(ISC_BUFFER_VALID(b)); \ | | ------------------ | | | | 194| 15.9M|#define REQUIRE(e) ISC_REQUIRE(e) | | | | ------------------ | | | | | | 42| 31.8M| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (42:11): [True: 15.9M, False: 0] | | | | | | | Branch (42:11): [True: 15.9M, False: 0] | | | | | | ------------------ | | | | | | 43| 15.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (43:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | | | 45| 0| 0))) | | | | ------------------ | | ------------------ | | 833| 15.9M| if ((b)->used - (b)->current < s) { \ | | ------------------ | | | Branch (833:7): [True: 0, False: 15.9M] | | ------------------ | | 834| 0| return (ISC_R_NOMORE); \ | | 835| 0| } \ | | 836| 15.9M| } ------------------ 841| | 842| 15.9M| uint8_t *cp = isc_buffer_current(b); ------------------ | | 145| 15.9M| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 843| | SET_IF_NOT_NULL(valp, (uint8_t)(cp[0])); ------------------ | | 100| 15.9M| if ((obj) != NULL) { \ | | ------------------ | | | Branch (100:6): [True: 15.9M, False: 0] | | ------------------ | | 101| 15.9M| *(obj) = (val); \ | | 102| 15.9M| } ------------------ 844| 15.9M| return ISC_R_SUCCESS; 845| 15.9M|} isc_lib_initialize: 57| 2|isc_lib_initialize(void) { 58| 2| isc__lib_initialize(); 59| 2|} mem.c:isc_tid: 39| 839|isc_tid(void) { 40| 839| return isc__tid_local; 41| 839|} isc__iterated_hash_initialize: 144| 2|isc__iterated_hash_initialize(void) { 145| 2| if (initialized) { ------------------ | Branch (145:6): [True: 0, False: 2] ------------------ 146| 0| return; 147| 0| } 148| | 149| 2| basectx = EVP_MD_CTX_new(); 150| 2| INSIST(basectx != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 151| 2| mdctx = EVP_MD_CTX_new(); 152| 2| INSIST(mdctx != NULL); ------------------ | | 198| 2|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 2, False: 0] | | | | ------------------ | | | | 55| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 153| | 154| 2| RUNTIME_CHECK(EVP_DigestInit_ex(basectx, isc__crypto_md[ISC_MD_SHA1], ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 155| 2| NULL) == 1); 156| | initialized = true; 157| 2|} mem.c:mallocx: 66| 824|mallocx(size_t size, int flags) { 67| 824| void *ptr = malloc(size); 68| 824| INSIST(ptr != NULL); ------------------ | | 198| 824|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 824| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 824, False: 0] | | | | ------------------ | | | | 55| 824| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 69| | 70| 824| if ((flags & MALLOCX_ZERO) != 0) { ------------------ | | 32| 824|#define MALLOCX_ZERO ((int)0x40) ------------------ | Branch (70:6): [True: 0, False: 824] ------------------ 71| 0| memset(ptr, 0, size); 72| 0| } 73| | 74| 824| return ptr; 75| 824|} mem.c:sdallocx: 78| 25|sdallocx(void *ptr, size_t size ISC_ATTR_UNUSED, int flags ISC_ATTR_UNUSED) { 79| 25| free(ptr); 80| 25|} mem.c:sallocx: 59| 263|sallocx(void *ptr, int flags ISC_ATTR_UNUSED) { 60| 263| return malloc_usable_size(ptr); 61| 263|} isc_lex_create: 84| 2|isc_lex_create(isc_mem_t *mctx, size_t max_token, isc_lex_t **lexp) { 85| 2| isc_lex_t *lex; 86| | 87| | /* 88| | * Create a lexer. 89| | */ 90| 2| REQUIRE(lexp != NULL && *lexp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 91| | 92| 2| if (max_token == 0U) { ------------------ | Branch (92:6): [True: 0, False: 2] ------------------ 93| 0| max_token = 1; 94| 0| } 95| | 96| 2| lex = isc_mem_get(mctx, sizeof(*lex)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 97| 2| lex->data = isc_mem_get(mctx, max_token + 1); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 98| 2| lex->mctx = mctx; 99| 2| lex->max_token = max_token; 100| 2| lex->comments = 0; 101| 2| lex->comment_ok = true; 102| 2| lex->last_was_eol = true; 103| 2| lex->brace_count = 0; 104| 2| lex->paren_count = 0; 105| 2| lex->saved_paren_count = 0; 106| 2| memset(lex->specials, 0, 256); 107| 2| ISC_LIST_INIT(lex->sources); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 108| 2| lex->magic = LEX_MAGIC; ------------------ | | 48| 2|#define LEX_MAGIC ISC_MAGIC('L', 'e', 'x', '!') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 109| | 110| 2| *lexp = lex; 111| 2|} isc_lex_openbuffer: 233| 255|isc_lex_openbuffer(isc_lex_t *lex, isc_buffer_t *buffer) { 234| 255| char name[128]; 235| | 236| | /* 237| | * Make 'buffer' the current input source for 'lex'. 238| | */ 239| | 240| 255| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 255|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 510| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 255, False: 0] | | | | | Branch (42:11): [True: 255, False: 0] | | | | ------------------ | | | | 43| 255| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 241| | 242| 255| snprintf(name, sizeof(name), "buffer-%p", buffer); 243| | 244| 255| new_source(lex, false, false, buffer, name); 245| 255| return ISC_R_SUCCESS; 246| 255|} isc_lex_gettoken: 330| 4.80k|isc_lex_gettoken(isc_lex_t *lex, unsigned int options, isc_token_t *tokenp) { 331| 4.80k| inputsource *source; 332| 4.80k| int c; 333| 4.80k| bool done = false; 334| 4.80k| bool no_comments = false; 335| 4.80k| bool escaped = false; 336| 4.80k| lexstate state = lexstate_start; 337| 4.80k| lexstate saved_state = lexstate_start; 338| 4.80k| isc_buffer_t *buffer; 339| 4.80k| FILE *stream; 340| 4.80k| char *curr, *prev; 341| 4.80k| size_t remaining; 342| 4.80k| uint32_t as_ulong; 343| 4.80k| unsigned int saved_options; 344| 4.80k| isc_result_t result; 345| | 346| | /* 347| | * Get the next token. 348| | */ 349| | 350| 4.80k| REQUIRE(VALID_LEX(lex)); ------------------ | | 194| 4.80k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 9.61k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4.80k, False: 0] | | | | | Branch (42:11): [True: 4.80k, False: 0] | | | | ------------------ | | | | 43| 4.80k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 351| 4.80k| source = ISC_LIST_HEAD(lex->sources); ------------------ | | 62| 4.80k|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 352| 4.80k| REQUIRE(tokenp != NULL); ------------------ | | 194| 4.80k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.80k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.80k, False: 0] | | | | ------------------ | | | | 43| 4.80k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 353| | 354| 4.80k| if (source == NULL) { ------------------ | Branch (354:6): [True: 0, False: 4.80k] ------------------ 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| 4.80k| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (362:6): [True: 0, False: 4.80k] ------------------ 363| 0| return source->result; 364| 0| } 365| | 366| 4.80k| lex->saved_paren_count = lex->paren_count; 367| 4.80k| source->saved_line = source->line; 368| | 369| 4.80k| if (isc_buffer_remaininglength(source->pushback) == 0 && source->at_eof) ------------------ | | 159| 4.80k|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (369:6): [True: 401, False: 4.40k] | Branch (369:59): [True: 0, False: 401] ------------------ 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| 4.80k| isc_buffer_compact(source->pushback); 390| | 391| 4.80k| saved_options = options; 392| 4.80k| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && lex->paren_count > 0) { ------------------ | | 77| 4.80k|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (392:6): [True: 0, False: 4.80k] | Branch (392:50): [True: 0, False: 0] ------------------ 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| 4.80k| curr = lex->data; 397| 4.80k| *curr = '\0'; 398| | 399| 4.80k| prev = NULL; 400| 4.80k| remaining = lex->max_token; 401| | 402| 4.80k|#ifdef HAVE_FLOCKFILE 403| 4.80k| if (source->is_file) { ------------------ | Branch (403:6): [True: 0, False: 4.80k] ------------------ 404| 0| flockfile(source->input); 405| 0| } 406| 4.80k|#endif /* ifdef HAVE_FLOCKFILE */ 407| | 408| 15.9M| do { 409| 15.9M| if (isc_buffer_remaininglength(source->pushback) == 0) { ------------------ | | 159| 15.9M|#define isc_buffer_remaininglength(b) ((b)->used - (b)->current) /* d-b */ ------------------ | Branch (409:7): [True: 15.9M, False: 4.40k] ------------------ 410| 15.9M| if (source->is_file) { ------------------ | Branch (410:8): [True: 0, False: 15.9M] ------------------ 411| 0| stream = source->input; 412| | 413| 0|#if defined(HAVE_FLOCKFILE) && defined(HAVE_GETC_UNLOCKED) 414| 0| c = getc_unlocked(stream); 415| |#else /* if defined(HAVE_FLOCKFILE) && defined(HAVE_GETC_UNLOCKED) */ 416| | c = getc(stream); 417| |#endif /* if defined(HAVE_FLOCKFILE) && defined(HAVE_GETC_UNLOCKED) */ 418| 0| if (c == EOF) { ------------------ | Branch (418:9): [True: 0, False: 0] ------------------ 419| 0| if (ferror(stream)) { ------------------ | Branch (419:10): [True: 0, False: 0] ------------------ 420| 0| source->result = 421| 0| isc__errno2result( ------------------ | | 25| 0|#define isc__errno2result(x) isc___errno2result(x, true, __FILE__, __LINE__) ------------------ 422| 0| errno); 423| 0| result = source->result; 424| 0| goto done; 425| 0| } 426| 0| source->at_eof = true; 427| 0| } 428| 15.9M| } else { 429| 15.9M| buffer = source->input; 430| | 431| 15.9M| if (buffer->current == buffer->used) { ------------------ | Branch (431:9): [True: 401, False: 15.9M] ------------------ 432| 401| c = EOF; 433| 401| source->at_eof = true; 434| 15.9M| } else { 435| 15.9M| c = *((unsigned char *)buffer->base + 436| 15.9M| buffer->current); 437| 15.9M| buffer->current++; 438| 15.9M| } 439| 15.9M| } 440| 15.9M| if (c != EOF) { ------------------ | Branch (440:8): [True: 15.9M, False: 401] ------------------ 441| 15.9M| source->result = pushandgrow(lex, source, c); 442| 15.9M| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (442:9): [True: 0, False: 15.9M] ------------------ 443| 0| result = source->result; 444| 0| goto done; 445| 0| } 446| 15.9M| } 447| 15.9M| } 448| | 449| 15.9M| if (!source->at_eof) { ------------------ | Branch (449:7): [True: 15.9M, False: 401] ------------------ 450| 15.9M| if (state == lexstate_start) { ------------------ | Branch (450:8): [True: 11.1k, False: 15.9M] ------------------ 451| | /* Token has not started yet. */ 452| 11.1k| source->ignored = isc_buffer_consumedlength( ------------------ | | 158| 11.1k|#define isc_buffer_consumedlength(b) ((b)->current) /* b-a */ ------------------ 453| 11.1k| source->pushback); 454| 11.1k| } 455| 15.9M| c = isc_buffer_getuint8(source->pushback); 456| 15.9M| } else { 457| 401| c = EOF; 458| 401| } 459| | 460| 15.9M| if (c == '\n') { ------------------ | Branch (460:7): [True: 3.05k, False: 15.9M] ------------------ 461| 3.05k| source->line++; 462| 3.05k| } 463| | 464| 15.9M| if (lex->comment_ok && !no_comments) { ------------------ | Branch (464:7): [True: 15.9M, False: 0] | Branch (464:26): [True: 15.9M, False: 0] ------------------ 465| 15.9M| if (!escaped && c == ';' && ------------------ | Branch (465:8): [True: 15.9M, False: 0] | Branch (465:20): [True: 39.2k, False: 15.9M] ------------------ 466| 39.2k| ((lex->comments & ISC_LEXCOMMENT_DNSMASTERFILE) != ------------------ | | 97| 39.2k|#define ISC_LEXCOMMENT_DNSMASTERFILE 0x08 ------------------ | Branch (466:8): [True: 0, False: 39.2k] ------------------ 467| 39.2k| 0)) 468| 0| { 469| 0| saved_state = state; 470| 0| state = lexstate_eatline; 471| 0| no_comments = true; 472| 0| continue; 473| 15.9M| } else if (c == '/' && ------------------ | Branch (473:15): [True: 4.09k, False: 15.9M] ------------------ 474| 4.09k| (lex->comments & ------------------ | Branch (474:8): [True: 0, False: 4.09k] ------------------ 475| 4.09k| (ISC_LEXCOMMENT_C | ------------------ | | 94| 4.09k|#define ISC_LEXCOMMENT_C 0x01 ------------------ 476| 4.09k| ISC_LEXCOMMENT_CPLUSPLUS)) != 0) ------------------ | | 95| 4.09k|#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| 15.9M| } else if (c == '#' && ((lex->comments & ------------------ | Branch (482:15): [True: 2.44k, False: 15.9M] | Branch (482:27): [True: 0, False: 2.44k] ------------------ 483| 2.44k| ISC_LEXCOMMENT_SHELL) != 0)) ------------------ | | 96| 2.44k|#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| 15.9M| } 491| | 492| 15.9M| no_read: 493| | /* INSIST(c == EOF || (c >= 0 && c <= 255)); */ 494| 15.9M| switch (state) { 495| 11.4k| case lexstate_start: ------------------ | Branch (495:3): [True: 11.4k, False: 15.9M] ------------------ 496| 11.4k| if (c == EOF) { ------------------ | Branch (496:8): [True: 255, False: 11.1k] ------------------ 497| 255| lex->last_was_eol = false; 498| 255| if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && ------------------ | | 77| 255|#define ISC_LEXOPT_DNSMULTILINE 0x0020 /*%< Handle '(' and ')'. */ ------------------ | Branch (498:9): [True: 0, False: 255] ------------------ 499| 0| lex->paren_count != 0) ------------------ | Branch (499:9): [True: 0, False: 0] ------------------ 500| 0| { 501| 0| lex->paren_count = 0; 502| 0| result = ISC_R_UNBALANCED; 503| 0| goto done; 504| 0| } 505| 255| if ((options & ISC_LEXOPT_BTEXT) != 0 && ------------------ | | 84| 255|#define ISC_LEXOPT_BTEXT 0x0800 /*%< Bracketed text. */ ------------------ | Branch (505:9): [True: 0, False: 255] ------------------ 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| 255| if ((options & ISC_LEXOPT_EOF) == 0) { ------------------ | | 63| 255|#define ISC_LEXOPT_EOF 0x0002 /*%< Want end-of-file token. */ ------------------ | Branch (512:9): [True: 255, False: 0] ------------------ 513| 255| result = ISC_R_EOF; 514| 255| goto done; 515| 255| } 516| 0| tokenp->type = isc_tokentype_eof; 517| 0| done = true; 518| 11.1k| } else if (c == ' ' || c == '\t') { ------------------ | Branch (518:15): [True: 2.96k, False: 8.23k] | Branch (518:27): [True: 1.62k, False: 6.61k] ------------------ 519| 4.58k| if (lex->last_was_eol && ------------------ | Branch (519:9): [True: 1.07k, False: 3.50k] ------------------ 520| 1.07k| (options & ISC_LEXOPT_INITIALWS) != 0) ------------------ | | 64| 1.07k|#define ISC_LEXOPT_INITIALWS 0x0004 /*%< Want initial whitespace. */ ------------------ | Branch (520:9): [True: 0, False: 1.07k] ------------------ 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| 6.61k| } else if (c == '\n') { ------------------ | Branch (527:15): [True: 1.66k, False: 4.94k] ------------------ 528| 1.66k| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 1.66k|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (528:9): [True: 0, False: 1.66k] ------------------ 529| 0| tokenp->type = isc_tokentype_eol; 530| 0| done = true; 531| 0| } 532| 1.66k| lex->last_was_eol = true; 533| 4.94k| } else if (c == '\r') { ------------------ | Branch (533:15): [True: 393, False: 4.55k] ------------------ 534| 393| if ((options & ISC_LEXOPT_EOL) != 0) { ------------------ | | 62| 393|#define ISC_LEXOPT_EOL 0x0001 /*%< Want end-of-line token. */ ------------------ | Branch (534:9): [True: 0, False: 393] ------------------ 535| 0| state = lexstate_crlf; 536| 0| } 537| 4.55k| } else if (c == '"' && ------------------ | Branch (537:15): [True: 486, False: 4.06k] ------------------ 538| 486| (options & ISC_LEXOPT_QSTRING) != 0) ------------------ | | 66| 486|#define ISC_LEXOPT_QSTRING 0x0010 /*%< Recognize qstrings. */ ------------------ | Branch (538:8): [True: 0, False: 486] ------------------ 539| 0| { 540| 0| lex->last_was_eol = false; 541| 0| no_comments = true; 542| 0| state = lexstate_qstring; 543| 4.55k| } else if (lex->specials[c]) { ------------------ | Branch (543:15): [True: 0, False: 4.55k] ------------------ 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| 4.55k| } else if (isdigit((unsigned char)c) && ------------------ | Branch (581:15): [True: 952, False: 3.60k] ------------------ 582| 952| (options & ISC_LEXOPT_NUMBER) != 0) ------------------ | | 65| 952|#define ISC_LEXOPT_NUMBER 0x0008 /*%< Recognize numbers. */ ------------------ | Branch (582:8): [True: 0, False: 952] ------------------ 583| 0| { 584| 0| lex->last_was_eol = false; 585| 0| if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 0|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (585:9): [True: 0, False: 0] ------------------ 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| 0| } else { 590| 0| state = lexstate_number; 591| 0| } 592| 0| goto no_read; 593| 4.55k| } else { 594| 4.55k| lex->last_was_eol = false; 595| 4.55k| state = lexstate_string; 596| 4.55k| goto no_read; 597| 4.55k| } 598| 6.64k| break; 599| 6.64k| case lexstate_crlf: ------------------ | Branch (599:3): [True: 0, False: 15.9M] ------------------ 600| 0| if (c != '\n') { ------------------ | Branch (600:8): [True: 0, False: 0] ------------------ 601| 0| pushback(source, c); 602| 0| } 603| 0| tokenp->type = isc_tokentype_eol; 604| 0| done = true; 605| 0| lex->last_was_eol = true; 606| 0| break; 607| 0| case lexstate_number: ------------------ | Branch (607:3): [True: 0, False: 15.9M] ------------------ 608| 0| if (c == EOF || !isdigit((unsigned char)c)) { ------------------ | Branch (608:8): [True: 0, False: 0] | Branch (608:20): [True: 0, False: 0] ------------------ 609| 0| if (c == ' ' || c == '\t' || c == '\r' || ------------------ | Branch (609:9): [True: 0, False: 0] | Branch (609:21): [True: 0, False: 0] | Branch (609:34): [True: 0, False: 0] ------------------ 610| 0| c == '\n' || c == EOF || lex->specials[c]) ------------------ | Branch (610:9): [True: 0, False: 0] | Branch (610:22): [True: 0, False: 0] | Branch (610:34): [True: 0, False: 0] ------------------ 611| 0| { 612| 0| int base; 613| 0| if ((options & ISC_LEXOPT_OCTAL) != 0) { ------------------ | | 83| 0|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (613:10): [True: 0, False: 0] ------------------ 614| 0| base = 8; 615| 0| } else if ((options & ------------------ | Branch (615:17): [True: 0, False: 0] ------------------ 616| 0| ISC_LEXOPT_CNUMBER) != 0) ------------------ | | 80| 0|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ 617| 0| { 618| 0| base = 0; 619| 0| } else { 620| 0| base = 10; 621| 0| } 622| 0| pushback(source, c); 623| | 624| 0| result = isc_parse_uint32( 625| 0| &as_ulong, lex->data, base); 626| 0| if (result == ISC_R_SUCCESS) { ------------------ | Branch (626:10): [True: 0, False: 0] ------------------ 627| 0| tokenp->type = 628| 0| isc_tokentype_number; 629| 0| tokenp->value.as_ulong = 630| 0| as_ulong; 631| 0| } else if (result == ISC_R_BADNUMBER) { ------------------ | Branch (631:17): [True: 0, False: 0] ------------------ 632| 0| isc_tokenvalue_t *v; 633| | 634| 0| tokenp->type = 635| 0| isc_tokentype_string; 636| 0| v = &(tokenp->value); 637| 0| v->as_textregion.base = 638| 0| lex->data; 639| 0| v->as_textregion.length = 640| 0| (unsigned int)(lex->max_token - 641| 0| remaining); 642| 0| } else { 643| 0| goto done; 644| 0| } 645| 0| done = true; 646| 0| continue; 647| 0| } else if ((options & ISC_LEXOPT_CNUMBER) == ------------------ | | 80| 0|#define ISC_LEXOPT_CNUMBER 0x0080 /*%< Recognize octal and hex. */ ------------------ | Branch (647:16): [True: 0, False: 0] ------------------ 648| 0| 0 || 649| 0| ((c != 'x' && c != 'X') || ------------------ | Branch (649:11): [True: 0, False: 0] | Branch (649:23): [True: 0, False: 0] ------------------ 650| 0| (curr != &lex->data[1]) || ------------------ | Branch (650:10): [True: 0, False: 0] ------------------ 651| 0| (lex->data[0] != '0'))) ------------------ | Branch (651:10): [True: 0, False: 0] ------------------ 652| 0| { 653| | /* Above test supports hex numbers */ 654| 0| state = lexstate_string; 655| 0| } 656| 0| } else if ((options & ISC_LEXOPT_OCTAL) != 0 && ------------------ | | 83| 0|#define ISC_LEXOPT_OCTAL 0x0400 /*%< Expect a octal number. */ ------------------ | Branch (656:15): [True: 0, False: 0] ------------------ 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| 0| if (remaining == 0U) { ------------------ | Branch (661:8): [True: 0, False: 0] ------------------ 662| 0| grow_data(lex, &remaining, &curr, &prev); 663| 0| } 664| 0| INSIST(remaining > 0U); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 665| 0| *curr++ = c; 666| 0| *curr = '\0'; 667| 0| remaining--; 668| 0| break; 669| 15.9M| case lexstate_string: ------------------ | Branch (669:3): [True: 15.9M, False: 11.4k] ------------------ 670| 15.9M| if (!escaped && c == '=' && ------------------ | Branch (670:8): [True: 15.9M, False: 0] | Branch (670:20): [True: 1.30k, False: 15.9M] ------------------ 671| 1.30k| (options & ISC_LEXOPT_VPAIR) != 0) ------------------ | | 85| 1.30k|#define ISC_LEXOPT_VPAIR 0x1000 /*%< Recognize value pair. */ ------------------ | Branch (671:8): [True: 0, False: 1.30k] ------------------ 672| 0| { 673| 0| if (remaining == 0U) { ------------------ | Branch (673:9): [True: 0, False: 0] ------------------ 674| 0| grow_data(lex, &remaining, &curr, 675| 0| &prev); 676| 0| } 677| 0| INSIST(remaining > 0U); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 678| 0| *curr++ = c; 679| 0| *curr = '\0'; 680| 0| remaining--; 681| 0| state = lexstate_vpairstart; 682| 0| break; 683| 0| } 684| 15.9M| FALLTHROUGH; ------------------ | | 101| 15.9M|#define FALLTHROUGH [[fallthrough]] ------------------ 685| 15.9M| case lexstate_vpairstart: ------------------ | Branch (685:3): [True: 0, False: 15.9M] ------------------ 686| 15.9M| if (state == lexstate_vpairstart) { ------------------ | Branch (686:8): [True: 0, False: 15.9M] ------------------ 687| 0| if (c == '"' && ------------------ | Branch (687:9): [True: 0, False: 0] ------------------ 688| 0| (options & ISC_LEXOPT_QVPAIR) != 0) ------------------ | | 86| 0|#define ISC_LEXOPT_QVPAIR 0x2000 /*%< Recognize quoted value pair. */ ------------------ | Branch (688:9): [True: 0, False: 0] ------------------ 689| 0| { 690| 0| no_comments = true; 691| 0| state = lexstate_qvpair; 692| 0| break; 693| 0| } 694| 0| state = lexstate_vpair; 695| 0| } 696| 15.9M| FALLTHROUGH; ------------------ | | 101| 15.9M|#define FALLTHROUGH [[fallthrough]] ------------------ 697| 15.9M| case lexstate_vpair: ------------------ | Branch (697:3): [True: 0, False: 15.9M] ------------------ 698| | /* 699| | * EOF needs to be checked before lex->specials[c] 700| | * as lex->specials[EOF] is not a good idea. 701| | */ 702| 15.9M| if (c == '\r' || c == '\n' || c == EOF || ------------------ | Branch (702:8): [True: 199, False: 15.9M] | Branch (702:21): [True: 1.38k, False: 15.9M] | Branch (702:34): [True: 146, False: 15.9M] ------------------ 703| 15.9M| (!escaped && ------------------ | Branch (703:9): [True: 15.9M, False: 0] ------------------ 704| 15.9M| (c == ' ' || c == '\t' || lex->specials[c]))) ------------------ | Branch (704:10): [True: 2.42k, False: 15.9M] | Branch (704:22): [True: 404, False: 15.9M] | Branch (704:35): [True: 0, False: 15.9M] ------------------ 705| 4.55k| { 706| 4.55k| pushback(source, c); 707| 4.55k| if (source->result != ISC_R_SUCCESS) { ------------------ | Branch (707:9): [True: 0, False: 4.55k] ------------------ 708| 0| result = source->result; 709| 0| goto done; 710| 0| } 711| 4.55k| if (escaped && c == EOF) { ------------------ | Branch (711:9): [True: 0, False: 4.55k] | Branch (711:20): [True: 0, False: 0] ------------------ 712| 0| result = ISC_R_UNEXPECTEDEND; 713| 0| goto done; 714| 0| } 715| 4.55k| tokenp->type = (state == lexstate_string) ------------------ | Branch (715:20): [True: 4.55k, False: 0] ------------------ 716| 4.55k| ? isc_tokentype_string 717| 4.55k| : isc_tokentype_vpair; 718| 4.55k| tokenp->value.as_textregion.base = lex->data; 719| 4.55k| tokenp->value.as_textregion.length = 720| 4.55k| (unsigned int)(lex->max_token - 721| 4.55k| remaining); 722| 4.55k| done = true; 723| 4.55k| continue; 724| 4.55k| } 725| 15.9M| if ((options & ISC_LEXOPT_ESCAPE) != 0) { ------------------ | | 81| 15.9M|#define ISC_LEXOPT_ESCAPE 0x0100 /*%< Recognize escapes. */ ------------------ | Branch (725:8): [True: 0, False: 15.9M] ------------------ 726| 0| escaped = (!escaped && c == '\\') ? true ------------------ | Branch (726:16): [True: 0, False: 0] | Branch (726:28): [True: 0, False: 0] ------------------ 727| 0| : false; 728| 0| } 729| 15.9M| if (remaining == 0U) { ------------------ | Branch (729:8): [True: 10, False: 15.9M] ------------------ 730| 10| grow_data(lex, &remaining, &curr, &prev); 731| 10| } 732| 15.9M| INSIST(remaining > 0U); ------------------ | | 198| 15.9M|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 15.9M| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 15.9M, False: 0] | | | | ------------------ | | | | 55| 15.9M| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 733| 15.9M| *curr++ = c; 734| 15.9M| *curr = '\0'; 735| 15.9M| remaining--; 736| 15.9M| break; 737| 0| case lexstate_maybecomment: ------------------ | Branch (737:3): [True: 0, False: 15.9M] ------------------ 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: 15.9M] ------------------ 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: 15.9M] ------------------ 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: 15.9M] ------------------ 783| 0| if ((c == '\n') || (c == EOF)) { ------------------ | Branch (783:8): [True: 0, False: 0] | Branch (783:23): [True: 0, False: 0] ------------------ 784| 0| no_comments = false; 785| 0| state = saved_state; 786| 0| goto no_read; 787| 0| } 788| 0| break; 789| 0| case lexstate_qstring: ------------------ | Branch (789:3): [True: 0, False: 15.9M] ------------------ 790| 0| case lexstate_qvpair: ------------------ | Branch (790:3): [True: 0, False: 15.9M] ------------------ 791| 0| if (c == EOF) { ------------------ | Branch (791:8): [True: 0, False: 0] ------------------ 792| 0| result = ISC_R_UNEXPECTEDEND; 793| 0| goto done; 794| 0| } 795| 0| if (c == '"') { ------------------ | Branch (795:8): [True: 0, False: 0] ------------------ 796| 0| if (escaped) { ------------------ | Branch (796:9): [True: 0, False: 0] ------------------ 797| 0| escaped = false; 798| | /* 799| | * Overwrite the preceding backslash. 800| | */ 801| 0| INSIST(prev != NULL); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 802| 0| *prev = '"'; 803| 0| } else { 804| 0| tokenp->type = 805| 0| (state == lexstate_qstring) ------------------ | Branch (805:7): [True: 0, False: 0] ------------------ 806| 0| ? isc_tokentype_qstring 807| 0| : isc_tokentype_qvpair; 808| 0| tokenp->value.as_textregion.base = 809| 0| lex->data; 810| 0| tokenp->value.as_textregion.length = 811| 0| (unsigned int)(lex->max_token - 812| 0| remaining); 813| 0| no_comments = false; 814| 0| done = true; 815| 0| } 816| 0| } else { 817| 0| if (c == '\n' && !escaped && ------------------ | Branch (817:9): [True: 0, False: 0] | Branch (817:22): [True: 0, False: 0] ------------------ 818| 0| (options & ISC_LEXOPT_QSTRINGMULTILINE) == ------------------ | | 82| 0|#define ISC_LEXOPT_QSTRINGMULTILINE 0x0200 /*%< Allow multiline "" strings */ ------------------ | Branch (818:9): [True: 0, False: 0] ------------------ 819| 0| 0) 820| 0| { 821| 0| pushback(source, c); 822| 0| result = ISC_R_UNBALANCEDQUOTES; 823| 0| goto done; 824| 0| } 825| 0| if (c == '\\' && !escaped) { ------------------ | Branch (825:9): [True: 0, False: 0] | Branch (825:22): [True: 0, False: 0] ------------------ 826| 0| escaped = true; 827| 0| } else { 828| 0| escaped = false; 829| 0| } 830| 0| if (remaining == 0U) { ------------------ | Branch (830:9): [True: 0, False: 0] ------------------ 831| 0| grow_data(lex, &remaining, &curr, 832| 0| &prev); 833| 0| } 834| 0| INSIST(remaining > 0U); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 835| 0| prev = curr; 836| 0| *curr++ = c; 837| 0| *curr = '\0'; 838| 0| remaining--; 839| 0| } 840| 0| break; 841| 0| case lexstate_btext: ------------------ | Branch (841:3): [True: 0, False: 15.9M] ------------------ 842| 0| if (c == EOF) { ------------------ | Branch (842:8): [True: 0, False: 0] ------------------ 843| 0| result = ISC_R_UNEXPECTEDEND; 844| 0| goto done; 845| 0| } 846| 0| if (c == '{') { ------------------ | Branch (846:8): [True: 0, False: 0] ------------------ 847| 0| if (escaped) { ------------------ | Branch (847:9): [True: 0, False: 0] ------------------ 848| 0| escaped = false; 849| 0| } else { 850| 0| lex->brace_count++; 851| 0| } 852| 0| } else if (c == '}') { ------------------ | Branch (852:15): [True: 0, False: 0] ------------------ 853| 0| if (escaped) { ------------------ | Branch (853:9): [True: 0, False: 0] ------------------ 854| 0| escaped = false; 855| 0| } else { 856| 0| INSIST(lex->brace_count > 0); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 857| 0| lex->brace_count--; 858| 0| } 859| | 860| 0| if (lex->brace_count == 0) { ------------------ | Branch (860:9): [True: 0, False: 0] ------------------ 861| 0| tokenp->type = isc_tokentype_btext; 862| 0| tokenp->value.as_textregion.base = 863| 0| lex->data; 864| 0| tokenp->value.as_textregion.length = 865| 0| (unsigned int)(lex->max_token - 866| 0| remaining); 867| 0| no_comments = false; 868| 0| done = true; 869| 0| break; 870| 0| } 871| 0| } 872| | 873| 0| if (c == '\\' && !escaped) { ------------------ | Branch (873:8): [True: 0, False: 0] | Branch (873:21): [True: 0, False: 0] ------------------ 874| 0| escaped = true; 875| 0| } else { 876| 0| escaped = false; 877| 0| } 878| | 879| 0| if (remaining == 0U) { ------------------ | Branch (879:8): [True: 0, False: 0] ------------------ 880| 0| grow_data(lex, &remaining, &curr, &prev); 881| 0| } 882| 0| INSIST(remaining > 0U); ------------------ | | 198| 0|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 0| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 0, False: 0] | | | | ------------------ | | | | 55| 0| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 883| 0| prev = curr; 884| 0| *curr++ = c; 885| 0| *curr = '\0'; 886| 0| remaining--; 887| 0| break; 888| 0| default: ------------------ | Branch (888:3): [True: 0, False: 15.9M] ------------------ 889| 0| FATAL_ERROR("Unexpected state %d", state); ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 890| 15.9M| } 891| 15.9M| } while (!done); ------------------ | Branch (891:11): [True: 15.9M, False: 4.55k] ------------------ 892| | 893| 4.55k| result = ISC_R_SUCCESS; 894| 4.80k|done: 895| 4.80k|#ifdef HAVE_FLOCKFILE 896| 4.80k| if (source->is_file) { ------------------ | Branch (896:6): [True: 0, False: 4.80k] ------------------ 897| 0| funlockfile(source->input); 898| 0| } 899| 4.80k|#endif /* ifdef HAVE_FLOCKFILE */ 900| 4.80k| return result; 901| 4.55k|} lex.c:new_source: 183| 255| const char *name) { 184| 255| inputsource *source; 185| | 186| 255| source = isc_mem_get(lex->mctx, sizeof(*source)); ------------------ | | 128| 255|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 187| 255| *source = (inputsource){ 188| 255| .is_file = is_file, 189| 255| .need_close = need_close, 190| 255| .last_was_eol = lex->last_was_eol, 191| 255| .input = input, 192| 255| .name = isc_mem_strdup(lex->mctx, name), ------------------ | | 144| 255|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 193| 255| .line = 1, 194| 255| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 255|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 255| { \ | | | | 27| 255| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 255|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 255| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 255|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 255| } | | ------------------ ------------------ 195| 255| }; 196| 255| isc_buffer_allocate(lex->mctx, &source->pushback, 197| 255| (unsigned int)lex->max_token); 198| | ISC_LIST_PREPEND(lex->sources, source, link); ------------------ | | 79| 255| do { \ | | 80| 255| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 255| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 255| do { \ | | | | 68| 255| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 254, False: 1] | | | | ------------------ | | | | 69| 254| (list).head->link.prev = (elt); \ | | | | 70| 254| } else { \ | | | | 71| 1| (list).tail = (elt); \ | | | | 72| 1| } \ | | | | 73| 255| (elt)->link.prev = NULL; \ | | | | 74| 255| (elt)->link.next = (list).head; \ | | | | 75| 255| (list).head = (elt); \ | | | | 76| 255| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 255] | | | | ------------------ | | ------------------ | | 82| 255| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 255] | | ------------------ ------------------ 199| 255|} lex.c:pushandgrow: 309| 15.9M|pushandgrow(isc_lex_t *lex, inputsource *source, int c) { 310| 15.9M| if (isc_buffer_availablelength(source->pushback) == 0) { ------------------ | | 161| 15.9M|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ | Branch (310:6): [True: 15, False: 15.9M] ------------------ 311| 15| isc_buffer_t *tbuf = NULL; 312| 15| unsigned int oldlen; 313| 15| isc_region_t used; 314| 15| isc_result_t result; 315| | 316| 15| oldlen = isc_buffer_length(source->pushback); ------------------ | | 150| 15|#define isc_buffer_length(b) ((b)->length) /*e*/ ------------------ 317| 15| isc_buffer_allocate(lex->mctx, &tbuf, oldlen * 2); 318| 15| isc_buffer_usedregion(source->pushback, &used); 319| 15| result = isc_buffer_copyregion(tbuf, &used); 320| 15| INSIST(result == ISC_R_SUCCESS); ------------------ | | 198| 15|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 15| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 15, False: 0] | | | | ------------------ | | | | 55| 15| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 321| 15| tbuf->current = source->pushback->current; 322| 15| isc_buffer_free(&source->pushback); 323| 15| source->pushback = tbuf; 324| 15| } 325| 15.9M| isc_buffer_putuint8(source->pushback, (uint8_t)c); 326| 15.9M| return ISC_R_SUCCESS; 327| 15.9M|} lex.c:pushback: 296| 4.55k|pushback(inputsource *source, int c) { 297| 4.55k| REQUIRE(source->pushback->current > 0); ------------------ | | 194| 4.55k|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4.55k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4.55k, False: 0] | | | | ------------------ | | | | 43| 4.55k| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 298| 4.55k| if (c == EOF) { ------------------ | Branch (298:6): [True: 146, False: 4.40k] ------------------ 299| 146| source->at_eof = false; 300| 146| return; 301| 146| } 302| 4.40k| source->pushback->current--; 303| 4.40k| if (c == '\n') { ------------------ | Branch (303:6): [True: 1.38k, False: 3.02k] ------------------ 304| 1.38k| source->line--; 305| 1.38k| } 306| 4.40k|} 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); ------------------ | | 150| 10| do { \ | | 151| 10| isc__mem_put((c), (p), (s), 0 _ISC_MEM_FILELINE); \ | | 152| 10| (p) = NULL; \ | | 153| 10| } while (0) | | ------------------ | | | Branch (153: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); \ | | ------------------ | | | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | | | ------------------ | | | | | | 54| 4| ((void)((cond) || \ | | | | | | ------------------ | | | | | | | Branch (54:10): [True: 4, False: 0] | | | | | | ------------------ | | | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | | | ------------------ | | | | | | | Branch (55:3): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | | | 57| 0| 0))) | | | | ------------------ | | ------------------ | | 72| 4| __v; \ | | 73| 4| }) ------------------ | Branch (47:6): [True: 2, False: 2] ------------------ 48| 2| return; 49| 2| } 50| | 51| 4| rcu_register_thread(); 52| 2| isc__os_initialize(); 53| 2| isc__mutex_initialize(); 54| 2| isc__mem_initialize(); 55| 2| isc__log_initialize(); 56| 2| isc__crypto_initialize(); 57| 2| isc__uv_initialize(); 58| 2| isc__xml_initialize(); 59| 2| isc__hash_initialize(); 60| 2| isc__iterated_hash_initialize(); 61| 2| (void)isc_os_ncpus(); 62| 2|} isc_logconfig_create: 328| 2|isc_logconfig_create(isc_logconfig_t **lcfgp) { 329| 2| REQUIRE(lcfgp != NULL && *lcfgp == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 330| 2| REQUIRE(VALID_CONTEXT(isc__lctx)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 331| | 332| 2| int level = ISC_LOG_INFO; ------------------ | | 42| 2|#define ISC_LOG_INFO (-1) ------------------ 333| | 334| 2| isc_logconfig_t *lcfg = isc_mem_get(isc__lctx->mctx, sizeof(*lcfg)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 335| | 336| 2| *lcfg = (isc_logconfig_t){ 337| 2| .magic = LCFG_MAGIC, ------------------ | | 43| 2|#define LCFG_MAGIC ISC_MAGIC('L', 'c', 'f', 'g') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 338| 2| .lctx = isc__lctx, 339| 2| .channels = ISC_LIST_INITIALIZER, ------------------ | | 21| 2| { \ | | 22| 2| .head = NULL, \ | | 23| 2| .tail = NULL, \ | | 24| 2| } ------------------ 340| 2| .highest_level = level, 341| 2| }; 342| | 343| | /* 344| | * Create the default channels: 345| | * default_syslog, default_stderr, default_debug and null. 346| | */ 347| 2| isc_log_createchannel(lcfg, "default_syslog", ISC_LOG_TOSYSLOG, level, ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ 348| 2| ISC_LOGDESTINATION_SYSLOG(LOG_DAEMON), 0); ------------------ | | 287| 2| (&(isc_logdestination_t){ .facility = (f) }) ------------------ 349| | 350| 2| isc_log_createchannel(lcfg, "default_stderr", ISC_LOG_TOFILEDESC, level, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 351| 2| ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ ISC_LOGDESTINATION_STDERR, ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 352| | 353| | /* 354| | * Set the default category's channel to default_stderr, 355| | * which is at the head of the channels list because it was 356| | * just created. 357| | */ 358| 2| default_channel.channel = ISC_LIST_HEAD(lcfg->channels); ------------------ | | 62| 2|#define ISC_LIST_HEAD(list) ((list).head) ------------------ 359| | 360| 2| isc_log_createchannel(lcfg, "default_debug", ISC_LOG_TOFILEDESC, ------------------ | | 56| 2|#define ISC_LOG_TOFILEDESC 4 ------------------ 361| 2| ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ ISC_LOG_DYNAMIC, ISC_LOGDESTINATION_STDERR, ------------------ | | 284| 2|#define ISC_LOGDESTINATION_STDERR ISC_LOGDESTINATION_FILE(stderr) | | ------------------ | | | | 277| 2| (&(isc_logdestination_t){ \ | | | | 278| 2| .file = { \ | | | | 279| 2| .stream = errout, \ | | | | 280| 2| .versions = ISC_LOG_ROLLNEVER, \ | | | | ------------------ | | | | | | 87| 2|#define ISC_LOG_ROLLNEVER (-2) | | | | ------------------ | | | | 281| 2| .suffix = isc_log_rollsuffix_increment, \ | | | | 282| 2| } }) | | ------------------ ------------------ 362| 2| ISC_LOG_PRINTTIME); ------------------ | | 63| 2|#define ISC_LOG_PRINTTIME 0x00001 ------------------ 363| | 364| 2| isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ isc_log_createchannel(lcfg, "null", ISC_LOG_TONULL, ISC_LOG_DYNAMIC, ------------------ | | 41| 2|#define ISC_LOG_DYNAMIC 0 ------------------ 365| 2| NULL, 0); 366| | 367| 2| *lcfgp = lcfg; 368| 2|} isc_log_createchannel: 473| 8| unsigned int flags) { 474| 8| isc_logchannel_t *channel; 475| 8| isc_mem_t *mctx; 476| 8| unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 69| 8|#define ISC_LOG_PRINTALL 0x0003F ------------------ unsigned int permitted = ISC_LOG_PRINTALL | ISC_LOG_DEBUGONLY | ------------------ | | 71| 8|#define ISC_LOG_DEBUGONLY 0x01000 ------------------ 477| 8| ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 70| 8|#define ISC_LOG_BUFFERED 0x00040 ------------------ ISC_LOG_BUFFERED | ISC_LOG_ISO8601 | ------------------ | | 73| 8|#define ISC_LOG_ISO8601 0x10000 /* if PRINTTIME, use ISO8601 */ ------------------ 478| 8| ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 74| 8|#define ISC_LOG_UTC 0x20000 /* if PRINTTIME, use UTC */ ------------------ ISC_LOG_UTC | ISC_LOG_TZINFO; ------------------ | | 75| 8|#define ISC_LOG_TZINFO 0x40000 /* if PRINTTIME, output TZ info */ ------------------ 479| | 480| 8| REQUIRE(VALID_CONFIG(lcfg)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 16| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 481| 8| REQUIRE(name != NULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 482| 8| REQUIRE(type == ISC_LOG_TOSYSLOG || type == ISC_LOG_TOFILE || ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 38| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 6] | | | | | Branch (42:11): [True: 0, False: 6] | | | | | Branch (42:11): [True: 4, False: 2] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 483| 8| type == ISC_LOG_TOFILEDESC || type == ISC_LOG_TONULL); 484| 8| REQUIRE(destination != NULL || type == ISC_LOG_TONULL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 6, False: 2] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 485| 8| REQUIRE(level >= ISC_LOG_CRITICAL); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 486| 8| REQUIRE((flags & ~permitted) == 0); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 8, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 487| 8| REQUIRE(!(flags & ISC_LOG_UTC) || !(flags & ISC_LOG_TZINFO)); ------------------ | | 194| 8|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 8, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 8| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 488| | 489| | /* FIXME: find duplicate names? */ 490| | 491| 8| mctx = lcfg->lctx->mctx; 492| | 493| 8| channel = isc_mem_get(mctx, sizeof(*channel)); ------------------ | | 128| 8|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 494| | 495| 8| channel->name = isc_mem_strdup(mctx, name); ------------------ | | 144| 8|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 496| | 497| 8| channel->type = type; 498| 8| channel->level = level; 499| 8| channel->flags = flags; 500| 8| ISC_LINK_INIT(channel, link); ------------------ | | 57| 8|#define ISC_LINK_INIT(elt, link) ISC_LINK_INIT_TYPE(elt, link, void) | | ------------------ | | | | 53| 8| do { \ | | | | 54| 8| (elt)->link.prev = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 55| 8| (elt)->link.next = ISC_LINK_TOMBSTONE(type); \ | | | | ------------------ | | | | | | 18| 8|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 56| 8| } while (0) | | | | ------------------ | | | | | Branch (56:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 501| | 502| 8| switch (type) { 503| 2| case ISC_LOG_TOSYSLOG: ------------------ | | 54| 2|#define ISC_LOG_TOSYSLOG 2 ------------------ | Branch (503:2): [True: 2, False: 6] ------------------ 504| 2| FACILITY(channel) = destination->facility; ------------------ | | 314| 2|#define FACILITY(channel) (channel->destination.facility) ------------------ 505| 2| break; 506| | 507| 0| case ISC_LOG_TOFILE: ------------------ | | 55| 0|#define ISC_LOG_TOFILE 3 ------------------ | Branch (507:2): [True: 0, False: 8] ------------------ 508| | /* 509| | * The file name is copied because greatest_version wants 510| | * to scribble on it, so it needs to be definitely in 511| | * writable memory. 512| | */ 513| 0| FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 315| 0|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ FILE_NAME(channel) = isc_mem_strdup(mctx, ------------------ | | 144| 0|#define isc_mem_strdup(c, p) isc__mem_strdup((c), (p)_ISC_MEM_FILELINE) ------------------ 514| 0| destination->file.name); 515| 0| FILE_STREAM(channel) = NULL; ------------------ | | 316| 0|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 516| 0| FILE_VERSIONS(channel) = destination->file.versions; ------------------ | | 317| 0|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ 517| 0| FILE_SUFFIX(channel) = destination->file.suffix; ------------------ | | 318| 0|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 518| 0| FILE_MAXSIZE(channel) = destination->file.maximum_size; ------------------ | | 319| 0|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 519| 0| FILE_MAXREACHED(channel) = false; ------------------ | | 320| 0|#define FILE_MAXREACHED(channel) (channel->destination.file.maximum_reached) ------------------ 520| 0| break; 521| | 522| 4| case ISC_LOG_TOFILEDESC: ------------------ | | 56| 4|#define ISC_LOG_TOFILEDESC 4 ------------------ | Branch (522:2): [True: 4, False: 4] ------------------ 523| 4| FILE_NAME(channel) = NULL; ------------------ | | 315| 4|#define FILE_NAME(channel) (channel->destination.file.name) ------------------ 524| 4| FILE_STREAM(channel) = destination->file.stream; ------------------ | | 316| 4|#define FILE_STREAM(channel) (channel->destination.file.stream) ------------------ 525| 4| FILE_MAXSIZE(channel) = 0; ------------------ | | 319| 4|#define FILE_MAXSIZE(channel) (channel->destination.file.maximum_size) ------------------ 526| 4| FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 317| 4|#define FILE_VERSIONS(channel) (channel->destination.file.versions) ------------------ FILE_VERSIONS(channel) = ISC_LOG_ROLLNEVER; ------------------ | | 87| 4|#define ISC_LOG_ROLLNEVER (-2) ------------------ 527| 4| FILE_SUFFIX(channel) = isc_log_rollsuffix_increment; ------------------ | | 318| 4|#define FILE_SUFFIX(channel) (channel->destination.file.suffix) ------------------ 528| 4| break; 529| | 530| 2| case ISC_LOG_TONULL: ------------------ | | 53| 2|#define ISC_LOG_TONULL 1 ------------------ | Branch (530:2): [True: 2, False: 6] ------------------ 531| | /* Nothing. */ 532| 2| break; 533| | 534| 0| default: ------------------ | Branch (534:2): [True: 0, False: 8] ------------------ 535| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 536| 8| } 537| | 538| 8| ISC_LIST_PREPEND(lcfg->channels, channel, link); ------------------ | | 79| 8| do { \ | | 80| 8| ISC_LINK_INSIST(!ISC_LINK_LINKED(elt, link)); \ | | 81| 8| __ISC_LIST_PREPENDUNSAFE(list, elt, link); \ | | ------------------ | | | | 67| 8| do { \ | | | | 68| 8| if ((list).head != NULL) { \ | | | | ------------------ | | | | | Branch (68:7): [True: 6, False: 2] | | | | ------------------ | | | | 69| 6| (list).head->link.prev = (elt); \ | | | | 70| 6| } else { \ | | | | 71| 2| (list).tail = (elt); \ | | | | 72| 2| } \ | | | | 73| 8| (elt)->link.prev = NULL; \ | | | | 74| 8| (elt)->link.next = (list).head; \ | | | | 75| 8| (list).head = (elt); \ | | | | 76| 8| } while (0) | | | | ------------------ | | | | | Branch (76:11): [Folded, False: 8] | | | | ------------------ | | ------------------ | | 82| 8| } while (0) | | ------------------ | | | Branch (82:11): [Folded, False: 8] | | ------------------ ------------------ 539| | 540| | /* 541| | * If default_stderr was redefined, make the default category 542| | * point to the new default_stderr. 543| | */ 544| 8| if (strcmp(name, "default_stderr") == 0) { ------------------ | Branch (544:6): [True: 2, False: 6] ------------------ 545| 2| default_channel.channel = channel; 546| 2| } 547| 8|} isc__log_initialize: 1532| 2|isc__log_initialize(void) { 1533| 2| REQUIRE(isc__lctx == NULL); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 2| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1534| | 1535| 2| isc_mem_t *mctx = NULL; 1536| | 1537| 2| isc_mem_create("log", &mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 1538| 2| isc_mem_setdebugging(mctx, 0); 1539| | 1540| 2| isc__lctx = isc_mem_get(mctx, sizeof(*isc__lctx)); ------------------ | | 128| 2|#define isc_mem_get(c, s) isc__mem_get((c), (s), 0 _ISC_MEM_FILELINE) ------------------ 1541| 2| *isc__lctx = (isc_log_t){ 1542| 2| .magic = LCTX_MAGIC, ------------------ | | 40| 2|#define LCTX_MAGIC ISC_MAGIC('L', 'c', 't', 'x') | | ------------------ | | | | 31| 2|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 1543| 2| .mctx = mctx, /* implicit attach */ 1544| 2| }; 1545| | 1546| 2| isc_mutex_init(&isc__lctx->lock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 1547| | 1548| | /* Create default logging configuration */ 1549| 2| isc_logconfig_t *lcfg = NULL; 1550| 2| isc_logconfig_create(&lcfg); 1551| | 1552| 2| atomic_init(&isc__lctx->highest_level, lcfg->highest_level); 1553| 2| atomic_init(&isc__lctx->dynamic, lcfg->dynamic); 1554| | 1555| 2| isc__lctx->logconfig = lcfg; 1556| 2|} isc__mem_initialize: 505| 2|isc__mem_initialize(void) { 506| |/* 507| | * Check if the values copied from jemalloc still match 508| | */ 509| |#ifdef JEMALLOC_API_SUPPORTED 510| | RUNTIME_CHECK(ISC__MEM_ZERO == MALLOCX_ZERO); 511| | 512| | /* 513| | * ignore errors — volumetric-based purge in mem_put handles the rest 514| | * regardless 515| | */ 516| | 517| | (void)mallctl("background_thread", NULL, NULL, &(bool){ true }, 518| | sizeof(bool)); 519| | 520| | (void)mallctl("arenas.dirty_decay_ms", NULL, NULL, 521| | &default_dirty_decay_ms, sizeof(default_dirty_decay_ms)); 522| | 523| | (void)mallctl("arena." STRINGIFY(MALLCTL_ARENAS_ALL) ".dirty_decay_ms", 524| | NULL, NULL, &default_dirty_decay_ms, 525| | sizeof(default_dirty_decay_ms)); 526| | 527| |#endif /* JEMALLOC_API_SUPPORTED */ 528| | 529| 2| isc_mutex_init(&contextslock); ------------------ | | 68| 2|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 2| { \ | | | | 80| 2| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 2| } | | ------------------ ------------------ 530| 2| ISC_LIST_INIT(contexts); ------------------ | | 43| 2| do { \ | | 44| 2| (list).head = NULL; \ | | 45| 2| (list).tail = NULL; \ | | 46| 2| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 2] | | ------------------ ------------------ 531| | 532| 2| if (debugging_enabled("ISC_MEM_DEBUGTRACE")) { ------------------ | Branch (532:6): [True: 0, False: 2] ------------------ 533| 0| mem_debugging |= ISC_MEM_DEBUGTRACE; ------------------ | | 39| 0|#define ISC_MEM_DEBUGTRACE 0x00000001U ------------------ 534| 0| } 535| | 536| 2| if (debugging_enabled("ISC_MEM_DEBUGRECORD")) { ------------------ | Branch (536:6): [True: 0, False: 2] ------------------ 537| 0| mem_debugging |= ISC_MEM_DEBUGRECORD; ------------------ | | 40| 0|#define ISC_MEM_DEBUGRECORD 0x00000002U ------------------ 538| 0| } 539| | 540| 2| if (debugging_enabled("ISC_MEM_DEBUGUSAGE")) { ------------------ | Branch (540:6): [True: 0, False: 2] ------------------ 541| 0| mem_debugging |= ISC_MEM_DEBUGUSAGE; ------------------ | | 41| 0|#define ISC_MEM_DEBUGUSAGE 0x00000004U ------------------ 542| 0| } 543| | 544| 2| isc_mem_create("default", &isc_g_mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 545| 2|} isc_mem_setdebugging: 567| 4|isc_mem_setdebugging(isc_mem_t *ctx, unsigned int debugging) { 568| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 569| 4| REQUIRE(isc_mem_inuse(ctx) == 0); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 570| | 571| 4| ctx->debugging = debugging; 572| 4|} isc__mem_get: 747| 551|isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) { 748| 551| void *ptr = NULL; 749| | 750| 551| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 551|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.10k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 551, False: 0] | | | | | Branch (42:11): [True: 551, False: 0] | | | | ------------------ | | | | 43| 551| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 751| | 752| 551| ptr = mem_get(ctx, size, flags); 753| | 754| 551| mem_getstats(ctx, size); 755| 551| ADD_TRACE(ctx, ptr, size, func, file, line); 756| | 757| 551| return ptr; 758| 551|} isc__mem_put: 761| 25|isc__mem_put(isc_mem_t *ctx, void *ptr, size_t size, int flags FLARG) { 762| 25| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 25|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 50| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 25, False: 0] | | | | | Branch (42:11): [True: 25, False: 0] | | | | ------------------ | | | | 43| 25| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 763| | 764| 25| DELETE_TRACE(ctx, ptr, size, func, file, line); 765| | 766| 25| mem_putstats(ctx, size); 767| 25| mem_put(ctx, ptr, size, flags); 768| 25|} isc__mem_allocate: 839| 263|isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) { 840| 263| void *ptr = NULL; 841| | 842| 263| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 263|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 526| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 263, False: 0] | | | | | Branch (42:11): [True: 263, False: 0] | | | | ------------------ | | | | 43| 263| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 843| | 844| 263| ptr = mem_get(ctx, size, flags); 845| | 846| | /* Recalculate the real allocated size */ 847| 263| size = sallocx(ptr, flags | ctx->jemalloc_flags); 848| | 849| 263| mem_getstats(ctx, size); 850| 263| ADD_TRACE(ctx, ptr, size, func, file, line); 851| | 852| 263| return ptr; 853| 263|} isc__mem_strdup: 947| 263|isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) { 948| 263| size_t len; 949| 263| char *ns = NULL; 950| | 951| 263| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 194| 263|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 526| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 263, False: 0] | | | | | Branch (42:11): [True: 263, False: 0] | | | | ------------------ | | | | 43| 263| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 952| 263| REQUIRE(s != NULL); ------------------ | | 194| 263|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 263| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 263, False: 0] | | | | ------------------ | | | | 43| 263| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 953| | 954| 263| len = strlen(s) + 1; 955| | 956| 263| ns = isc__mem_allocate(mctx, len, 0 FLARG_PASS); 957| | 958| 263| strlcpy(ns, s, len); 959| | 960| 263| return ns; 961| 263|} isc_mem_setdestroycheck: 985| 2|isc_mem_setdestroycheck(isc_mem_t *ctx, bool flag) { 986| 2| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 2|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 2, False: 0] | | | | | Branch (42:11): [True: 2, False: 0] | | | | ------------------ | | | | 43| 2| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 987| | 988| 2| MCTXLOCK(ctx); ------------------ | | 66| 2|#define MCTXLOCK(m) LOCK(&m->lock) | | ------------------ | | | | 26| 2| { \ | | | | 27| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | | | 28| 2| __FILE__, __LINE__)); \ | | | | 29| 2| isc_mutex_lock((lp)); \ | | | | ------------------ | | | | | | 69| 2|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | | | ------------------ | | | | | | | | 85| 2| { \ | | | | | | | | 86| 2| int _ret = pthread_mutex_lock(mp); \ | | | | | | | | 87| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 88| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 30| 2| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | | | 31| 2| __FILE__, __LINE__)); \ | | | | 32| 2| } | | ------------------ ------------------ 989| | 990| 2| ctx->checkfree = flag; 991| | 992| 2| MCTXUNLOCK(ctx); ------------------ | | 67| 2|#define MCTXUNLOCK(m) UNLOCK(&m->lock) | | ------------------ | | | | 34| 2| { \ | | | | 35| 2| isc_mutex_unlock((lp)); \ | | | | ------------------ | | | | | | 70| 2|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | | | ------------------ | | | | | | | | 91| 2| { \ | | | | | | | | 92| 2| int _ret = pthread_mutex_unlock(mp); \ | | | | | | | | 93| 2| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | | | ------------------ | | | | | | | | | | 284| 2| if ((ret) != 0) { \ | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (284:6): [True: 0, False: 2] | | | | | | | | | | ------------------ | | | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | | | 224| 0| } | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | | | 286| 0| } | | | | | | | | ------------------ | | | | | | | | 94| 2| } | | | | | | ------------------ | | | | ------------------ | | | | 36| 2| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | | | 37| 2| __FILE__, __LINE__)); \ | | | | 38| 2| } | | ------------------ ------------------ 993| 2|} isc_mem_inuse: 996| 4|isc_mem_inuse(isc_mem_t *ctx) { 997| 4| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 194| 4|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 8| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 4, False: 0] | | | | | Branch (42:11): [True: 4, False: 0] | | | | ------------------ | | | | 43| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 998| | 999| 4| int_fast64_t inuse = 0; 1000| | 1001| 8| for (ssize_t i = -1; i < isc_tid_count(); i++) { ------------------ | Branch (1001:23): [True: 4, False: 4] ------------------ 1002| 4| inuse += atomic_load_relaxed(&ctx->stat[i].inuse); ------------------ | | 28| 4|#define atomic_load_relaxed(o) atomic_load_explicit((o), memory_order_relaxed) ------------------ 1003| 4| } 1004| 4| INSIST(inuse >= 0); ------------------ | | 198| 4|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 4| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 4, False: 0] | | | | ------------------ | | | | 55| 4| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 1005| | 1006| 4| return (size_t)inuse; 1007| 4|} isc__mem_create: 1557| 10|isc__mem_create(const char *name, isc_mem_t **mctxp FLARG) { 1558| 10| mem_create(name, mctxp, mem_debugging, 0); 1559| |#if ISC_MEM_TRACKLINES 1560| | if ((mem_debugging & ISC_MEM_DEBUGTRACE) != 0) { 1561| | fprintf(stderr, "create mctx %p func %s file %s line %u\n", 1562| | *mctxp, func, file, line); 1563| | } 1564| |#endif /* ISC_MEM_TRACKLINES */ 1565| 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)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 500| 0| UNREACHABLE(); ------------------ | | 202| 0|#define UNREACHABLE() ISC_UNREACHABLE() | | ------------------ | | | | 66| 0| (isc_assertion_failed(__FILE__, __LINE__, isc_assertiontype_insist, \ | | | | 67| 0| "unreachable"), \ | | | | 68| 0| __builtin_unreachable()) | | ------------------ ------------------ 501| 6| } 502| 6|} mem.c:mem_get: 395| 814|mem_get(isc_mem_t *ctx, size_t size, int flags) { 396| 814| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 387| 814| if (s == 0) { \ | | ------------------ | | | Branch (387:6): [True: 0, False: 814] | | ------------------ | | 388| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 83| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 389| 0| } ------------------ 397| | 398| 814| void *ptr = mallocx(size, flags | ctx->jemalloc_flags); 399| 814| CHECK_OOM(ptr, size); ------------------ | | 241| 814|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (241:37): [True: 814, False: 0] | | | Branch (241:54): [True: 0, False: 0] | | ------------------ ------------------ 400| | 401| 814| return ptr; 402| 814|} mem.c:mem_getstats: 471| 814|mem_getstats(isc_mem_t *ctx, size_t size) { 472| | atomic_fetch_add_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 30| 814| atomic_fetch_add_explicit((o), (v), memory_order_relaxed) ------------------ 473| 814|} mem.c:mem_putstats: 479| 25|mem_putstats(isc_mem_t *ctx, size_t size) { 480| | atomic_fetch_sub_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 32| 25| atomic_fetch_sub_explicit((o), (v), memory_order_relaxed) ------------------ 481| 25|} mem.c:mem_put: 442| 25|mem_put(isc_mem_t *ctx, void *mem, size_t size, int flags) { 443| 25| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 387| 25| if (s == 0) { \ | | ------------------ | | | Branch (387:6): [True: 0, False: 25] | | ------------------ | | 388| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 83| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 389| 0| } ------------------ 444| | 445| 25| sdallocx(mem, size, flags | ctx->jemalloc_flags); 446| | 447| 25| freed_bytes += size; 448| | 449| 25| if (freed_bytes >= purge_threshold) { ------------------ | Branch (449:6): [True: 0, False: 25] ------------------ 450| 0| freed_bytes = 0; 451| 0| mem_purge(); 452| 0| } 453| 25|} 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); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 20| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 10, False: 0] | | | | | Branch (42:11): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 606| 10| REQUIRE(name != NULL); ------------------ | | 194| 10|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 10| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 10, False: 0] | | | | ------------------ | | | | 43| 10| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 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); \ | | | | ------------------ | | | | | | 284| 10| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 10] | | | | | | ------------------ | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | ------------------ | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | ------------------ | | | | | | | | | | 219| 0| { \ | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | ------------------ | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | ------------------ | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | 224| 0| } | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 286| 0| } | | | | ------------------ | | | | 82| 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++) { ------------------ | | 94| 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); \ | | | | | | ------------------ | | | | | | | | 284| 10| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 10] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 88| 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); \ | | | | | | ------------------ | | | | | | | | 284| 10| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 10] | | | | | | | | ------------------ | | | | | | | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | | | | | | | ------------------ | | | | | | | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | | | | | | | ------------------ | | | | | | | | | | | | 219| 0| { \ | | | | | | | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | | | | | | | ------------------ | | | | | | | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | | | | | | | 224| 0| } | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | 286| 0| } | | | | | | ------------------ | | | | | | 94| 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); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 35| |#if ISC_MUTEX_ERROR_CHECK 36| | RUNTIME_CHECK(pthread_mutexattr_settype(&isc__mutex_init_attr, 37| | PTHREAD_MUTEX_ERRORCHECK) == 0); 38| |#elif HAVE_PTHREAD_MUTEX_ADAPTIVE_NP 39| 2| RUNTIME_CHECK(pthread_mutexattr_settype(&isc__mutex_init_attr, ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 40| 2| PTHREAD_MUTEX_ADAPTIVE_NP) == 41| 2| 0); 42| 2|#endif 43| 2|} isc_os_ncpus: 199| 2|isc_os_ncpus(void) { 200| 2| return isc__os_ncpus; 201| 2|} isc__os_initialize: 222| 2|isc__os_initialize(void) { 223| 2| umask_initialize(); 224| 2| ncpus_initialize(); 225| 2| kernel_initialize(); 226| 2|#if defined(_SC_LEVEL1_DCACHE_LINESIZE) 227| 2| long s = sysconf(_SC_LEVEL1_DCACHE_LINESIZE); 228| 2| if (s > 0 && (unsigned long)s > isc__os_cacheline) { ------------------ | Branch (228:6): [True: 2, False: 0] | Branch (228:15): [True: 0, False: 2] ------------------ 229| 0| isc__os_cacheline = s; 230| 0| } 231| 2|#endif 232| | 233| 2| pthread_attr_init(&isc__thread_attr); 234| | 235| 2| size_t stacksize = isc_thread_getstacksize(); 236| 2| if (stacksize != 0 && stacksize < THREAD_MINSTACKSIZE) { ------------------ | | 29| 2|#define THREAD_MINSTACKSIZE (1U * 1024 * 1024) ------------------ | Branch (236:6): [True: 2, False: 0] | Branch (236:24): [True: 0, False: 2] ------------------ 237| 0| isc_thread_setstacksize(THREAD_MINSTACKSIZE); ------------------ | | 29| 0|#define THREAD_MINSTACKSIZE (1U * 1024 * 1024) ------------------ 238| 0| } 239| 2|} os.c:umask_initialize: 180| 2|umask_initialize(void) { 181| 2| isc__os_umask = umask(0); 182| 2| (void)umask(isc__os_umask); 183| 2|} os.c:ncpus_initialize: 42| 2|ncpus_initialize(void) { 43| 2| isc__os_ncpus = uv_available_parallelism(); 44| 2|} os.c:kernel_initialize: 186| 2|kernel_initialize(void) { 187| 2| struct utsname buffer; 188| | 189| 2| if (uname(&buffer) == -1) { ------------------ | Branch (189:6): [True: 0, False: 2] ------------------ 190| 0| return; 191| 0| } 192| | 193| 2| (void)sscanf(buffer.release, "%d.%d.%d", &kernel_major, &kernel_minor, 194| 2| &kernel_patch); 195| 2| (void)strlcpy(kernel_name, buffer.sysname, sizeof(kernel_name)); 196| 2|} isc_ossl_wrap_load_rsa_public_from_components: 702| 12| EVP_PKEY **pkeyp) { 703| 12| OSSL_PARAM_BLD *bld = NULL; 704| 12| EVP_PKEY_CTX *pctx = NULL; 705| 12| OSSL_PARAM *params = NULL; 706| 12| isc_result_t result; 707| | 708| 12| result = ISC_R_SUCCESS; 709| | 710| 12| REQUIRE(pkeyp != NULL && *pkeyp == NULL); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 24| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 12, False: 0] | | | | | Branch (42:11): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 711| 12| REQUIRE(c != NULL && c->n != NULL && c->e != NULL); ------------------ | | 194| 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))) | | ------------------ ------------------ 712| | 713| 12| bld = OSSL_PARAM_BLD_new(); 714| 12| if (bld == NULL) { ------------------ | Branch (714:6): [True: 0, False: 12] ------------------ 715| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_new")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 716| 0| } 717| | 718| 12| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, c->n) != 1) { ------------------ | Branch (718:6): [True: 0, False: 12] ------------------ 719| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_push_BN")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 720| 0| } 721| | 722| 12| if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, c->e) != 1) { ------------------ | Branch (722:6): [True: 0, False: 12] ------------------ 723| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_push_BN")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 724| 0| } 725| | 726| 12| params = OSSL_PARAM_BLD_to_param(bld); 727| 12| if (params == NULL) { ------------------ | Branch (727:6): [True: 0, False: 12] ------------------ 728| 0| CLEANUP(OSSL_WRAP_ERROR("OSSL_PARAM_BLD_to_param")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 729| 0| } 730| | 731| 12| pctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); 732| 12| if (pctx == NULL) { ------------------ | Branch (732:6): [True: 0, False: 12] ------------------ 733| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_CTX_new_from_name")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 734| 0| } 735| | 736| 12| if (EVP_PKEY_fromdata_init(pctx) != 1) { ------------------ | Branch (736:6): [True: 0, False: 12] ------------------ 737| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_fromdata_init")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 738| 0| } 739| | 740| 12| if (EVP_PKEY_fromdata(pctx, pkeyp, EVP_PKEY_PUBLIC_KEY, params) != 1) { ------------------ | Branch (740:6): [True: 0, False: 12] ------------------ 741| 0| CLEANUP(OSSL_WRAP_ERROR("EVP_PKEY_fromdata")); ------------------ | | 262| 0| { \ | | 263| 0| result = (r); \ | | 264| 0| goto cleanup; \ | | 265| 0| } ------------------ 742| 0| } 743| | 744| 12| result = ISC_R_SUCCESS; 745| | 746| 12|cleanup: 747| 12| EVP_PKEY_CTX_free(pctx); 748| 12| OSSL_PARAM_free(params); 749| 12| OSSL_PARAM_BLD_free(bld); 750| 12| return result; 751| 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); ------------------ | | 194| 12|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 12| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 12, False: 0] | | | | ------------------ | | | | 43| 12| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 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_rwlock_init: 293| 2.05k|isc_rwlock_init(isc_rwlock_t *rwl) { 294| 2.05k| REQUIRE(rwl != NULL); ------------------ | | 194| 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))) | | ------------------ ------------------ 295| | 296| 2.05k| atomic_init(&rwl->writers_lock, ISC_RWLOCK_UNLOCKED); ------------------ | | 69| 2.05k|#define ISC_RWLOCK_UNLOCKED false ------------------ 297| 2.05k| atomic_init(&rwl->writers_barrier, 0); 298| 2.05k| atomic_init(&rwl->readers_ingress, 0); 299| | atomic_init(&rwl->readers_egress, 0); 300| 2.05k| LIBISC_RWLOCK_INIT(rwl); 301| 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); ------------------ | | 284| 2| if ((ret) != 0) { \ | | ------------------ | | | Branch (284:6): [True: 0, False: 2] | | ------------------ | | 285| 0| FATAL_SYSERROR(ret, "%s()", #func); \ | | ------------------ | | | | 230| 0| REPORT_SYSERROR(isc_error_fatal, err, __VA_ARGS__) | | | | ------------------ | | | | | | 219| 0| { \ | | | | | | 220| 0| char strerr[ISC_STRERRORSIZE]; \ | | | | | | 221| 0| strerror_r(err, strerr, sizeof(strerr)); \ | | | | | | ------------------ | | | | | | | | 33| 0|#define strerror_r isc_string_strerror_r | | | | | | ------------------ | | | | | | 222| 0| report(__FILE__, __LINE__, __func__, fmt ": %s (%d)", \ | | | | | | 223| 0| ##__VA_ARGS__, strerr, err); \ | | | | | | 224| 0| } | | | | ------------------ | | ------------------ | | 286| 0| } ------------------ 177| 2|#endif /* HAVE_PTHREAD_ATTR_GETSTACKSIZE */ 178| | 179| 2| return stacksize; 180| 2|} isc_tid_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); ------------------ | | 241| 2| ((cond) ? (void)0 : FATAL_ERROR("RUNTIME_CHECK(%s) failed", #cond)) | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | | Branch (241:3): [True: 2, False: 0] | | ------------------ ------------------ 143| 2| if (fd > STDERR_FILENO) { ------------------ | Branch (143:7): [True: 2, False: 0] ------------------ 144| 2| close(fd); 145| 2| break; 146| 2| } 147| 2| } while (true); ------------------ | Branch (147:11): [True: 0, Folded] ------------------ 148| 2|#if UV_VERSION_HEX >= UV_VERSION(1, 38, 0) 149| 2| int r; 150| 2| isc_mem_create("uv", &isc__uv_mctx); ------------------ | | 200| 2|#define isc_mem_create(name, cp) isc__mem_create((name), (cp)_ISC_MEM_FILELINE) ------------------ 151| 2| isc_mem_setdebugging(isc__uv_mctx, 0); 152| 2| isc_mem_setdestroycheck(isc__uv_mctx, false); 153| | 154| 2| r = uv_replace_allocator(isc__uv_malloc, isc__uv_realloc, 155| 2| isc__uv_calloc, isc__uv_free); 156| 2| UV_RUNTIME_CHECK(uv_replace_allocator, r); ------------------ | | 50| 2| if (ret != 0) { \ | | ------------------ | | | Branch (50:6): [True: 0, False: 2] | | ------------------ | | 51| 0| FATAL_ERROR("%s failed: %s\n", #func, uv_strerror(ret)); \ | | ------------------ | | | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) | | ------------------ | | 52| 0| } ------------------ 157| 2|#endif /* UV_VERSION_HEX >= UV_VERSION(1, 38, 0) */ 158| 2|} 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|}