LLVMFuzzerInitialize: 32| 2|LLVMFuzzerInitialize(int *argc ISC_ATTR_UNUSED, char ***argv ISC_ATTR_UNUSED) { 33| 2| return 0; 34| 2|} LLVMFuzzerTestOneInput: 37| 172|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 38| 172| isc_result_t new_result; 39| 172| isc_result_t old_result; 40| 172| dns_fixedname_t new_fixed; 41| 172| dns_fixedname_t old_fixed; 42| 172| dns_name_t *new_name = dns_fixedname_initname(&new_fixed); 43| 172| dns_name_t *old_name = dns_fixedname_initname(&old_fixed); 44| 172| dns_decompress_t dctx = DNS_DECOMPRESS_PERMITTED; 45| 172| isc_buffer_t new_buf; 46| 172| isc_buffer_t old_buf; 47| | 48| | /* 49| | * Output buffers may be partially used or undersized. 50| | */ 51| 172| if (size > 0) { ------------------ | Branch (51:6): [True: 172, False: 0] ------------------ 52| 172| uint8_t add = *data++; 53| 172| size--; 54| 172| isc_buffer_add(&new_fixed.buffer, add); 55| 172| isc_buffer_add(&old_fixed.buffer, add); 56| 172| } 57| | 58| | /* 59| | * timeout faster if we hit a pointer loop 60| | */ 61| 172| alarm(1); 62| | 63| | /* 64| | * We shift forward by half the input data to make an area 65| | * that pointers can refer back to. 66| | */ 67| | 68| 172| isc_buffer_constinit(&new_buf, data, size); ------------------ | | 557| 172| do { \ | | 558| 172| union { \ | | 559| 172| void *_var; \ | | 560| 172| const void *_const; \ | | 561| 172| } _deconst; \ | | 562| 172| _deconst._const = (_d); \ | | 563| 172| isc_buffer_init((_b), _deconst._var, (_l)); \ | | 564| 172| } while (0) | | ------------------ | | | Branch (564:11): [Folded, False: 172] | | ------------------ ------------------ 69| 172| isc_buffer_add(&new_buf, size); 70| 172| isc_buffer_setactive(&new_buf, size); 71| 172| isc_buffer_forward(&new_buf, size / 2); 72| 172| new_result = dns_name_fromwire(new_name, &new_buf, dctx, NULL); 73| | 74| 172| isc_buffer_constinit(&old_buf, data, size); ------------------ | | 557| 172| do { \ | | 558| 172| union { \ | | 559| 172| void *_var; \ | | 560| 172| const void *_const; \ | | 561| 172| } _deconst; \ | | 562| 172| _deconst._const = (_d); \ | | 563| 172| isc_buffer_init((_b), _deconst._var, (_l)); \ | | 564| 172| } while (0) | | ------------------ | | | Branch (564:11): [Folded, False: 172] | | ------------------ ------------------ 75| 172| isc_buffer_add(&old_buf, size); 76| 172| isc_buffer_setactive(&old_buf, size); 77| 172| isc_buffer_forward(&old_buf, size / 2); 78| 172| old_result = old_name_fromwire(old_name, &old_buf, dctx, 0, NULL); 79| | 80| 172| REQUIRE(new_result == old_result); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 81| 172| REQUIRE(dns_name_equal(new_name, old_name)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 82| | 83| 172| REQUIRE(new_fixed.buffer.current == old_fixed.buffer.current); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 84| 172| REQUIRE(new_fixed.buffer.active == old_fixed.buffer.active); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 85| 172| REQUIRE(new_fixed.buffer.used == old_fixed.buffer.used); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 86| 172| REQUIRE(new_fixed.buffer.length == old_fixed.buffer.length); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 87| | 88| 172| REQUIRE(new_buf.base == old_buf.base); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 89| 172| REQUIRE(new_buf.current == old_buf.current); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 90| 172| REQUIRE(new_buf.active == old_buf.active); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 91| 172| REQUIRE(new_buf.used == old_buf.used); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 92| 172| REQUIRE(new_buf.length == old_buf.length); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 93| | 94| 172| return 0; 95| 172|} old_name_fromwire: 50| 172| unsigned int options, isc_buffer_t *target) { 51| 172| unsigned char *cdata, *ndata; 52| 172| unsigned int cused; /* Bytes of compressed name data used */ 53| 172| unsigned int nused, labels, n, nmax; 54| 172| unsigned int current, new_current, biggest_pointer; 55| 172| bool done; 56| 172| fw_state state = fw_start; 57| 172| unsigned int c; 58| 172| unsigned char *offsets; 59| 172| dns_offsets_t odata; 60| 172| bool downcase; 61| 172| bool seen_pointer; 62| | 63| | /* 64| | * Copy the possibly-compressed name at source into target, 65| | * decompressing it. Loop prevention is performed by checking 66| | * the new pointer against biggest_pointer. 67| | */ 68| | 69| 172| REQUIRE(VALID_NAME(name)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 70| 172| REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) || ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 172] | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 71| 172| (target == NULL && ISC_BUFFER_VALID(name->buffer))); 72| | 73| 172| downcase = ((options & DNS_NAME_DOWNCASE) != 0); ------------------ | | 134| 172|#define DNS_NAME_DOWNCASE 0x0001 ------------------ 74| | 75| 172| if (target == NULL && name->buffer != NULL) { ------------------ | Branch (75:6): [True: 172, False: 0] | Branch (75:24): [True: 172, False: 0] ------------------ 76| 172| target = name->buffer; 77| 172| isc_buffer_clear(target); 78| 172| } 79| | 80| 172| REQUIRE(BINDABLE(name)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 81| | 82| 172| INIT_OFFSETS(name, offsets, odata); ------------------ | | 37| 172|#define INIT_OFFSETS(name, var, default_offsets) (var) = (default_offsets) ------------------ 83| | 84| | /* 85| | * Make 'name' empty in case of failure. 86| | */ 87| 172| MAKE_EMPTY(name); ------------------ | | 40| 172| do { \ | | 41| 172| name->ndata = NULL; \ | | 42| 172| name->length = 0; \ | | 43| 172| name->attributes.absolute = false; \ | | 44| 172| } while (0) | | ------------------ | | | Branch (44:11): [Folded, False: 172] | | ------------------ ------------------ 88| | 89| | /* 90| | * Initialize things to make the compiler happy; they're not required. 91| | */ 92| 172| n = 0; 93| 172| new_current = 0; 94| | 95| | /* 96| | * Set up. 97| | */ 98| 172| labels = 0; 99| 172| done = false; 100| | 101| 172| ndata = isc_buffer_used(target); ------------------ | | 149| 172| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 102| 172| nused = 0; 103| 172| seen_pointer = false; 104| | 105| | /* 106| | * Find the maximum number of uncompressed target name 107| | * bytes we are willing to generate. This is the smaller 108| | * of the available target buffer length and the 109| | * maximum legal domain name length (255). 110| | */ 111| 172| nmax = isc_buffer_availablelength(target); ------------------ | | 161| 172|#define isc_buffer_availablelength(b) ((b)->length - (b)->used) /* e-d */ ------------------ 112| 172| if (nmax > DNS_NAME_MAXWIRE) { ------------------ | | 190| 172|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (112:6): [True: 0, False: 172] ------------------ 113| 0| nmax = DNS_NAME_MAXWIRE; ------------------ | | 190| 0|#define DNS_NAME_MAXWIRE 255 ------------------ 114| 0| } 115| | 116| 172| cdata = isc_buffer_current(source); ------------------ | | 145| 172| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 117| 172| cused = 0; 118| | 119| 172| current = source->current; 120| 172| biggest_pointer = current; 121| | 122| | /* 123| | * Note: The following code is not optimized for speed, but 124| | * rather for correctness. Speed will be addressed in the future. 125| | */ 126| | 127| 11.9k| while (current < source->active && !done) { ------------------ | Branch (127:9): [True: 11.8k, False: 65] | Branch (127:37): [True: 11.8k, False: 47] ------------------ 128| 11.8k| c = *cdata++; 129| 11.8k| current++; 130| 11.8k| if (!seen_pointer) { ------------------ | Branch (130:7): [True: 6.48k, False: 5.34k] ------------------ 131| 6.48k| cused++; 132| 6.48k| } 133| | 134| 11.8k| switch (state) { 135| 3.30k| case fw_start: ------------------ | Branch (135:3): [True: 3.30k, False: 8.52k] ------------------ 136| 3.30k| if (c < 64) { ------------------ | Branch (136:8): [True: 2.94k, False: 364] ------------------ 137| 2.94k| offsets[labels] = nused; 138| 2.94k| labels++; 139| 2.94k| if (nused + c + 1 > nmax) { ------------------ | Branch (139:9): [True: 16, False: 2.92k] ------------------ 140| 16| goto full; 141| 16| } 142| 2.92k| nused += c + 1; 143| 2.92k| *ndata++ = c; 144| 2.92k| if (c == 0) { ------------------ | Branch (144:9): [True: 66, False: 2.85k] ------------------ 145| 66| done = true; 146| 66| } 147| 2.92k| n = c; 148| 2.92k| state = fw_ordinary; 149| 2.92k| } else if (c >= 192) { ------------------ | Branch (149:15): [True: 345, False: 19] ------------------ 150| | /* 151| | * 14-bit compression pointer 152| | */ 153| 345| if (!dns_decompress_getpermitted(dctx)) { ------------------ | Branch (153:9): [True: 0, False: 345] ------------------ 154| 0| return DNS_R_DISALLOWED; 155| 0| } 156| 345| new_current = c & 0x3F; 157| 345| state = fw_newcurrent; 158| 345| } else { 159| 19| return DNS_R_BADLABELTYPE; 160| 19| } 161| 3.27k| break; 162| 8.18k| case fw_ordinary: ------------------ | Branch (162:3): [True: 8.18k, False: 3.64k] ------------------ 163| 8.18k| if (downcase) { ------------------ | Branch (163:8): [True: 0, False: 8.18k] ------------------ 164| 0| c = isc_ascii_tolower(c); ------------------ | | 31| 0|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ 165| 0| } 166| 8.18k| *ndata++ = c; 167| 8.18k| n--; 168| 8.18k| if (n == 0) { ------------------ | Branch (168:8): [True: 2.82k, False: 5.35k] ------------------ 169| 2.82k| state = fw_start; 170| 2.82k| } 171| 8.18k| break; 172| 342| case fw_newcurrent: ------------------ | Branch (172:3): [True: 342, False: 11.4k] ------------------ 173| 342| new_current *= 256; 174| 342| new_current += c; 175| 342| if (new_current >= biggest_pointer) { ------------------ | Branch (175:8): [True: 25, False: 317] ------------------ 176| 25| return DNS_R_BADPOINTER; 177| 25| } 178| 317| biggest_pointer = new_current; 179| 317| current = new_current; 180| 317| cdata = (unsigned char *)source->base + current; 181| 317| seen_pointer = true; 182| 317| state = fw_start; 183| 317| break; 184| 0| default: ------------------ | Branch (184:3): [True: 0, False: 11.8k] ------------------ 185| 0| FATAL_ERROR("Unknown state %d", state); ------------------ | | 216| 0| isc_error_fatal(__FILE__, __LINE__, __func__, __VA_ARGS__) ------------------ 186| | /* Does not return. */ 187| 11.8k| } 188| 11.8k| } 189| | 190| 112| if (!done) { ------------------ | Branch (190:6): [True: 46, False: 66] ------------------ 191| 46| return ISC_R_UNEXPECTEDEND; 192| 46| } 193| | 194| 66| name->ndata = (unsigned char *)target->base + target->used; 195| 66| name->length = nused; 196| 66| name->attributes.absolute = true; 197| | 198| 66| isc_buffer_forward(source, cused); 199| 66| isc_buffer_add(target, name->length); 200| | 201| 66| return ISC_R_SUCCESS; 202| | 203| 16|full: 204| 16| if (nmax == DNS_NAME_MAXWIRE) { ------------------ | | 190| 16|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (204:6): [True: 16, False: 0] ------------------ 205| | /* 206| | * The name did not fit even though we had a buffer 207| | * big enough to fit a maximum-length name. 208| | */ 209| 16| return DNS_R_NAMETOOLONG; 210| 16| } else { 211| | /* 212| | * The name might fit if only the caller could give us a 213| | * big enough buffer. 214| | */ 215| 0| return ISC_R_NOSPACE; 216| 0| } 217| 16|} 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_fixedname_init: 19| 344|dns_fixedname_init(dns_fixedname_t *fixed) { 20| 344| dns_name_init(&fixed->name); 21| 344| isc_buffer_init(&fixed->buffer, fixed->data, DNS_NAME_MAXWIRE); ------------------ | | 190| 344|#define DNS_NAME_MAXWIRE 255 ------------------ 22| 344| dns_name_setbuffer(&fixed->name, &fixed->buffer); 23| 344|} dns_fixedname_name: 31| 344|dns_fixedname_name(dns_fixedname_t *fixed) { 32| 344| return &fixed->name; 33| 344|} dns_fixedname_initname: 36| 344|dns_fixedname_initname(dns_fixedname_t *fixed) { 37| 344| dns_fixedname_init(fixed); 38| 344| return dns_fixedname_name(fixed); 39| 344|} old.c:dns_decompress_getpermitted: 251| 345|dns_decompress_getpermitted(dns_decompress_t dctx) { 252| 345| return dctx == DNS_DECOMPRESS_ALWAYS || ------------------ | Branch (252:9): [True: 0, False: 345] ------------------ 253| 345| dctx == DNS_DECOMPRESS_PERMITTED; ------------------ | Branch (253:9): [True: 345, False: 0] ------------------ 254| 345|} name.c:dns_decompress_getpermitted: 251| 345|dns_decompress_getpermitted(dns_decompress_t dctx) { 252| 345| return dctx == DNS_DECOMPRESS_ALWAYS || ------------------ | Branch (252:9): [True: 0, False: 345] ------------------ 253| 345| dctx == DNS_DECOMPRESS_PERMITTED; ------------------ | Branch (253:9): [True: 345, False: 0] ------------------ 254| 345|} dns_lib_initialize: 36| 2|dns_lib_initialize(void) { 37| 2| isc__lib_initialize(); 38| 2| dns__lib_initialize(); 39| 2|} fixedname.c:dns_name_init: 209| 344|dns_name_init(dns_name_t *name) { 210| 344| *name = (dns_name_t){ 211| 344| .magic = DNS_NAME_MAGIC, ------------------ | | 121| 344|#define DNS_NAME_MAGIC ISC_MAGIC('D', 'N', 'S', 'n') | | ------------------ | | | | 31| 344|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 212| 344| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 344|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 344| { \ | | | | 27| 344| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 344|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 344| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 344|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 344| } | | ------------------ ------------------ 213| | .list = ISC_LIST_INITIALIZER, ------------------ | | 21| 344| { \ | | 22| 344| .head = NULL, \ | | 23| 344| .tail = NULL, \ | | 24| 344| } ------------------ 214| 344| }; 215| 344|} fixedname.c:dns_name_setbuffer: 298| 344|dns_name_setbuffer(dns_name_t *name, isc_buffer_t *buffer) { 299| 344| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 688| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 344, False: 0] | | | | | Branch (42:11): [True: 344, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 300| 344| REQUIRE((buffer != NULL && name->buffer == NULL) || (buffer == NULL)); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.03k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 344, False: 0] | | | | | Branch (42:11): [True: 344, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 301| | 302| 344| name->buffer = buffer; 303| 344|} 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|} dns_name_equal: 437| 172|dns_name_equal(const dns_name_t *name1, const dns_name_t *name2) { 438| 172| unsigned int length; 439| | 440| | /* 441| | * Are 'name1' and 'name2' equal? 442| | * 443| | * Note: It makes no sense for one of the names to be relative and the 444| | * other absolute. If both names are relative, then to be meaningfully 445| | * compared the caller must ensure that they are both relative to the 446| | * same domain. 447| | */ 448| | 449| 172| REQUIRE(DNS_NAME_VALID(name1)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 450| 172| REQUIRE(DNS_NAME_VALID(name2)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 451| | /* 452| | * Either name1 is absolute and name2 is absolute, or neither is. 453| | */ 454| 172| REQUIRE((name1->attributes.absolute) == (name2->attributes.absolute)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 172| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 455| | 456| 172| if (name1 == name2) { ------------------ | Branch (456:6): [True: 0, False: 172] ------------------ 457| 0| return true; 458| 0| } 459| | 460| 172| length = name1->length; 461| 172| if (length != name2->length) { ------------------ | Branch (461:6): [True: 0, False: 172] ------------------ 462| 0| return false; 463| 0| } 464| | 465| | /* label lengths are < 64 so tolower() does not affect them */ 466| 172| return isc_ascii_lowerequal(name1->ndata, name2->ndata, length); 467| 172|} dns_name_fromwire: 1270| 172| const dns_decompress_t dctx, isc_buffer_t *target) { 1271| | /* 1272| | * Copy the name at source into target, decompressing it. 1273| | * 1274| | * *** WARNING *** 1275| | * 1276| | * dns_name_fromwire() deals with raw network data. An error in this 1277| | * routine could result in the failure or hijacking of the server. 1278| | * 1279| | * The description of name compression in RFC 1035 section 4.1.4 is 1280| | * subtle wrt certain edge cases. The first important sentence is: 1281| | * 1282| | * > In this scheme, an entire domain name or a list of labels at the 1283| | * > end of a domain name is replaced with a pointer to a prior 1284| | * > occurrence of the same name. 1285| | * 1286| | * The key word is "prior". This says that compression pointers must 1287| | * point strictly earlier in the message (before our "marker" variable), 1288| | * which is enough to prevent DoS attacks due to compression loops. 1289| | * 1290| | * The next important sentence is: 1291| | * 1292| | * > If a domain name is contained in a part of the message subject to a 1293| | * > length field (such as the RDATA section of an RR), and compression 1294| | * > is used, the length of the compressed name is used in the length 1295| | * > calculation, rather than the length of the expanded name. 1296| | * 1297| | * When decompressing, this means that the amount of the source buffer 1298| | * that we consumed (which is checked wrt the container's length field) 1299| | * is the length of the compressed name. A compressed name is defined as 1300| | * a sequence of labels ending with the root label or a compression 1301| | * pointer, that is, the segment of the name that dns_name_fromwire() 1302| | * examines first. 1303| | * 1304| | * This matters when handling names that play dirty tricks, like: 1305| | * 1306| | * +---+---+---+---+---+---+ 1307| | * | 4 | 1 |'a'|192| 0 | 0 | 1308| | * +---+---+---+---+---+---+ 1309| | * 1310| | * We start at octet 1. There is an ordinary single character label "a", 1311| | * followed by a compression pointer that refers back to octet zero. 1312| | * Here there is a label of length 4, which weirdly re-uses the octets 1313| | * we already examined as the data for the label. It is followed by the 1314| | * root label, 1315| | * 1316| | * The specification says that the compressed name ends after the first 1317| | * zero octet (after the compression pointer) not the second zero octet, 1318| | * even though the second octet is later in the message. This shows the 1319| | * correct way to set our "consumed" variable. 1320| | */ 1321| | 1322| 172| REQUIRE(DNS_NAME_VALID(name)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1323| 172| REQUIRE(DNS_NAME_BINDABLE(name)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1324| 172| REQUIRE((target != NULL && ISC_BUFFER_VALID(target)) || ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.20k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 0] | | | | | Branch (42:11): [True: 0, False: 172] | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 1325| 172| (target == NULL && ISC_BUFFER_VALID(name->buffer))); 1326| | 1327| 172| if (target == NULL && name->buffer != NULL) { ------------------ | Branch (1327:6): [True: 172, False: 0] | Branch (1327:24): [True: 172, False: 0] ------------------ 1328| 172| target = name->buffer; 1329| 172| isc_buffer_clear(target); 1330| 172| } 1331| | 1332| 172| uint8_t *const name_buf = isc_buffer_used(target); ------------------ | | 149| 172| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1333| 172| const uint32_t name_max = ISC_MIN(DNS_NAME_MAXWIRE, ------------------ | | 73| 172|#define ISC_MIN(a, b) ((a) < (b) ? (a) : (b)) | | ------------------ | | | Branch (73:24): [True: 0, False: 172] | | ------------------ ------------------ 1334| 172| isc_buffer_availablelength(target)); 1335| 172| uint32_t name_len = 0; 1336| | 1337| | /* 1338| | * After chasing a compression pointer, these variables refer to the 1339| | * source buffer as follows: 1340| | * 1341| | * sb --- mr --- cr --- st --- cd --- sm 1342| | * 1343| | * sb = source_buf (const) 1344| | * mr = marker 1345| | * cr = cursor 1346| | * st = start (const) 1347| | * cd = consumed 1348| | * sm = source_max (const) 1349| | * 1350| | * The marker hops backwards for each pointer. 1351| | * The cursor steps forwards for each label. 1352| | * The amount of the source we consumed is set once. 1353| | */ 1354| 172| const uint8_t *const source_buf = isc_buffer_base(source); ------------------ | | 143| 172|#define isc_buffer_base(b) ((void *)(b)->base) /*a*/ ------------------ 1355| 172| const uint8_t *const source_max = isc_buffer_used(source); ------------------ | | 149| 172| ((void *)((unsigned char *)(b)->base + (b)->used)) /*d*/ ------------------ 1356| 172| const uint8_t *const start = isc_buffer_current(source); ------------------ | | 145| 172| ((void *)((unsigned char *)(b)->base + (b)->current)) /*b*/ ------------------ 1357| 172| const uint8_t *marker = start; 1358| 172| const uint8_t *cursor = start; 1359| 172| const uint8_t *consumed = NULL; 1360| | 1361| | /* 1362| | * One iteration per label. 1363| | */ 1364| 3.35k| while (cursor < source_max) { ------------------ | Branch (1364:9): [True: 3.30k, False: 46] ------------------ 1365| 3.30k| const uint8_t label_len = *cursor++; 1366| 3.30k| if (label_len <= DNS_NAME_LABELLEN) { ------------------ | | 192| 3.30k|#define DNS_NAME_LABELLEN 63 ------------------ | Branch (1366:7): [True: 2.94k, False: 364] ------------------ 1367| | /* 1368| | * Normal label: record its offset, and check bounds on 1369| | * the name length, which also ensures we don't overrun 1370| | * the offsets array. Don't touch any source bytes yet! 1371| | * The source bounds check will happen when we loop. 1372| | */ 1373| | /* and then a step to the ri-i-i-i-i-ight */ 1374| 2.94k| cursor += label_len; 1375| 2.94k| name_len += label_len + 1; 1376| 2.94k| if (name_len > name_max) { ------------------ | Branch (1376:8): [True: 16, False: 2.92k] ------------------ 1377| 16| return name_max == DNS_NAME_MAXWIRE ------------------ | | 190| 16|#define DNS_NAME_MAXWIRE 255 ------------------ | Branch (1377:12): [True: 16, False: 0] ------------------ 1378| 16| ? DNS_R_NAMETOOLONG 1379| 16| : ISC_R_NOSPACE; 1380| 2.92k| } else if (label_len == 0) { ------------------ | Branch (1380:15): [True: 66, False: 2.85k] ------------------ 1381| 66| goto root_label; 1382| 66| } 1383| 2.94k| } else if (label_len < 192) { ------------------ | Branch (1383:14): [True: 19, False: 345] ------------------ 1384| 19| return DNS_R_BADLABELTYPE; 1385| 345| } else if (!dns_decompress_getpermitted(dctx)) { ------------------ | Branch (1385:14): [True: 0, False: 345] ------------------ 1386| 0| return DNS_R_DISALLOWED; 1387| 345| } else if (cursor < source_max) { ------------------ | Branch (1387:14): [True: 342, False: 3] ------------------ 1388| | /* 1389| | * Compression pointer. Ensure it does not loop. 1390| | * 1391| | * Copy multiple labels in one go, to make the most of 1392| | * memmove() performance. Start at the marker and finish 1393| | * just before the pointer's hi+lo bytes, before the 1394| | * cursor. Bounds were already checked. 1395| | */ 1396| 342| const uint32_t hi = label_len & 0x3F; 1397| 342| const uint32_t lo = *cursor++; 1398| 342| const uint8_t *pointer = source_buf + (256 * hi + lo); 1399| 342| if (pointer >= marker) { ------------------ | Branch (1399:8): [True: 25, False: 317] ------------------ 1400| 25| return DNS_R_BADPOINTER; 1401| 25| } 1402| 317| const uint32_t copy_len = (cursor - 2) - marker; 1403| 317| uint8_t *const dest = name_buf + name_len - copy_len; 1404| 317| memmove(dest, marker, copy_len); 1405| 317| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1405:15): [True: 229, False: 88] ------------------ 1406| | /* it's just a jump to the left */ 1407| 317| cursor = marker = pointer; 1408| 317| } 1409| 3.30k| } 1410| 46| return ISC_R_UNEXPECTEDEND; 1411| 66|root_label:; 1412| | /* 1413| | * Copy labels almost like we do for compression pointers, 1414| | * from the marker up to and including the root label. 1415| | */ 1416| 66| const uint32_t copy_len = cursor - marker; 1417| 66| memmove(name_buf + name_len - copy_len, marker, copy_len); 1418| 66| consumed = consumed != NULL ? consumed : cursor; ------------------ | Branch (1418:13): [True: 35, False: 31] ------------------ 1419| 66| isc_buffer_forward(source, consumed - start); 1420| | 1421| 66| name->attributes.absolute = true; 1422| 66| name->ndata = name_buf; 1423| 66| name->length = name_len; 1424| 66| isc_buffer_add(target, name_len); 1425| | 1426| 66| return ISC_R_SUCCESS; 1427| 172|} 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|} name.c:isc_ascii_tolower8: 71| 1.16k|isc_ascii_tolower8(uint64_t octets) { 72| | /* 73| | * Multiply a single-byte constant by `all_bytes` to replicate 74| | * it to all eight bytes in a word. 75| | */ 76| 1.16k| uint64_t all_bytes = 0x0101010101010101; 77| | /* 78| | * Clear the top bit of each byte to make space for a per-byte flag. 79| | */ 80| 1.16k| uint64_t heptets = octets & (0x7F * all_bytes); 81| | /* 82| | * We will need to avoid going wrong if our flag bits were originally 83| | * set, and clear calculation leftovers in our non-flag bits 84| | */ 85| 1.16k| uint64_t is_ascii = ~octets & (0x80 * all_bytes); 86| | /* 87| | * To compare a heptet to `N`, we can add `0x7F - N` so that carry 88| | * propagation will set the flag when our heptet is greater than `N` 89| | */ 90| 1.16k| uint64_t is_gt_Z = heptets + (0x7F - 'Z') * all_bytes; 91| | /* 92| | * Add one for greater-than-or-equal comparison 93| | */ 94| 1.16k| uint64_t is_ge_A = heptets + (0x80 - 'A') * all_bytes; 95| | /* 96| | * Now we have what we need to identify the ascii uppercase bytes 97| | */ 98| 1.16k| uint64_t is_upper = (is_ge_A ^ is_gt_Z) & is_ascii; 99| | /* 100| | * Move the is_upper flag bits to bit 0x20 (which is 'a' - 'A') 101| | * and use them to adjust each byte as required 102| | */ 103| 1.16k| return octets | (is_upper >> 2); 104| 1.16k|} name.c:isc__ascii_load8: 124| 1.16k|isc__ascii_load8(const uint8_t *ptr) { 125| 1.16k| uint64_t bytes = 0; 126| 1.16k| memmove(&bytes, ptr, sizeof(bytes)); 127| 1.16k| return bytes; 128| 1.16k|} name.c:isc_ascii_lowerequal: 135| 172| unsigned int len) { 136| 172| uint64_t a8 = 0, b8 = 0; 137| 172| if (len >= 8) { ------------------ | Branch (137:6): [True: 38, False: 134] ------------------ 138| 38| const uint8_t *a_tail = a + len - 8; 139| 38| const uint8_t *b_tail = b + len - 8; 140| 583| while (len >= 8) { ------------------ | Branch (140:10): [True: 545, False: 38] ------------------ 141| 545| a8 = isc_ascii_tolower8(isc__ascii_load8(a)); 142| 545| b8 = isc_ascii_tolower8(isc__ascii_load8(b)); 143| 545| if (a8 != b8) { ------------------ | Branch (143:8): [True: 0, False: 545] ------------------ 144| 0| return false; 145| 0| } 146| 545| len -= 8; 147| 545| a += 8; 148| 545| b += 8; 149| 545| } 150| | 151| 38| a8 = isc_ascii_tolower8(isc__ascii_load8(a_tail)); 152| 38| b8 = isc_ascii_tolower8(isc__ascii_load8(b_tail)); 153| 38| return a8 == b8; 154| 38| } 155| | 156| 196| while (len-- > 0) { ------------------ | Branch (156:9): [True: 62, False: 134] ------------------ 157| 62| if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 62|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ if (isc_ascii_tolower(*a++) != isc_ascii_tolower(*b++)) { ------------------ | | 31| 62|#define isc_ascii_tolower(c) isc__ascii_tolower[(uint8_t)(c)] ------------------ | Branch (157:7): [True: 0, False: 62] ------------------ 158| 0| return false; 159| 0| } 160| 62| } 161| 134| return true; 162| 134|} dns_name_fromwire.c:isc_buffer_add: 652| 688|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 688| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 688|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 1.37k| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 688, False: 0] | | | | | Branch (42:11): [True: 688, False: 0] | | | | ------------------ | | | | 43| 688| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 688| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 688|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 688| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 688, False: 0] | | | | ------------------ | | | | 43| 688| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 688| b->used += n; 657| 688|} dns_name_fromwire.c:isc_buffer_init: 524| 344| const unsigned int length) { 525| 344| REQUIRE(b != NULL); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 344, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 344| *b = (isc_buffer_t){ 528| 344| .base = base, 529| 344| .length = length, 530| 344| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 344|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 344| { \ | | | | 27| 344| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 344|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 344| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 344|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 344| } | | ------------------ ------------------ 531| 344| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 344|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 344| }; 533| 344|} dns_name_fromwire.c:isc_buffer_setactive: 771| 344|isc_buffer_setactive(isc_buffer_t *restrict b, const unsigned int n) { 772| 344| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 688| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 344, False: 0] | | | | | Branch (42:11): [True: 344, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 773| 344| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 344, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 774| | 775| 344| b->active = b->current + n; 776| 344|} dns_name_fromwire.c:isc_buffer_forward: 806| 344|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 344| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 688| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 344, False: 0] | | | | | Branch (42:11): [True: 344, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 344| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 344, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 344| b->current += n; 811| 344|} old.c:isc_buffer_clear: 694| 172|isc_buffer_clear(isc_buffer_t *restrict b) { 695| 172| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| | 697| 172| b->used = 0; 698| 172| b->current = 0; 699| 172| b->active = 0; 700| 172|} old.c:isc_buffer_forward: 806| 66|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 66| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 66, False: 0] | | | | | Branch (42:11): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 66| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 66| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 66| b->current += n; 811| 66|} old.c:isc_buffer_add: 652| 66|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 66| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 66, False: 0] | | | | | Branch (42:11): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 66| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 66| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 66| b->used += n; 657| 66|} fixedname.c:isc_buffer_init: 524| 344| const unsigned int length) { 525| 344| REQUIRE(b != NULL); ------------------ | | 194| 344|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 344, False: 0] | | | | ------------------ | | | | 43| 344| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 526| | 527| 344| *b = (isc_buffer_t){ 528| 344| .base = base, 529| 344| .length = length, 530| 344| .link = ISC_LINK_INITIALIZER, ------------------ | | 30| 344|#define ISC_LINK_INITIALIZER ISC_LINK_INITIALIZER_TYPE(void) | | ------------------ | | | | 26| 344| { \ | | | | 27| 344| .prev = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 344|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 28| 344| .next = ISC_LINK_TOMBSTONE(type), \ | | | | ------------------ | | | | | | 18| 344|#define ISC_LINK_TOMBSTONE(type) ((type *)-1) | | | | ------------------ | | | | 29| 344| } | | ------------------ ------------------ 531| 344| .magic = ISC_BUFFER_MAGIC, ------------------ | | 121| 344|#define ISC_BUFFER_MAGIC 0x42756621U /* Buf!. */ ------------------ 532| 344| }; 533| 344|} name.c:isc_buffer_clear: 694| 172|isc_buffer_clear(isc_buffer_t *restrict b) { 695| 172| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 172|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 344| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 172, False: 0] | | | | | Branch (42:11): [True: 172, False: 0] | | | | ------------------ | | | | 43| 172| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 696| | 697| 172| b->used = 0; 698| 172| b->current = 0; 699| 172| b->active = 0; 700| 172|} name.c:isc_buffer_add: 652| 66|isc_buffer_add(isc_buffer_t *restrict b, const unsigned int n) { 653| 66| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 66, False: 0] | | | | | Branch (42:11): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 654| 66| REQUIRE(b->used + n <= b->length); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 66| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 655| | 656| 66| b->used += n; 657| 66|} name.c:isc_buffer_forward: 806| 66|isc_buffer_forward(isc_buffer_t *restrict b, const unsigned int n) { 807| 66| REQUIRE(ISC_BUFFER_VALID(b)); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 132| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:11): [True: 66, False: 0] | | | | | Branch (42:11): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 808| 66| REQUIRE(b->current + n <= b->used); ------------------ | | 194| 66|#define REQUIRE(e) ISC_REQUIRE(e) | | ------------------ | | | | 42| 66| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (42:10): [True: 66, False: 0] | | | | ------------------ | | | | 43| 66| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (43:3): [True: 0, False: 0] | | | | ------------------ | | | | 44| 0| isc_assertiontype_require, #cond), \ | | | | 45| 0| 0))) | | ------------------ ------------------ 809| | 810| 66| b->current += n; 811| 66|} isc_lib_initialize: 57| 2|isc_lib_initialize(void) { 58| 2| isc__lib_initialize(); 59| 2|} mem.c:isc_tid: 39| 20|isc_tid(void) { 40| 20| return isc__tid_local; 41| 20|} 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| 28|mallocx(size_t size, int flags) { 67| 28| void *ptr = malloc(size); 68| 28| INSIST(ptr != NULL); ------------------ | | 198| 28|#define INSIST(e) ISC_INSIST(e) | | ------------------ | | | | 54| 28| ((void)((cond) || \ | | | | ------------------ | | | | | Branch (54:10): [True: 28, False: 0] | | | | ------------------ | | | | 55| 28| ((isc_assertion_failed)(__FILE__, __LINE__, \ | | | | ------------------ | | | | | Branch (55:3): [True: 0, False: 0] | | | | ------------------ | | | | 56| 0| isc_assertiontype_insist, #cond), \ | | | | 57| 0| 0))) | | ------------------ ------------------ 69| | 70| 28| if ((flags & MALLOCX_ZERO) != 0) { ------------------ | | 32| 28|#define MALLOCX_ZERO ((int)0x40) ------------------ | Branch (70:6): [True: 0, False: 28] ------------------ 71| 0| memset(ptr, 0, size); 72| 0| } 73| | 74| 28| return ptr; 75| 28|} mem.c:sallocx: 59| 8|sallocx(void *ptr, int flags ISC_ATTR_UNUSED) { 60| 8| return malloc_usable_size(ptr); 61| 8|} 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| 12|isc__mem_get(isc_mem_t *ctx, size_t size, int flags FLARG) { 748| 12| void *ptr = NULL; 749| | 750| 12| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 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))) | | ------------------ ------------------ 751| | 752| 12| ptr = mem_get(ctx, size, flags); 753| | 754| 12| mem_getstats(ctx, size); 755| 12| ADD_TRACE(ctx, ptr, size, func, file, line); 756| | 757| 12| return ptr; 758| 12|} isc__mem_allocate: 839| 8|isc__mem_allocate(isc_mem_t *ctx, size_t size, int flags FLARG) { 840| 8| void *ptr = NULL; 841| | 842| 8| REQUIRE(VALID_CONTEXT(ctx)); ------------------ | | 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))) | | ------------------ ------------------ 843| | 844| 8| ptr = mem_get(ctx, size, flags); 845| | 846| | /* Recalculate the real allocated size */ 847| 8| size = sallocx(ptr, flags | ctx->jemalloc_flags); 848| | 849| 8| mem_getstats(ctx, size); 850| 8| ADD_TRACE(ctx, ptr, size, func, file, line); 851| | 852| 8| return ptr; 853| 8|} isc__mem_strdup: 947| 8|isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) { 948| 8| size_t len; 949| 8| char *ns = NULL; 950| | 951| 8| REQUIRE(VALID_CONTEXT(mctx)); ------------------ | | 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))) | | ------------------ ------------------ 952| 8| REQUIRE(s != 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))) | | ------------------ ------------------ 953| | 954| 8| len = strlen(s) + 1; 955| | 956| 8| ns = isc__mem_allocate(mctx, len, 0 FLARG_PASS); 957| | 958| 8| strlcpy(ns, s, len); 959| | 960| 8| return ns; 961| 8|} 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| 8|isc__mem_create(const char *name, isc_mem_t **mctxp FLARG) { 1558| 8| 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| 8|} 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| 20|mem_get(isc_mem_t *ctx, size_t size, int flags) { 396| 20| ADJUST_ZERO_ALLOCATION_SIZE(size); ------------------ | | 387| 20| if (s == 0) { \ | | ------------------ | | | Branch (387:6): [True: 0, False: 20] | | ------------------ | | 388| 0| s = ZERO_ALLOCATION_SIZE; \ | | ------------------ | | | | 83| 0|#define ZERO_ALLOCATION_SIZE sizeof(void *) | | ------------------ | | 389| 0| } ------------------ 397| | 398| 20| void *ptr = mallocx(size, flags | ctx->jemalloc_flags); 399| 20| CHECK_OOM(ptr, size); ------------------ | | 241| 20|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (241:37): [True: 20, False: 0] | | | Branch (241:54): [True: 0, False: 0] | | ------------------ ------------------ 400| | 401| 20| return ptr; 402| 20|} mem.c:mem_getstats: 471| 20|mem_getstats(isc_mem_t *ctx, size_t size) { 472| | atomic_fetch_add_relaxed(&ctx->stat[isc_tid()].inuse, size); ------------------ | | 30| 20| atomic_fetch_add_explicit((o), (v), memory_order_relaxed) ------------------ 473| 20|} mem.c:mem_create: 602| 8| unsigned int jemalloc_flags) { 603| 8| isc_mem_t *ctx = NULL; 604| | 605| 8| REQUIRE(ctxp != NULL && *ctxp == NULL); ------------------ | | 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))) | | ------------------ ------------------ 606| 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))) | | ------------------ ------------------ 607| | 608| 8| ctx = mallocx(sizeof(*ctx), jemalloc_flags); 609| 8| CHECK_OOM(ctx, sizeof(*ctx)); ------------------ | | 241| 8|#define CHECK_OOM(ptr, size) (void)((ptr != NULL) || (oom(size), false)) | | ------------------ | | | Branch (241:37): [True: 8, False: 0] | | | Branch (241:54): [True: 0, False: 0] | | ------------------ ------------------ 610| | 611| 8| *ctx = (isc_mem_t){ 612| 8| .magic = MEM_MAGIC, ------------------ | | 118| 8|#define MEM_MAGIC ISC_MAGIC('M', 'e', 'm', 'C') | | ------------------ | | | | 31| 8|#define ISC_MAGIC(a, b, c, d) ((a) << 24 | (b) << 16 | (c) << 8 | (d)) | | ------------------ ------------------ 613| 8| .debugging = debugging, 614| 8| .jemalloc_flags = jemalloc_flags, 615| 8| .checkfree = true, 616| 8| .name = strdup(name), 617| 8| }; 618| | 619| 8| isc_mutex_init(&ctx->lock); ------------------ | | 68| 8|#define isc_mutex_init(mp) isc__mutex_init(mp) | | ------------------ | | | | 79| 8| { \ | | | | 80| 8| int _ret = pthread_mutex_init(mp, &isc__mutex_init_attr); \ | | | | 81| 8| PTHREADS_RUNTIME_CHECK(pthread_mutex_init, _ret); \ | | | | ------------------ | | | | | | 284| 8| if ((ret) != 0) { \ | | | | | | ------------------ | | | | | | | Branch (284:6): [True: 0, False: 8] | | | | | | ------------------ | | | | | | 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| 8| } | | ------------------ ------------------ 620| 8| isc_refcount_init(&ctx->references, 1); ------------------ | | 44| 8|#define isc_refcount_init(target, value) atomic_init(target, value) ------------------ 621| | 622| 4.11k| for (size_t i = 0; i < ARRAY_SIZE(ctx->stat_s); i++) { ------------------ | | 94| 4.11k|#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) ------------------ | Branch (622:21): [True: 4.10k, False: 8] ------------------ 623| 4.10k| atomic_init(&ctx->stat_s[i].inuse, 0); 624| 4.10k| } 625| | 626| | /* Reserve the [-1] index for ISC_TID_UNKNOWN */ 627| 8| ctx->stat = &ctx->stat_s[1]; 628| | 629| 8| atomic_init(&ctx->hi_water, 0); 630| 8| atomic_init(&ctx->lo_water, 0); 631| | 632| 8| ISC_LIST_INIT(ctx->pools); ------------------ | | 43| 8| do { \ | | 44| 8| (list).head = NULL; \ | | 45| 8| (list).tail = NULL; \ | | 46| 8| } while (0) | | ------------------ | | | Branch (46:11): [Folded, False: 8] | | ------------------ ------------------ 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| 8| LOCK(&contextslock); ------------------ | | 26| 8| { \ | | 27| 8| ISC_UTIL_TRACE(fprintf(stderr, "LOCKING %p %s %d\n", (lp), \ | | 28| 8| __FILE__, __LINE__)); \ | | 29| 8| isc_mutex_lock((lp)); \ | | ------------------ | | | | 69| 8|#define isc_mutex_lock(mp) isc__mutex_lock(mp) | | | | ------------------ | | | | | | 85| 8| { \ | | | | | | 86| 8| int _ret = pthread_mutex_lock(mp); \ | | | | | | 87| 8| PTHREADS_RUNTIME_CHECK(pthread_mutex_lock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 8| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 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| 8| } | | | | ------------------ | | ------------------ | | 30| 8| ISC_UTIL_TRACE(fprintf(stderr, "LOCKED %p %s %d\n", (lp), \ | | 31| 8| __FILE__, __LINE__)); \ | | 32| 8| } ------------------ 650| 8| ISC_LIST_INITANDAPPEND(contexts, ctx, link); ------------------ | | 106| 8| __ISC_LIST_APPENDUNSAFE(list, elt, link) | | ------------------ | | | | 88| 8| do { \ | | | | 89| 8| if ((list).tail != NULL) { \ | | | | ------------------ | | | | | Branch (89:7): [True: 6, False: 2] | | | | ------------------ | | | | 90| 6| (list).tail->link.next = (elt); \ | | | | 91| 6| } else { \ | | | | 92| 2| (list).head = (elt); \ | | | | 93| 2| } \ | | | | 94| 8| (elt)->link.prev = (list).tail; \ | | | | 95| 8| (elt)->link.next = NULL; \ | | | | 96| 8| (list).tail = (elt); \ | | | | 97| 8| } while (0) | | | | ------------------ | | | | | Branch (97:11): [Folded, False: 8] | | | | ------------------ | | ------------------ ------------------ 651| 8| UNLOCK(&contextslock); ------------------ | | 34| 8| { \ | | 35| 8| isc_mutex_unlock((lp)); \ | | ------------------ | | | | 70| 8|#define isc_mutex_unlock(mp) isc__mutex_unlock(mp) | | | | ------------------ | | | | | | 91| 8| { \ | | | | | | 92| 8| int _ret = pthread_mutex_unlock(mp); \ | | | | | | 93| 8| PTHREADS_RUNTIME_CHECK(pthread_mutex_unlock, _ret); \ | | | | | | ------------------ | | | | | | | | 284| 8| if ((ret) != 0) { \ | | | | | | | | ------------------ | | | | | | | | | Branch (284:6): [True: 0, False: 8] | | | | | | | | ------------------ | | | | | | | | 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| 8| } | | | | ------------------ | | ------------------ | | 36| 8| ISC_UTIL_TRACE(fprintf(stderr, "UNLOCKED %p %s %d\n", (lp), \ | | 37| 8| __FILE__, __LINE__)); \ | | 38| 8| } ------------------ 652| | 653| 8| *ctxp = ctx; 654| 8|} 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|}