ogs_core_initialize: 40| 1|{ 41| 1| ogs_mem_init(); 42| 1| ogs_log_init(); 43| 1| ogs_pkbuf_init(); 44| 1| ogs_socket_init(); 45| 1| ogs_tlv_init(); 46| | 47| 1| ogs_log_install_domain(&__ogs_mem_domain, "mem", ogs_core()->log.level); 48| 1| ogs_log_install_domain(&__ogs_sock_domain, "sock", ogs_core()->log.level); 49| 1| ogs_log_install_domain(&__ogs_event_domain, "event", ogs_core()->log.level); 50| 1| ogs_log_install_domain(&__ogs_thread_domain, 51| 1| "thread", ogs_core()->log.level); 52| 1| ogs_log_install_domain(&__ogs_tlv_domain, "tlv", ogs_core()->log.level); 53| 1|} ogs_core: 65| 606|{ 66| 606| return &self; 67| 606|} ogs_hash_make: 70| 3|{ 71| 3| ogs_hash_t *ht; 72| 3| ogs_time_t now = ogs_get_monotonic_time(); 73| | 74| 3| ht = ogs_malloc(sizeof(ogs_hash_t)); ------------------ | | 68| 3| ogs_talloc_size(__ogs_talloc_core, size, __location__) ------------------ 75| 3| if (!ht) { ------------------ | Branch (75:9): [True: 0, False: 3] ------------------ 76| 0| ogs_error("ogs_malloc() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 3| ht->free = NULL; 81| 3| ht->count = 0; 82| 3| ht->max = INITIAL_MAX; ------------------ | | 60| 3|#define INITIAL_MAX 15 /* tunable == 2^n - 1 */ ------------------ 83| 3| ht->seed = (unsigned int)((now >> 32) ^ now ^ 84| 3| (uintptr_t)ht ^ (uintptr_t)&now) - 1; 85| 3| ht->array = alloc_array(ht, ht->max); 86| 3| ht->hash_func = NULL; 87| | 88| 3| return ht; 89| 3|} ogs-hash.c:alloc_array: 63| 3|{ 64| 3| ogs_hash_entry_t **ptr = ogs_calloc(1, sizeof(*ht->array) * (max + 1)); ------------------ | | 70| 3| ogs_talloc_zero_size(__ogs_talloc_core, (nmemb) * (size), __location__) ------------------ 65| 3| ogs_assert(ptr); ------------------ | | 113| 3| do { \ | | 114| 3| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 115| 3| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 3| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3] | | ------------------ ------------------ 66| 3| return ptr; 67| 3|} ogs-log.c:ogs_list_first: 51| 8.29k|{ 52| 8.29k| return list->next; 53| 8.29k|} ogs-log.c:ogs_list_next: 61| 7.21k|{ 62| 7.21k| ogs_list_t *node = (ogs_list_t *)lnode; 63| 7.21k| return node->next; 64| 7.21k|} ogs-log.c:ogs_list_add: 115| 8|{ 116| 8| ogs_list_t *node = (ogs_list_t *)lnode; 117| | 118| 8| node->prev = list->prev; 119| 8| node->next = NULL; 120| 8| if (list->prev) ------------------ | Branch (120:9): [True: 6, False: 2] ------------------ 121| 6| list->prev->next = node; 122| 2| else 123| 2| list->next = node; 124| 8| list->prev = node; 125| 8|} ogs_log_init: 115| 1|{ 116| 1| ogs_pool_init(&log_pool, ogs_core()->log.pool); ------------------ | | 52| 1|#define ogs_pool_init(pool, _size) do { \ | | 53| 1| int i; \ | | 54| 1| (pool)->name = #pool; \ | | 55| 1| (pool)->free = malloc(sizeof(*(pool)->free) * _size); \ | | 56| 1| ogs_assert((pool)->free); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 57| 1| (pool)->array = malloc(sizeof(*(pool)->array) * _size); \ | | 58| 1| ogs_assert((pool)->array); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 59| 1| (pool)->index = malloc(sizeof(*(pool)->index) * _size); \ | | 60| 1| ogs_assert((pool)->index); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 61| 1| (pool)->size = (pool)->avail = _size; \ | | 62| 1| (pool)->head = (pool)->tail = 0; \ | | 63| 9| for (i = 0; i < _size; i++) { \ | | ------------------ | | | Branch (63:17): [True: 8, False: 1] | | ------------------ | | 64| 8| (pool)->free[i] = &((pool)->array[i]); \ | | 65| 8| (pool)->index[i] = NULL; \ | | 66| 8| } \ | | 67| 1| \ | | 68| 1| (pool)->id_hash = ogs_hash_make(); \ | | 69| 1| ogs_assert((pool)->id_hash); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 70| 1|} while (0) | | ------------------ | | | Branch (70:10): [Folded, False: 1] | | ------------------ ------------------ 117| 1| ogs_pool_init(&domain_pool, ogs_core()->log.domain_pool); ------------------ | | 52| 1|#define ogs_pool_init(pool, _size) do { \ | | 53| 1| int i; \ | | 54| 1| (pool)->name = #pool; \ | | 55| 1| (pool)->free = malloc(sizeof(*(pool)->free) * _size); \ | | 56| 1| ogs_assert((pool)->free); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 57| 1| (pool)->array = malloc(sizeof(*(pool)->array) * _size); \ | | 58| 1| ogs_assert((pool)->array); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 59| 1| (pool)->index = malloc(sizeof(*(pool)->index) * _size); \ | | 60| 1| ogs_assert((pool)->index); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 61| 1| (pool)->size = (pool)->avail = _size; \ | | 62| 1| (pool)->head = (pool)->tail = 0; \ | | 63| 65| for (i = 0; i < _size; i++) { \ | | ------------------ | | | Branch (63:17): [True: 64, False: 1] | | ------------------ | | 64| 64| (pool)->free[i] = &((pool)->array[i]); \ | | 65| 64| (pool)->index[i] = NULL; \ | | 66| 64| } \ | | 67| 1| \ | | 68| 1| (pool)->id_hash = ogs_hash_make(); \ | | 69| 1| ogs_assert((pool)->id_hash); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 70| 1|} while (0) | | ------------------ | | | Branch (70:10): [Folded, False: 1] | | ------------------ ------------------ 118| | 119| 1| ogs_log_add_domain("core", ogs_core()->log.level); 120| 1| ogs_log_add_stderr(); 121| 1|} ogs_log_add_stderr: 152| 1|{ 153| 1| ogs_log_t *log = NULL; 154| | 155| 1| log = add_log(OGS_LOG_STDERR_TYPE); 156| 1| ogs_assert(log); ------------------ | | 113| 1| do { \ | | 114| 1| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 115| 1| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 1| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1] | | ------------------ ------------------ 157| | 158| 1| log->file.out = stderr; 159| 1| log->writer = file_writer; 160| | 161| 1|#if !defined(_WIN32) 162| 1| log->print.color = 1; 163| 1|#endif 164| | 165| 1| return log; 166| 1|} ogs_log_add_domain: 204| 7|{ 205| 7| ogs_log_domain_t *domain = NULL; 206| | 207| 7| ogs_assert(name); ------------------ | | 113| 7| do { \ | | 114| 7| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 115| 7| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7] | | ------------------ ------------------ 208| | 209| 7| ogs_pool_alloc(&domain_pool, &domain); ------------------ | | 132| 7|#define ogs_pool_alloc(pool, node) do { \ | | 133| 7| *(node) = NULL; \ | | 134| 7| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 7, False: 0] | | ------------------ | | 135| 7| (pool)->avail--; \ | | 136| 7| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 7| (pool)->free[(pool)->head] = NULL; \ | | 138| 7| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 7| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 7|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 7| } \ | | 141| 7|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 7] | | ------------------ ------------------ 210| 7| ogs_assert(domain); ------------------ | | 113| 7| do { \ | | 114| 7| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 115| 7| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7] | | ------------------ ------------------ 211| | 212| 7| domain->name = name; 213| 7| domain->id = ogs_pool_index(&domain_pool, domain); ------------------ | | 152| 7|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) ------------------ 214| 7| domain->level = level; 215| | 216| 7| ogs_list_add(&domain_list, domain); 217| | 218| 7| return domain; 219| 7|} ogs_log_find_domain: 222| 7|{ 223| 7| ogs_log_domain_t *domain = NULL; 224| | 225| 7| ogs_assert(name); ------------------ | | 113| 7| do { \ | | 114| 7| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 115| 7| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7] | | ------------------ ------------------ 226| | 227| 7| ogs_list_for_each(&domain_list, domain) ------------------ | | 76| 33| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 27, False: 6] | | ------------------ | | 77| 26| node = ogs_list_next(node)) ------------------ 228| 27| if (!ogs_strcasecmp(domain->name, name)) ------------------ | | 63| 27|#define ogs_strcasecmp strcasecmp ------------------ | Branch (228:13): [True: 1, False: 26] ------------------ 229| 1| return domain; 230| | 231| 6| return NULL; 232| 7|} ogs_log_set_domain_level: 243| 1|{ 244| 1| ogs_log_domain_t *domain = NULL; 245| | 246| 1| ogs_assert(id > 0 && id <= ogs_core()->log.domain_pool); ------------------ | | 113| 1| do { \ | | 114| 1| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1, False: 0] | | | | | Branch (54:44): [True: 1, False: 0] | | | | | Branch (54:44): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 115| 1| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 1| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1] | | ------------------ ------------------ 247| | 248| 1| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 1| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 1, False: 0] | | | Branch (154:20): [True: 1, False: 0] | | ------------------ ------------------ 249| 1| ogs_assert(domain); ------------------ | | 113| 1| do { \ | | 114| 1| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 115| 1| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 1| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1] | | ------------------ ------------------ 250| | 251| 1| domain->level = level; 252| 1|} ogs_log_install_domain: 292| 7|{ 293| 7| ogs_log_domain_t *domain = NULL; 294| | 295| 7| ogs_assert(domain_id); ------------------ | | 113| 7| do { \ | | 114| 7| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 115| 7| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7] | | ------------------ ------------------ 296| 7| ogs_assert(name); ------------------ | | 113| 7| do { \ | | 114| 7| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7, False: 0] | | | | ------------------ | | ------------------ | | 115| 7| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7] | | ------------------ ------------------ 297| | 298| 7| domain = ogs_log_find_domain(name); 299| 7| if (domain) { ------------------ | Branch (299:9): [True: 1, False: 6] ------------------ 300| 1| ogs_warn("`%s` log-domain duplicated", name); ------------------ | | 37| 1|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 1|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 301| 1| if (level != domain->level) { ------------------ | Branch (301:13): [True: 1, False: 0] ------------------ 302| 1| ogs_warn("[%s]->[%s] log-level changed", ------------------ | | 37| 1|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 1|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 303| 1| level_strings[domain->level], level_strings[level]); 304| 1| ogs_log_set_domain_level(domain->id, level); 305| 1| } 306| 6| } else { 307| 6| domain = ogs_log_add_domain(name, level); 308| 6| ogs_assert(domain); ------------------ | | 113| 6| do { \ | | 114| 6| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6, False: 0] | | | | ------------------ | | ------------------ | | 115| 6| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 6| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6] | | ------------------ ------------------ 309| 6| } 310| | 311| 7| *domain_id = domain->id; 312| 7|} ogs_log_vprintf: 404| 8.29k|{ 405| 8.29k| ogs_log_t *log = NULL; 406| 8.29k| ogs_log_domain_t *domain = NULL; 407| | 408| 8.29k| char logstr[OGS_HUGE_LEN]; 409| 8.29k| char *p, *last; 410| | 411| 8.29k| int wrote_stderr = 0; 412| | 413| 8.29k| ogs_list_for_each(&log_list, log) { ------------------ | | 76| 15.4k| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 8.29k, False: 7.19k] | | ------------------ | | 77| 8.29k| node = ogs_list_next(node)) ------------------ 414| 8.29k| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 8.29k| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 8.29k, False: 0] | | | Branch (154:20): [True: 8.29k, False: 0] | | ------------------ ------------------ 415| 8.29k| if (!domain) { ------------------ | Branch (415:13): [True: 0, False: 8.29k] ------------------ 416| 0| fprintf(stderr, "No LogDomain[id:%d] in %s:%d", id, file, line); 417| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 418| 0| } 419| 8.29k| if (domain->level < level) ------------------ | Branch (419:13): [True: 1.09k, False: 7.19k] ------------------ 420| 1.09k| return; 421| | 422| 7.19k| p = logstr; 423| 7.19k| last = logstr + OGS_HUGE_LEN; ------------------ | | 210| 7.19k|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 424| | 425| 7.19k| if (!content_only) { ------------------ | Branch (425:13): [True: 7.04k, False: 148] ------------------ 426| 7.04k| if (log->print.timestamp) ------------------ | Branch (426:17): [True: 7.04k, False: 0] ------------------ 427| 7.04k| p = log_timestamp(p, last, log->print.color); 428| 7.04k| if (log->print.domain) ------------------ | Branch (428:17): [True: 7.04k, False: 0] ------------------ 429| 7.04k| p = log_domain(p, last, domain->name, log->print.color); 430| 7.04k| if (log->print.level) ------------------ | Branch (430:17): [True: 7.04k, False: 0] ------------------ 431| 7.04k| p = log_level(p, last, level, log->print.color); 432| 7.04k| } 433| | 434| 7.19k| p = log_content(p, last, format, ap); 435| | 436| 7.19k| if (err) { ------------------ | Branch (436:13): [True: 0, False: 7.19k] ------------------ 437| 0| char errbuf[OGS_HUGE_LEN]; 438| 0| p = ogs_slprintf(p, last, " (%d:%s)", 439| 0| (int)err, ogs_strerror(err, errbuf, OGS_HUGE_LEN)); ------------------ | | 210| 0|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 440| 0| } 441| | 442| 7.19k| if (!content_only) { ------------------ | Branch (442:13): [True: 7.04k, False: 148] ------------------ 443| 7.04k| if (log->print.fileline) ------------------ | Branch (443:17): [True: 7.04k, False: 0] ------------------ 444| 7.04k| p = ogs_slprintf(p, last, " (%s:%d)", file, line); 445| 7.04k| if (log->print.function) ------------------ | Branch (445:17): [True: 0, False: 7.04k] ------------------ 446| 0| p = ogs_slprintf(p, last, " %s()", func); 447| 7.04k| if (log->print.linefeed) ------------------ | Branch (447:17): [True: 7.04k, False: 0] ------------------ 448| 7.04k| p = log_linefeed(p, last); 449| 7.04k| } 450| | 451| 7.19k| log->writer(log, level, logstr); 452| | 453| 7.19k| if (log->type == OGS_LOG_STDERR_TYPE) ------------------ | Branch (453:13): [True: 7.19k, False: 0] ------------------ 454| 7.19k| wrote_stderr = 1; 455| 7.19k| } 456| | 457| 7.19k| if (!wrote_stderr) ------------------ | Branch (457:9): [True: 0, False: 7.19k] ------------------ 458| 0| { 459| 0| int use_color = 0; 460| 0|#if !defined(_WIN32) 461| 0| use_color = 1; 462| 0|#endif 463| | 464| 0| p = logstr; 465| 0| last = logstr + OGS_HUGE_LEN; ------------------ | | 210| 0|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 466| | 467| 0| if (!content_only) { ------------------ | Branch (467:13): [True: 0, False: 0] ------------------ 468| 0| p = log_timestamp(p, last, use_color); 469| 0| p = log_level(p, last, level, use_color); 470| 0| } 471| 0| p = log_content(p, last, format, ap); 472| 0| if (!content_only) { ------------------ | Branch (472:13): [True: 0, False: 0] ------------------ 473| 0| p = ogs_slprintf(p, last, " (%s:%d)", file, line); 474| 0| p = ogs_slprintf(p, last, " %s()", func); 475| 0| p = log_linefeed(p, last); 476| 0| } 477| | 478| 0| fprintf(stderr, "%s", logstr); 479| | fflush(stderr); 480| 0| } 481| 7.19k|} ogs_log_printf: 486| 8.29k|{ 487| 8.29k| va_list args; 488| | 489| 8.29k| va_start(args, format); 490| 8.29k| ogs_log_vprintf(level, id, 491| 8.29k| err, file, line, func, content_only, format, args); 492| | va_end(args); 493| 8.29k|} ogs_log_hexdump_func: 497| 172|{ 498| 172| size_t n, m; 499| 172| char dumpstr[OGS_HUGE_LEN]; 500| 172| char *p, *last; 501| | 502| | /* 503| | * Nothing is written to dumpstr when len is zero, so printing it 504| | * would output an uninitialized stack buffer. 505| | */ 506| 172| if (!len) ------------------ | Branch (506:9): [True: 24, False: 148] ------------------ 507| 24| return; 508| | 509| 148| last = dumpstr + OGS_HUGE_LEN; ------------------ | | 210| 148|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 510| 148| p = dumpstr; 511| | 512| 1.41k| for (n = 0; n < len; n += 16) { ------------------ | Branch (512:17): [True: 1.26k, False: 148] ------------------ 513| 1.26k| p = ogs_slprintf(p, last, "%04x: ", (int)n); 514| | 515| 21.5k| for (m = n; m < n + 16; m++) { ------------------ | Branch (515:21): [True: 20.2k, False: 1.26k] ------------------ 516| 20.2k| if (m > n && (m % 4) == 0) ------------------ | Branch (516:17): [True: 18.9k, False: 1.26k] | Branch (516:26): [True: 3.79k, False: 15.1k] ------------------ 517| 3.79k| p = ogs_slprintf(p, last, " "); 518| 20.2k| if (m < len) ------------------ | Branch (518:17): [True: 18.8k, False: 1.41k] ------------------ 519| 18.8k| p = ogs_slprintf(p, last, "%02x", data[m]); 520| 1.41k| else 521| 1.41k| p = ogs_slprintf(p, last, " "); 522| 20.2k| } 523| | 524| 1.26k| p = ogs_slprintf(p, last, " "); 525| | 526| 20.0k| for (m = n; m < len && m < n + 16; m++) ------------------ | Branch (526:21): [True: 19.9k, False: 148] | Branch (526:32): [True: 18.8k, False: 1.11k] ------------------ 527| 18.8k| p = ogs_slprintf(p, last, "%c", isprint(data[m]) ? data[m] : '.'); ------------------ | Branch (527:45): [True: 4.05k, False: 14.7k] ------------------ 528| | 529| 1.26k| p = ogs_slprintf(p, last, "\n"); 530| 1.26k| } 531| | 532| | ogs_log_print(level, "%s", dumpstr); ------------------ | | 48| 148| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | ------------------ | | | | 32| 148|#define OGS_LOG_DOMAIN 1 | | ------------------ | | 49| 148| 0, NULL, 0, NULL, \ | | 50| 148| 1, __VA_ARGS__) ------------------ 533| 148|} ogs-log.c:add_log: 536| 1|{ 537| 1| ogs_log_t *log = NULL; 538| | 539| 1| ogs_pool_alloc(&log_pool, &log); ------------------ | | 132| 1|#define ogs_pool_alloc(pool, node) do { \ | | 133| 1| *(node) = NULL; \ | | 134| 1| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 1, False: 0] | | ------------------ | | 135| 1| (pool)->avail--; \ | | 136| 1| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 1| (pool)->free[(pool)->head] = NULL; \ | | 138| 1| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 1| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 1|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 1| } \ | | 141| 1|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 1] | | ------------------ ------------------ 540| 1| ogs_assert(log); ------------------ | | 113| 1| do { \ | | 114| 1| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 115| 1| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 1| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1] | | ------------------ ------------------ 541| 1| memset(log, 0, sizeof *log); 542| | 543| 1| log->type = type; 544| | 545| 1| log->print.timestamp = 1; 546| 1| log->print.domain = 1; 547| 1| log->print.level = 1; 548| 1| log->print.fileline = 1; 549| 1| log->print.linefeed = 1; 550| | 551| 1| ogs_list_add(&log_list, log); 552| | 553| 1| return log; 554| 1|} ogs-log.c:log_timestamp: 571| 7.04k|{ 572| 7.04k| struct timeval tv; 573| 7.04k| struct tm tm; 574| 7.04k| char nowstr[32]; 575| | 576| 7.04k| ogs_gettimeofday(&tv); 577| 7.04k| ogs_localtime(tv.tv_sec, &tm); 578| 7.04k| strftime(nowstr, sizeof nowstr, "%m/%d %H:%M:%S", &tm); 579| | 580| 7.04k| buf = ogs_slprintf(buf, last, "%s%s.%03d%s: ", 581| 7.04k| use_color ? TA_FGC_GREEN : "", ------------------ | | 37| 7.04k|#define TA_FGC_GREEN "\033[32m" /* Green */ ------------------ | Branch (581:13): [True: 7.04k, False: 0] ------------------ 582| 7.04k| nowstr, (int)(tv.tv_usec/1000), 583| 7.04k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.04k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (583:13): [True: 7.04k, False: 0] ------------------ 584| | 585| 7.04k| return buf; 586| 7.04k|} ogs-log.c:log_domain: 590| 7.04k|{ 591| 7.04k| buf = ogs_slprintf(buf, last, "[%s%s%s] ", 592| 7.04k| use_color ? TA_FGC_YELLOW : "", ------------------ | | 39| 7.04k|#define TA_FGC_YELLOW "\033[33m" /* Yellow */ ------------------ | Branch (592:13): [True: 7.04k, False: 0] ------------------ 593| 7.04k| name, 594| 7.04k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.04k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (594:13): [True: 7.04k, False: 0] ------------------ 595| | 596| 7.04k| return buf; 597| 7.04k|} ogs-log.c:log_level: 601| 7.04k|{ 602| 7.04k| const char *colors[] = { 603| 7.04k| TA_NOR, ------------------ | | 32| 7.04k|#define TA_NOR "\033[0m" /* all off */ ------------------ 604| 7.04k| TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 36| 7.04k|#define TA_FGC_BOLD_RED "\033[1;31m" /* Bold Red */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 40| 7.04k|#define TA_FGC_BOLD_YELLOW "\033[1;33m" /* Bold Yellow */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 43| 7.04k|#define TA_FGC_BOLD_CYAN "\033[1;36m" /* Bold Cyan */ ------------------ 605| 7.04k| TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 38| 7.04k|#define TA_FGC_BOLD_GREEN "\033[1;32m" /* Bold Green */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 45| 7.04k|#define TA_FGC_BOLD_WHITE "\033[1;37m" /* Bold White */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 44| 7.04k|#define TA_FGC_WHITE "\033[37m" /* White */ ------------------ 606| 7.04k| }; 607| | 608| 7.04k| buf = ogs_slprintf(buf, last, "%s%s%s: ", 609| 7.04k| use_color ? colors[level] : "", ------------------ | Branch (609:13): [True: 7.04k, False: 0] ------------------ 610| 7.04k| level_strings[level], 611| 7.04k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.04k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (611:13): [True: 7.04k, False: 0] ------------------ 612| | 613| 7.04k| return buf; 614| 7.04k|} ogs-log.c:log_content: 618| 7.19k|{ 619| 7.19k| va_list bp; 620| | 621| 7.19k| va_copy(bp, ap); 622| 7.19k|#pragma GCC diagnostic push 623| 7.19k|#pragma GCC diagnostic ignored "-Wformat-nonliteral" 624| 7.19k| buf = ogs_vslprintf(buf, last, format, bp); 625| 7.19k|#pragma GCC diagnostic pop 626| 7.19k| va_end(bp); 627| | 628| 7.19k| return buf; 629| 7.19k|} ogs-log.c:log_linefeed: 632| 7.04k|{ 633| |#if defined(_WIN32) 634| | if (buf > last - 3) 635| | buf = last - 3; 636| | 637| | buf = ogs_slprintf(buf, last, "\r\n"); 638| |#else 639| 7.04k| if (buf > last - 2) ------------------ | Branch (639:9): [True: 0, False: 7.04k] ------------------ 640| 0| buf = last - 2; 641| | 642| 7.04k| buf = ogs_slprintf(buf, last, "\n"); 643| 7.04k|#endif 644| | 645| 7.04k| return buf; 646| 7.04k|} ogs-log.c:file_writer: 650| 7.19k|{ 651| 7.19k| fprintf(log->file.out, "%s", string); 652| 7.19k| fflush(log->file.out); 653| 7.19k|} ogs_mem_init: 34| 1|{ 35| 1| ogs_thread_mutex_init(&mutex); ------------------ | | 37| 1|#define ogs_thread_mutex_init(_n) (void)pthread_mutex_init((_n), NULL) ------------------ 36| | 37| 1| talloc_enable_null_tracking(); 38| | 39| 1|#define TALLOC_MEMSIZE 1 40| 1| __ogs_talloc_core = talloc_named_const(NULL, TALLOC_MEMSIZE, "core"); ------------------ | | 39| 1|#define TALLOC_MEMSIZE 1 ------------------ 41| 1|} ogs_talloc_size: 59| 3|{ 60| 3| void *ptr = NULL; 61| | 62| 3| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 3|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 63| | 64| 3| ptr = talloc_named_const(ctx, size, name); 65| 3| ogs_expect(ptr); ------------------ | | 128| 3| do { \ | | 129| 3| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 130| 3| else { \ | | 131| 0| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 23| 0|#define OGS_LOG_DOMAIN __ogs_mem_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 0| } \ | | 133| 3| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 3] | | ------------------ ------------------ 66| | 67| 3| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 3|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 68| | 69| 3| return ptr; 70| 3|} ogs_talloc_zero_size: 73| 472|{ 74| 472| void *ptr = NULL; 75| | 76| 472| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 472|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 77| | 78| 472| ptr = _talloc_zero(ctx, size, name); 79| 472| ogs_expect(ptr); ------------------ | | 128| 472| do { \ | | 129| 472| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 472|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 472, False: 0] | | | | ------------------ | | ------------------ | | 130| 472| else { \ | | 131| 0| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 23| 0|#define OGS_LOG_DOMAIN __ogs_mem_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 0| } \ | | 133| 472| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 472] | | ------------------ ------------------ 80| | 81| 472| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 472|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 82| | 83| 472| return ptr; 84| 472|} ogs_talloc_free: 102| 469|{ 103| 469| int ret; 104| | 105| 469| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 469|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 106| | 107| 469| ret = _talloc_free(ptr, location); 108| | 109| 469| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 469|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 110| | 111| 469| return ret; 112| 469|} ogs_pkbuf_put_data: 91| 469|{ 92| 469| void *tmp = ogs_pkbuf_put(pkbuf, len); 93| | 94| 469| memcpy(tmp, data, len); 95| 469| return tmp; 96| 469|} ogs_pkbuf_init: 99| 1|{ 100| |#if OGS_USE_TALLOC == 0 101| | ogs_pool_init(&pkbuf_pool, ogs_core()->pkbuf.pool); 102| | 103| |#endif 104| 1|} ogs_pkbuf_default_init: 114| 1|{ 115| |#if OGS_USE_TALLOC == 0 116| | ogs_assert(config); 117| | memset(config, 0, sizeof *config); 118| | 119| | config->cluster_128_pool = 65536; 120| | config->cluster_256_pool = 16384; 121| | config->cluster_512_pool = 4096; 122| | config->cluster_1024_pool = 2048; 123| | config->cluster_2048_pool = 1024; 124| | config->cluster_8192_pool = 256; 125| | config->cluster_32768_pool = 64; 126| | config->cluster_big_pool = 8; 127| |#endif 128| 1|} ogs_pkbuf_default_create: 131| 1|{ 132| |#if OGS_USE_TALLOC == 0 133| | default_pool = ogs_pkbuf_pool_create(config); 134| |#endif 135| 1|} ogs_pkbuf_alloc_debug: 222| 469|{ 223| 469|#if OGS_USE_TALLOC == 1 224| 469| ogs_pkbuf_t *pkbuf = NULL; 225| | 226| 469| pkbuf = ogs_talloc_zero_size(pool, sizeof(*pkbuf) + size, file_line); 227| 469| if (!pkbuf) { ------------------ | Branch (227:9): [True: 0, False: 469] ------------------ 228| 0| ogs_error("ogs_pkbuf_alloc() failed [size=%d]", size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 23| 0|#define OGS_LOG_DOMAIN __ogs_mem_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 229| 0| return NULL; 230| 0| } 231| | 232| 469| pkbuf->head = pkbuf->_data; 233| 469| pkbuf->end = pkbuf->_data + size; 234| | 235| 469| pkbuf->len = 0; 236| | 237| 469| pkbuf->data = pkbuf->_data; 238| 469| pkbuf->tail = pkbuf->_data; 239| | 240| 469| pkbuf->file_line = file_line; /* For debug */ 241| | 242| 469| return pkbuf; 243| |#else 244| | ogs_pkbuf_t *pkbuf = NULL; 245| | ogs_cluster_t *cluster = NULL; 246| | 247| | if (pool == NULL) 248| | pool = default_pool; 249| | ogs_assert(pool); 250| | 251| | ogs_thread_mutex_lock(&pool->mutex); 252| | 253| | cluster = cluster_alloc(pool, size); 254| | if (!cluster) { 255| | ogs_error("ogs_pkbuf_alloc() failed [size=%d]", size); 256| | ogs_thread_mutex_unlock(&pool->mutex); 257| | return NULL; 258| | } 259| | 260| | ogs_pool_alloc(&pool->pkbuf, &pkbuf); 261| | if (!pkbuf) { 262| | ogs_error("ogs_pkbuf_alloc() failed [size=%d]", size); 263| | ogs_thread_mutex_unlock(&pool->mutex); 264| | return NULL; 265| | } 266| | memset(pkbuf, 0, sizeof(*pkbuf)); 267| | 268| | OGS_OBJECT_REF(cluster); 269| | 270| | pkbuf->cluster = cluster; 271| | 272| | pkbuf->len = 0; 273| | 274| | pkbuf->data = cluster->buffer; 275| | pkbuf->head = cluster->buffer; 276| | pkbuf->tail = cluster->buffer; 277| | pkbuf->end = cluster->buffer + size; 278| | 279| | pkbuf->file_line = file_line; /* For debug */ 280| | 281| | pkbuf->pool = pool; 282| | 283| | ogs_thread_mutex_unlock(&pool->mutex); 284| | 285| | return pkbuf; 286| |#endif 287| 469|} ogs_pkbuf_free: 290| 469|{ 291| 469|#if OGS_USE_TALLOC == 1 292| 469| ogs_talloc_free(pkbuf, OGS_FILE_LINE); ------------------ | | 213| 469|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | ------------------ | | | | 167| 469|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | ------------------ | | | | | | 168| 469|#define OGS_STRINGIFY_HELPER(n) #n | | | | ------------------ | | ------------------ ------------------ 293| |#else 294| | ogs_pkbuf_pool_t *pool = NULL; 295| | ogs_cluster_t *cluster = NULL; 296| | ogs_assert(pkbuf); 297| | 298| | pool = pkbuf->pool; 299| | ogs_assert(pool); 300| | 301| | ogs_thread_mutex_lock(&pool->mutex); 302| | 303| | cluster = pkbuf->cluster; 304| | ogs_assert(cluster); 305| | 306| | if (OGS_OBJECT_IS_REF(cluster)) 307| | OGS_OBJECT_UNREF(cluster); 308| | else 309| | cluster_free(pool, pkbuf->cluster); 310| | 311| | ogs_pool_free(&pool->pkbuf, pkbuf); 312| | 313| | ogs_thread_mutex_unlock(&pool->mutex); 314| |#endif 315| 469|} message.c:ogs_pkbuf_pull: 165| 469|{ 166| 469| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 469|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 8, False: 461] | | ------------------ ------------------ 167| 469| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 469|} message.c:ogs_pkbuf_pull_inline: 159| 461|{ 160| 461| pkbuf->len -= len; 161| 461| return pkbuf->data += len; 162| 461|} message.c:ogs_pkbuf_push: 147| 461|{ 148| 461| if (ogs_unlikely(ogs_pkbuf_headroom(pkbuf) < (int)len)) ------------------ | | 55| 461|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 461] | | ------------------ ------------------ 149| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 150| | 151| 461| pkbuf->data -= len; 152| 461| pkbuf->len += len; 153| | 154| 461| return pkbuf->data; 155| 461|} message.c:ogs_pkbuf_headroom: 104| 461|{ 105| 461| return pkbuf->data - pkbuf->head; 106| 461|} ogs-pkbuf.c:ogs_pkbuf_put: 115| 469|{ 116| 469| void *tmp = pkbuf->tail; 117| | 118| 469| if (ogs_unlikely(ogs_pkbuf_tailroom(pkbuf) < (int)len)) ------------------ | | 55| 469|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 469] | | ------------------ ------------------ 119| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 120| | 121| 469| pkbuf->tail += len; 122| 469| pkbuf->len += len; 123| | 124| 469| return tmp; 125| 469|} ogs-pkbuf.c:ogs_pkbuf_tailroom: 99| 469|{ 100| 469| return pkbuf->end - pkbuf->tail; 101| 469|} ogs_rbtree_insert_color: 93| 6.49k|{ 94| 6.49k| ogs_rbnode_t *node = rb_node; 95| 6.49k| ogs_rbnode_t *parent; 96| 6.49k| ogs_assert(tree); ------------------ | | 113| 6.49k| do { \ | | 114| 6.49k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.49k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.49k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.49k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 6.49k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.49k] | | ------------------ ------------------ 97| 6.49k| ogs_assert(node); ------------------ | | 113| 6.49k| do { \ | | 114| 6.49k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.49k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.49k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.49k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 6.49k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.49k] | | ------------------ ------------------ 98| | 99| 13.3k| while ((parent = node->parent) && parent->color == OGS_RBTREE_RED) { ------------------ | Branch (99:12): [True: 12.2k, False: 1.09k] | Branch (99:39): [True: 6.83k, False: 5.39k] ------------------ 100| 6.83k| ogs_rbnode_t *gparent = parent->parent; 101| 6.83k| ogs_assert(gparent); ------------------ | | 113| 6.83k| do { \ | | 114| 6.83k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.83k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.83k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.83k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 6.83k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.83k] | | ------------------ ------------------ 102| | 103| | /* parent == grandparent's left child */ 104| 6.83k| if (parent == gparent->left) { ------------------ | Branch (104:13): [True: 2.66k, False: 4.17k] ------------------ 105| 2.66k| ogs_rbnode_t *uncle = gparent->right; 106| | 107| 2.66k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (107:17): [True: 1.58k, False: 1.08k] | Branch (107:26): [True: 1.13k, False: 446] ------------------ 108| | /* 109| | * node's uncle == red (color flips) 110| | * 111| | * G g 112| | * / \ / \ 113| | * p u --> P U 114| | * / / 115| | * n n 116| | */ 117| 1.13k| uncle->color = OGS_RBTREE_BLACK; 118| 1.13k| parent->color = OGS_RBTREE_BLACK; 119| | 120| 1.13k| gparent->color = OGS_RBTREE_RED; 121| | 122| 1.13k| node = gparent; 123| 1.53k| } else { 124| | /* node's uncle == black */ 125| 1.53k| if (node == parent->right) { ------------------ | Branch (125:21): [True: 929, False: 604] ------------------ 126| | /* 127| | * node == the parent's right child, 128| | * (left rotate at parent) 129| | * 130| | * G G 131| | * / \ / \ 132| | * p U --> p U 133| | * \ / 134| | * n n 135| | */ 136| 929| node = node->parent; 137| 929| rb_rotate_left(tree, node); 138| 929| } 139| | 140| | /* 141| | * Now we're the left child 142| | * (right rotate at grand parent) 143| | * 144| | * g P 145| | * / \ / \ 146| | * P U --> n g 147| | * / \ 148| | * n U 149| | */ 150| 1.53k| node->parent->color = OGS_RBTREE_BLACK; 151| 1.53k| gparent->color = OGS_RBTREE_RED; 152| 1.53k| rb_rotate_right(tree, gparent); 153| 1.53k| } 154| | /* parent == grandparent's right child */ 155| 4.17k| } else { 156| 4.17k| ogs_rbnode_t *uncle = gparent->left; 157| | 158| 4.17k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (158:17): [True: 2.88k, False: 1.28k] | Branch (158:26): [True: 2.17k, False: 705] ------------------ 159| | /* 160| | * node's uncle == red (color flips) 161| | * 162| | * G g 163| | * / \ / \ 164| | * u p --> U P 165| | * \ \ 166| | * n n 167| | */ 168| 2.17k| uncle->color = OGS_RBTREE_BLACK; 169| 2.17k| parent->color = OGS_RBTREE_BLACK; 170| | 171| 2.17k| gparent->color = OGS_RBTREE_RED; 172| | 173| 2.17k| node = gparent; 174| 2.17k| } else { 175| | /* node's uncle == black */ 176| 1.99k| if (node == parent->left) { ------------------ | Branch (176:21): [True: 714, False: 1.27k] ------------------ 177| | /* 178| | * node == the parent's left child, 179| | * (right rotate at parent) 180| | * 181| | * G G 182| | * / \ / \ 183| | * p U --> p U 184| | * / \ 185| | * n n 186| | */ 187| 714| node = node->parent; 188| 714| rb_rotate_right(tree, node); 189| 714| } 190| | 191| | /* 192| | * Now we're the right child, 193| | * (left rotate at grand parent) 194| | * 195| | * g P 196| | * / \ / \ 197| | * P U --> n g 198| | * \ \ 199| | * n U 200| | */ 201| 1.99k| node->parent->color = OGS_RBTREE_BLACK; 202| 1.99k| gparent->color = OGS_RBTREE_RED; 203| 1.99k| rb_rotate_left(tree, gparent); 204| 1.99k| } 205| 4.17k| } 206| 6.83k| } 207| | 208| 6.49k| ogs_assert(tree->root); ------------------ | | 113| 6.49k| do { \ | | 114| 6.49k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.49k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.49k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.49k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 6.49k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.49k] | | ------------------ ------------------ 209| 6.49k| tree->root->color = OGS_RBTREE_BLACK; 210| 6.49k|} ogs-rbtree.c:rb_rotate_left: 56| 2.92k|{ 57| 2.92k| ogs_rbnode_t *right = node->right; 58| 2.92k| node->right = right->left; 59| 2.92k| if (right->left) ------------------ | Branch (59:9): [True: 994, False: 1.92k] ------------------ 60| 994| right->left->parent = node; 61| | 62| 2.92k| rb_replace_node(tree, node, right, node->parent); 63| | 64| 2.92k| right->left = node; 65| 2.92k| node->parent = right; 66| 2.92k|} ogs-rbtree.c:rb_rotate_right: 80| 2.24k|{ 81| 2.24k| ogs_rbnode_t *left = node->left; 82| 2.24k| node->left = left->right; 83| 2.24k| if (left->right) ------------------ | Branch (83:9): [True: 618, False: 1.62k] ------------------ 84| 618| left->right->parent = node; 85| | 86| 2.24k| rb_replace_node(tree, node, left, node->parent); 87| | 88| 2.24k| left->right = node; 89| 2.24k| node->parent = left; 90| 2.24k|} ogs-rbtree.c:rb_replace_node: 37| 5.16k|{ 38| 5.16k| rb_change_child(tree, old, new, parent); 39| | 40| 5.16k| if (new) ------------------ | Branch (40:9): [True: 5.16k, False: 0] ------------------ 41| 5.16k| new->parent = parent; 42| 5.16k|} ogs-rbtree.c:rb_change_child: 24| 5.16k|{ 25| 5.16k| if (parent) { ------------------ | Branch (25:9): [True: 4.62k, False: 547] ------------------ 26| 4.62k| if (old == parent->left) ------------------ | Branch (26:13): [True: 2.02k, False: 2.59k] ------------------ 27| 2.02k| parent->left = new; 28| 2.59k| else 29| 2.59k| parent->right = new; 30| 4.62k| } else { 31| 547| tree->root = new; 32| 547| } 33| 5.16k|} ogs-tlv-msg.c:ogs_rbtree_link_node: 54| 6.49k|{ 55| 6.49k| ogs_rbnode_t *node = (ogs_rbnode_t *)rb_node; 56| 6.49k| node->parent = parent; 57| 6.49k| node->left = node->right = NULL; 58| 6.49k| node->color = OGS_RBTREE_RED; 59| | 60| 6.49k| *rb_link = node; 61| 6.49k|} ogs_socket_init: 36| 1|{ 37| |#if _WIN32 38| | WORD wVersionRequested; 39| | WSADATA wsaData; 40| | int err; 41| | 42| | wVersionRequested = MAKEWORD(2, 2); 43| | 44| | err = WSAStartup(wVersionRequested, &wsaData); 45| | ogs_assert(err == 0); 46| |#endif 47| 1|} ogs_vsnprintf: 63| 89.0k|{ 64| 89.0k| int r = -1; 65| | 66| | /* Microsoft has finally implemented snprintf in Visual Studio 2015. 67| | * In previous versions, I will simulate it as below. */ 68| |#if defined(_MSC_VER) && _MSC_VER < 1900 69| | ogs_assert(str); 70| | 71| | if (size != 0) 72| | r = _vsnprintf_s(str, size, _TRUNCATE, format, ap); 73| | 74| | if (r == -1) 75| | r = _vscprintf(format, ap); 76| |#else 77| 89.0k| r = vsnprintf(str, size, format, ap); 78| 89.0k|#endif 79| 89.0k| str[size-1] = '\0'; 80| | 81| 89.0k| return r; 82| 89.0k|} ogs_vslprintf: 97| 89.0k|{ 98| 89.0k| int r = -1; 99| | 100| 89.0k| ogs_assert(last); ------------------ | | 113| 89.0k| do { \ | | 114| 89.0k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 89.0k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 89.0k, False: 0] | | | | ------------------ | | ------------------ | | 115| 89.0k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 89.0k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 89.0k] | | ------------------ ------------------ 101| | 102| 89.0k| if (!str) ------------------ | Branch (102:9): [True: 0, False: 89.0k] ------------------ 103| 0| return NULL; 104| | 105| 89.0k| if (str < last) ------------------ | Branch (105:9): [True: 89.0k, False: 0] ------------------ 106| 89.0k| r = ogs_vsnprintf(str, last - str, format, ap); 107| | 108| 89.0k| return (str + r); 109| 89.0k|} ogs_slprintf: 112| 81.8k|{ 113| 81.8k| char *r; 114| 81.8k| va_list ap; 115| | 116| 81.8k| va_start(ap, format); 117| 81.8k| r = ogs_vslprintf(str, last, format, ap); 118| 81.8k| va_end(ap); 119| | 120| 81.8k| return r; 121| 81.8k|} ogs_gettimeofday: 74| 7.04k|{ 75| |#if defined(_WIN32) 76| |#if defined(_MSC_VER) 77| |#define DELTA_EPOCH_IN_MICROSEC 11644473600000000Ui64 78| |#else 79| |#define DELTA_EPOCH_IN_MICROSEC 11644473600000000ULL 80| |#endif 81| | FILETIME ft; 82| | uint64_t tmp = 0; 83| | 84| | /* 85| | * The const value is shamelessy stolen from 86| | * http://www.boost.org/doc/libs/1_55_0/boost/chrono/detail/inlined/win/chrono.hpp 87| | * 88| | * File times are the number of 100 nanosecond intervals elapsed since 89| | * 12:00 am Jan 1, 1601 UTC. I haven't check the math particularly hard 90| | * 91| | * ... good luck 92| | */ 93| | 94| | if (tv) { 95| | GetSystemTimeAsFileTime (&ft); 96| | 97| | /* pull out of the filetime into a 64 bit uint */ 98| | tmp |= ft.dwHighDateTime; 99| | tmp <<= 32; 100| | tmp |= ft.dwLowDateTime; 101| | 102| | /* convert from 100's of nanosecs to microsecs */ 103| | tmp /= 10; 104| | 105| | /* adjust to unix epoch */ 106| | tmp -= DELTA_EPOCH_IN_MICROSEC; 107| | 108| | tv->tv_sec = (long) (tmp / 1000000UL); 109| | tv->tv_usec = (long) (tmp % 1000000UL); 110| | } 111| | 112| | return 0; 113| |#else 114| 7.04k| int rc = gettimeofday(tv, NULL); 115| 7.04k| ogs_assert(rc == 0); ------------------ | | 113| 7.04k| do { \ | | 114| 7.04k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.04k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.04k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.04k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7.04k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.04k] | | ------------------ ------------------ 116| 7.04k| return 0; 117| 7.04k|#endif 118| 7.04k|} ogs_get_monotonic_time: 241| 3|{ 242| 3|#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) 243| 3| struct timespec ts; 244| 3| clock_gettime(CLOCK_MONOTONIC, &ts); 245| 3| return ogs_time_from_sec(ts.tv_sec) + ts.tv_nsec / 1000UL; ------------------ | | 97| 3|#define ogs_time_from_sec(sec) ((ogs_time_t)(sec) * OGS_USEC_PER_SEC) | | ------------------ | | | | 76| 3|#define OGS_USEC_PER_SEC (1000000LL) | | ------------------ ------------------ 246| |#elif defined(__APPLE__) 247| | static mach_timebase_info_data_t info = {0}; 248| | static double ratio = 0.0; 249| | 250| | if (!info.denom) { 251| | /* the value from mach_absolute_time () * info.numer / info.denom 252| | * is in nano seconds. So we have to divid by 1000.0 to get micro 253| | * seconds*/ 254| | mach_timebase_info(&info); 255| | ratio = (double) info.numer / (double) info.denom / 1000.0; 256| | } 257| | 258| | return mach_absolute_time() * ratio; 259| |#elif defined(_WIN32) 260| | /* Despite it's name, this is in milliseconds! */ 261| | ogs_time_t ticks = GetTickCount64(); 262| | return (ticks * 1000L); 263| |#elif defined(__hpux__) 264| | ogs_time_t nanosec = gethrtime(); 265| | return (nanosec / 1000UL); 266| |#else 267| |#warning "Monotonic clock is not yet supported on your platform." 268| | struct timeval tv; 269| | 270| | ogs_gettimeofday(&tv); 271| | return ogs_time_from_sec(tv.tv_sec) + tv.tv_usec; 272| |#endif 273| 3|} ogs_localtime: 276| 7.04k|{ 277| 7.04k| ogs_assert(tm); ------------------ | | 113| 7.04k| do { \ | | 114| 7.04k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.04k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.04k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.04k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7.04k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.04k] | | ------------------ ------------------ 278| 7.04k| memset(tm, 0, sizeof(*tm)); 279| | 280| 7.04k|#if (HAVE_LOCALTIME_R) 281| 7.04k| (void)localtime_r(&s, tm); 282| |#else 283| | struct tm *t; 284| | 285| | t = localtime(&s); 286| | *tm = *t; 287| |#endif 288| 7.04k|} ogs_tlv_parse_msg: 743| 449|{ 744| 449| int rv; 745| 449| ogs_tlv_t *root; 746| | 747| 449| ogs_assert(msg); ------------------ | | 113| 449| do { \ | | 114| 449| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 449|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 449, False: 0] | | | | ------------------ | | ------------------ | | 115| 449| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 449| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 449] | | ------------------ ------------------ 748| 449| ogs_assert(desc); ------------------ | | 113| 449| do { \ | | 114| 449| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 449|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 449, False: 0] | | | | ------------------ | | ------------------ | | 115| 449| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 449| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 449] | | ------------------ ------------------ 749| 449| ogs_assert(pkbuf); ------------------ | | 113| 449| do { \ | | 114| 449| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 449|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 449, False: 0] | | | | ------------------ | | ------------------ | | 115| 449| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 449| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 449] | | ------------------ ------------------ 750| | 751| 449| ogs_assert(desc->ctype == OGS_TLV_MESSAGE); ------------------ | | 113| 449| do { \ | | 114| 449| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 449|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 449, False: 0] | | | | ------------------ | | ------------------ | | 115| 449| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 449| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 449] | | ------------------ ------------------ 752| 449| if (!desc->child_descs[0]) { ------------------ | Branch (752:9): [True: 0, False: 449] ------------------ 753| 0| ogs_fatal("No Child Descs in [%s]", desc->name); ------------------ | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 754| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 755| 0| } 756| | 757| 449| root = ogs_tlv_parse_block(pkbuf->len, pkbuf->data, mode); 758| 449| if (root == NULL) { ------------------ | Branch (758:9): [True: 147, False: 302] ------------------ 759| 147| ogs_error("Can't parse TLV message"); ------------------ | | 36| 147|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 147| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 147|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 147| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 147|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 147| 0, __VA_ARGS__) | | ------------------ ------------------ 760| 147| return OGS_ERROR; ------------------ | | 78| 147|#define OGS_ERROR -1 ------------------ 761| 147| } 762| | 763| 302| rv = tlv_parse_compound(msg, desc, root, 0, mode); 764| | 765| 302| ogs_tlv_free_all(root); 766| | 767| 302| return rv; 768| 449|} ogs-tlv-msg.c:tlv_parse_compound: 643| 626|{ 644| 626| int rv; 645| 626| ogs_tlv_presence_t *presence_p = (ogs_tlv_presence_t *)msg; 646| 626| ogs_tlv_desc_t *desc = NULL, *next_desc = NULL; 647| 626| ogs_tlv_t *tlv = NULL, *emb_tlv = NULL; 648| 626| uint8_t *p = msg; 649| 626| uint32_t offset = 0; 650| 626| uint8_t index = 0; 651| 626| int i = 0, j; 652| 626| OGS_RBTREE(tree); ------------------ | | 48| 626|#define OGS_RBTREE(name) ogs_rbtree_t name = { NULL } ------------------ 653| 626| tlv_count_node_t count_node[OGS_TLV_MAX_CHILD_DESC]; 654| 626| unsigned count_node_alloc_next = 0; 655| 626| char indent[17] = " "; /* 16 spaces */ 656| | 657| 626| ogs_assert(msg); ------------------ | | 113| 626| do { \ | | 114| 626| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 626|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 626, False: 0] | | | | ------------------ | | ------------------ | | 115| 626| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 626| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 626] | | ------------------ ------------------ 658| 626| ogs_assert(parent_desc); ------------------ | | 113| 626| do { \ | | 114| 626| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 626|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 626, False: 0] | | | | ------------------ | | ------------------ | | 115| 626| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 626| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 626] | | ------------------ ------------------ 659| 626| ogs_assert(parent_tlv); ------------------ | | 113| 626| do { \ | | 114| 626| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 626|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 626, False: 0] | | | | ------------------ | | ------------------ | | 115| 626| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 626| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 626] | | ------------------ ------------------ 660| | 661| 626| ogs_assert(depth <= 8); ------------------ | | 113| 626| do { \ | | 114| 626| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 626|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 626, False: 0] | | | | ------------------ | | ------------------ | | 115| 626| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 626| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 626] | | ------------------ ------------------ 662| 626| indent[depth*2] = 0; 663| | 664| 626| tlv = parent_tlv; 665| 8.22k| while (tlv) { ------------------ | Branch (665:12): [True: 7.68k, False: 538] ------------------ 666| 7.68k| tlv_count_node_t *curr_count = tlv_count_node_find(&tree, &count_node[0], 667| 7.68k| OGS_ARRAY_SIZE(count_node), &count_node_alloc_next, tlv->type, tlv->instance); ------------------ | | 165| 7.68k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 668| 7.68k| if (!curr_count) ------------------ | Branch (668:13): [True: 1, False: 7.68k] ------------------ 669| 1| return OGS_ERROR; ------------------ | | 78| 1|#define OGS_ERROR -1 ------------------ 670| 7.68k| desc = tlv_find_desc_by_type_inst(&index, &offset, parent_desc, tlv->type, tlv->instance, curr_count->count); 671| 7.68k| if (desc == NULL) { ------------------ | Branch (671:13): [True: 6.32k, False: 1.36k] ------------------ 672| 6.32k| ogs_warn("Unknown TLV type [%d]", tlv->type); ------------------ | | 37| 6.32k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.32k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 6.32k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 6.32k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.32k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.32k| 0, __VA_ARGS__) | | ------------------ ------------------ 673| 6.32k| tlv = tlv->next; 674| 6.32k| continue; 675| 6.32k| } 676| | 677| 1.36k| presence_p = (ogs_tlv_presence_t *)(p + offset); 678| | 679| | /* Multiple of the same type TLV may be included */ 680| 1.36k| next_desc = parent_desc->child_descs[index+1]; 681| 1.36k| if (next_desc != NULL && next_desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (681:13): [True: 1.23k, False: 131] | Branch (681:34): [True: 719, False: 514] ------------------ 682| 4.86k| for (j = 0; j < next_desc->length; j++) { ------------------ | Branch (682:25): [True: 4.43k, False: 428] ------------------ 683| 4.43k| presence_p = 684| 4.43k| (ogs_tlv_presence_t *)(p + offset + desc->vsize * j); 685| 4.43k| if (*presence_p == 0) { ------------------ | Branch (685:21): [True: 291, False: 4.14k] ------------------ 686| 291| offset += desc->vsize * j; 687| 291| break; 688| 291| } 689| 4.43k| } 690| 719| if (j == next_desc->length) { ------------------ | Branch (690:17): [True: 428, False: 291] ------------------ 691| 428| ogs_fatal("Multiple of the same type TLV need more room"); ------------------ | | 35| 428|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | ------------------ | | | | 43| 428| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 428|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 428| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 428|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 428| 0, __VA_ARGS__) | | ------------------ ------------------ 692| 428| tlv = tlv->next; 693| 428| continue; 694| 428| } 695| 719| } else { 696| 645| curr_count->count++; 697| 645| } 698| | 699| 936| if (desc->ctype == OGS_TLV_COMPOUND) { ------------------ | Branch (699:13): [True: 349, False: 587] ------------------ 700| 349| emb_tlv = ogs_tlv_parse_embedded_block(tlv, mode); 701| 349| if (emb_tlv == NULL) { ------------------ | Branch (701:17): [True: 25, False: 324] ------------------ 702| 25| ogs_error("Error while parse TLV"); ------------------ | | 36| 25|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 25| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 25|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 25| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 25|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 25| 0, __VA_ARGS__) | | ------------------ ------------------ 703| 25| return OGS_ERROR; ------------------ | | 78| 25|#define OGS_ERROR -1 ------------------ 704| 25| } 705| | 706| 324| ogs_trace("PARSE %sC#%d [%s] T:%d I:%d (vsz=%d) off:%p ", ------------------ | | 40| 324|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 324| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 324|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 324| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 324|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 324| 0, __VA_ARGS__) | | ------------------ ------------------ 707| 324| indent, i++, desc->name, desc->type, desc->instance, 708| 324| desc->vsize, p + offset); 709| | 710| 324| offset += sizeof(ogs_tlv_presence_t); 711| | 712| 324| rv = tlv_parse_compound( 713| 324| p + offset, desc, emb_tlv, depth + 1, mode); 714| 324| if (rv != OGS_OK) { ------------------ | | 77| 324|#define OGS_OK 0 ------------------ | Branch (714:17): [True: 4, False: 320] ------------------ 715| 4| ogs_error("Can't parse compound TLV"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 4|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 716| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 717| 4| } 718| | 719| 320| *presence_p = 1; 720| 587| } else { 721| 587| ogs_trace("PARSE %sL#%d [%s] T:%d L:%d I:%d " ------------------ | | 40| 587|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 587| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 587|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 587| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 587|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 587| 0, __VA_ARGS__) | | ------------------ ------------------ 722| 587| "(cls:%d vsz:%d) off:%p ", 723| 587| indent, i++, desc->name, desc->type, desc->length, 724| 587| desc->instance, desc->ctype, desc->vsize, p + offset); 725| | 726| 587| rv = tlv_parse_leaf(p + offset, desc, tlv); 727| 587| if (rv != OGS_OK) { ------------------ | | 77| 587|#define OGS_OK 0 ------------------ | Branch (727:17): [True: 58, False: 529] ------------------ 728| 58| ogs_error("Can't parse leaf TLV"); ------------------ | | 36| 58|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 58| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 58|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 58| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 58|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 58| 0, __VA_ARGS__) | | ------------------ ------------------ 729| 58| return OGS_ERROR; ------------------ | | 78| 58|#define OGS_ERROR -1 ------------------ 730| 58| } 731| | 732| 529| *presence_p = 1; 733| 529| } 734| | 735| 849| tlv = tlv->next; 736| 849| } 737| | 738| 538| return OGS_OK; ------------------ | | 77| 538|#define OGS_OK 0 ------------------ 739| 626|} ogs-tlv-msg.c:tlv_count_node_find: 608| 7.68k|{ 609| 7.68k| ogs_rbnode_t **new = NULL; 610| 7.68k| ogs_rbnode_t *parent = NULL; 611| 7.68k| tlv_count_node_t *this; 612| | 613| 7.68k| uint64_t key = (((uint32_t)type)<<8) | instance; 614| | 615| 7.68k| new = &tree->root; 616| 38.0k| while (*new) { ------------------ | Branch (616:12): [True: 31.5k, False: 6.49k] ------------------ 617| 31.5k| this = ogs_rb_entry(*new, tlv_count_node_t, node); ------------------ | | 50| 31.5k|#define ogs_rb_entry(ptr, type, member) ogs_container_of(ptr, type, member) | | ------------------ | | | | 188| 31.5k| (type *)((unsigned char *)ptr - offsetof(type, member)) | | ------------------ ------------------ 618| 31.5k| parent = *new; 619| 31.5k| if (key < this->key) { ------------------ | Branch (619:13): [True: 12.2k, False: 19.3k] ------------------ 620| 12.2k| new = &(*new)->left; 621| 19.3k| } else if (key > this->key) { ------------------ | Branch (621:20): [True: 18.1k, False: 1.19k] ------------------ 622| 18.1k| new = &(*new)->right; 623| 18.1k| } else { /* found entry: */ 624| 1.19k| return this; 625| 1.19k| } 626| 31.5k| } 627| | 628| | /* No entry, need to add one: */ 629| 6.49k| if (*count_alloc_next == count_node_arr_len) { ------------------ | Branch (629:9): [True: 1, False: 6.49k] ------------------ 630| 1| ogs_error("This TLV has to many entries, can't parse"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 1|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 631| 1| return NULL; 632| 1| } 633| 6.49k| this = &count_node_arr[(*count_alloc_next)++]; 634| 6.49k| this->key = key; 635| 6.49k| this->count = 0; 636| 6.49k| ogs_rbtree_link_node(&this->node, parent, new); 637| 6.49k| ogs_rbtree_insert_color(tree, &this->node); 638| 6.49k| return this; 639| 6.49k|} ogs-tlv-msg.c:tlv_find_desc_by_type_inst: 456| 7.68k|{ 457| 7.68k| ogs_tlv_desc_t *prev_desc = NULL, *desc = NULL; 458| 7.68k| int i, offset = 0; 459| 7.68k| unsigned match_i = 0; 460| | 461| 7.68k| ogs_assert(parent_desc); ------------------ | | 113| 7.68k| do { \ | | 114| 7.68k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.68k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.68k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.68k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7.68k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.68k] | | ------------------ ------------------ 462| | 463| 225k| for (i = 0, desc = parent_desc->child_descs[i]; desc != NULL; ------------------ | Branch (463:53): [True: 218k, False: 6.32k] ------------------ 464| 218k| i++, desc = parent_desc->child_descs[i]) { 465| 218k| if (desc->type == match_type && desc->instance == match_instance) { ------------------ | Branch (465:13): [True: 3.44k, False: 215k] | Branch (465:41): [True: 1.61k, False: 1.83k] ------------------ 466| 1.61k| if (match_i == match_type_pos) { ------------------ | Branch (466:17): [True: 1.36k, False: 251] ------------------ 467| 1.36k| *desc_index = i; 468| 1.36k| *tlv_offset = offset; 469| 1.36k| break; 470| 1.36k| } 471| 251| match_i++; 472| 251| } 473| | 474| 217k| if (desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (474:13): [True: 3.49k, False: 213k] ------------------ 475| 3.49k| ogs_assert(prev_desc && prev_desc->ctype != OGS_TLV_MORE); ------------------ | | 113| 3.49k| do { \ | | 114| 3.49k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.98k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.49k, False: 0] | | | | | Branch (54:44): [True: 3.49k, False: 0] | | | | | Branch (54:44): [True: 3.49k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.49k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 3.49k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.49k] | | ------------------ ------------------ 476| 3.49k| offset += prev_desc->vsize * (desc->length - 1); 477| 213k| } else { 478| 213k| offset += desc->vsize; 479| 213k| } 480| | 481| 217k| prev_desc = desc; 482| 217k| } 483| | 484| 7.68k| return desc; 485| 7.68k|} ogs-tlv-msg.c:tlv_parse_leaf: 488| 587|{ 489| 587| ogs_assert(msg); ------------------ | | 113| 587| do { \ | | 114| 587| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 587|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 587, False: 0] | | | | ------------------ | | ------------------ | | 115| 587| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 587| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 587] | | ------------------ ------------------ 490| 587| ogs_assert(desc); ------------------ | | 113| 587| do { \ | | 114| 587| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 587|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 587, False: 0] | | | | ------------------ | | ------------------ | | 115| 587| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 587| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 587] | | ------------------ ------------------ 491| 587| ogs_assert(tlv); ------------------ | | 113| 587| do { \ | | 114| 587| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 587|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 587, False: 0] | | | | ------------------ | | ------------------ | | 115| 587| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 587| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 587] | | ------------------ ------------------ 492| | 493| 587| switch (desc->ctype) { 494| 0| case OGS_TV_UINT8: ------------------ | Branch (494:5): [True: 0, False: 587] ------------------ 495| 0| case OGS_TV_INT8: ------------------ | Branch (495:5): [True: 0, False: 587] ------------------ 496| 66| case OGS_TLV_UINT8: ------------------ | Branch (496:5): [True: 66, False: 521] ------------------ 497| 66| case OGS_TLV_INT8: ------------------ | Branch (497:5): [True: 0, False: 587] ------------------ 498| 66| { 499| 66| ogs_tlv_uint8_t *v = (ogs_tlv_uint8_t *)msg; 500| | 501| 66| if (tlv->length != 1) { ------------------ | Branch (501:13): [True: 22, False: 44] ------------------ 502| 22| ogs_error("Invalid TLV length %d. It should be 1", tlv->length); ------------------ | | 36| 22|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 22| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 22|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 22| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 22|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 22| 0, __VA_ARGS__) | | ------------------ ------------------ 503| 22| return OGS_ERROR; ------------------ | | 78| 22|#define OGS_ERROR -1 ------------------ 504| 22| } 505| 44| v->u8 = *(uint8_t*)(tlv->value); 506| 44| break; 507| 66| } 508| 0| case OGS_TV_UINT16: ------------------ | Branch (508:5): [True: 0, False: 587] ------------------ 509| 0| case OGS_TV_INT16: ------------------ | Branch (509:5): [True: 0, False: 587] ------------------ 510| 23| case OGS_TLV_UINT16: ------------------ | Branch (510:5): [True: 23, False: 564] ------------------ 511| 23| case OGS_TLV_INT16: ------------------ | Branch (511:5): [True: 0, False: 587] ------------------ 512| 23| { 513| 23| ogs_tlv_uint16_t *v = (ogs_tlv_uint16_t *)msg; 514| | 515| 23| if (tlv->length != 2) { ------------------ | Branch (515:13): [True: 14, False: 9] ------------------ 516| 14| ogs_error("Invalid TLV length %d. It should be 2", tlv->length); ------------------ | | 36| 14|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 14| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 14|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 14| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 14|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 14| 0, __VA_ARGS__) | | ------------------ ------------------ 517| 14| return OGS_ERROR; ------------------ | | 78| 14|#define OGS_ERROR -1 ------------------ 518| 14| } 519| 9| v->u16 = ((((uint8_t*)tlv->value)[0]<< 8)&0xff00) | 520| 9| ((((uint8_t*)tlv->value)[1] )&0x00ff); 521| 9| break; 522| 23| } 523| 0| case OGS_TV_UINT24: ------------------ | Branch (523:5): [True: 0, False: 587] ------------------ 524| 0| case OGS_TV_INT24: ------------------ | Branch (524:5): [True: 0, False: 587] ------------------ 525| 0| case OGS_TLV_UINT24: ------------------ | Branch (525:5): [True: 0, False: 587] ------------------ 526| 0| case OGS_TLV_INT24: ------------------ | Branch (526:5): [True: 0, False: 587] ------------------ 527| 0| { 528| 0| ogs_tlv_uint24_t *v = (ogs_tlv_uint24_t *)msg; 529| | 530| 0| if (tlv->length != 3) { ------------------ | Branch (530:13): [True: 0, False: 0] ------------------ 531| 0| ogs_error("Invalid TLV length %d. It should be 3", tlv->length); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 532| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 533| 0| } 534| 0| v->u24 = ((((uint8_t*)tlv->value)[0]<<16)&0x00ff0000) | 535| 0| ((((uint8_t*)tlv->value)[1]<< 8)&0x0000ff00) | 536| 0| ((((uint8_t*)tlv->value)[2] )&0x000000ff); 537| 0| break; 538| 0| } 539| 0| case OGS_TV_UINT32: ------------------ | Branch (539:5): [True: 0, False: 587] ------------------ 540| 0| case OGS_TV_INT32: ------------------ | Branch (540:5): [True: 0, False: 587] ------------------ 541| 48| case OGS_TLV_UINT32: ------------------ | Branch (541:5): [True: 48, False: 539] ------------------ 542| 48| case OGS_TLV_INT32: ------------------ | Branch (542:5): [True: 0, False: 587] ------------------ 543| 48| { 544| 48| ogs_tlv_uint32_t *v = (ogs_tlv_uint32_t *)msg; 545| | 546| 48| if (tlv->length != 4) { ------------------ | Branch (546:13): [True: 16, False: 32] ------------------ 547| 16| ogs_error("Invalid TLV length %d. It should be 4", tlv->length); ------------------ | | 36| 16|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 16| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 16|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 16| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 16|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 16| 0, __VA_ARGS__) | | ------------------ ------------------ 548| 16| return OGS_ERROR; ------------------ | | 78| 16|#define OGS_ERROR -1 ------------------ 549| 16| } 550| 32| v->u32 = ((((uint8_t*)tlv->value)[0]<<24)&0xff000000) | 551| 32| ((((uint8_t*)tlv->value)[1]<<16)&0x00ff0000) | 552| 32| ((((uint8_t*)tlv->value)[2]<< 8)&0x0000ff00) | 553| 32| ((((uint8_t*)tlv->value)[3] )&0x000000ff); 554| 32| break; 555| 48| } 556| 0| case OGS_TV_FIXED_STR: ------------------ | Branch (556:5): [True: 0, False: 587] ------------------ 557| 0| case OGS_TLV_FIXED_STR: ------------------ | Branch (557:5): [True: 0, False: 587] ------------------ 558| 0| { 559| 0| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 560| | 561| 0| if (tlv->length != desc->length) ------------------ | Branch (561:13): [True: 0, False: 0] ------------------ 562| 0| { 563| 0| ogs_error("Invalid TLV length %d. It should be %d", ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 564| 0| tlv->length, desc->length); 565| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 566| 0| } 567| | 568| 0| v->data = tlv->value; 569| 0| v->len = tlv->length; 570| 0| break; 571| 0| } 572| 444| case OGS_TLV_VAR_STR: ------------------ | Branch (572:5): [True: 444, False: 143] ------------------ 573| 444| { 574| 444| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 575| | 576| 444| v->data = tlv->value; 577| 444| v->len = tlv->length; 578| 444| break; 579| 0| } 580| 0| case OGS_TV_NULL: ------------------ | Branch (580:5): [True: 0, False: 587] ------------------ 581| 0| case OGS_TLV_NULL: ------------------ | Branch (581:5): [True: 0, False: 587] ------------------ 582| 0| { 583| 0| if (tlv->length != 0) { ------------------ | Branch (583:13): [True: 0, False: 0] ------------------ 584| 0| ogs_error("Invalid TLV length %d. It should be 0", tlv->length); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 585| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 586| 0| } 587| 0| break; 588| 0| } 589| 6| default: ------------------ | Branch (589:5): [True: 6, False: 581] ------------------ 590| 6| ogs_error("Unknown type[%d]", desc->ctype); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 6|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 591| 6| return OGS_ERROR; ------------------ | | 78| 6|#define OGS_ERROR -1 ------------------ 592| 587| } 593| | 594| 529| return OGS_OK; ------------------ | | 77| 529|#define OGS_OK 0 ------------------ 595| 587|} ogs_tlv_get: 30| 8.64k|{ 31| 8.64k| ogs_tlv_t *tlv = NULL; 32| | 33| | /* get tlv node from node pool */ 34| 8.64k| ogs_pool_alloc(&pool, &tlv); ------------------ | | 132| 8.64k|#define ogs_pool_alloc(pool, node) do { \ | | 133| 8.64k| *(node) = NULL; \ | | 134| 8.64k| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 8.64k, False: 0] | | ------------------ | | 135| 8.64k| (pool)->avail--; \ | | 136| 8.64k| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 8.64k| (pool)->free[(pool)->head] = NULL; \ | | 138| 8.64k| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 8.64k| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 8.64k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 8.64k| } \ | | 141| 8.64k|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 8.64k] | | ------------------ ------------------ 35| | 36| | /* check for error */ 37| 8.64k| if (!tlv) { ------------------ | Branch (37:9): [True: 0, False: 8.64k] ------------------ 38| 0| ogs_error("ogs_tlv_get() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 39| 0| return NULL; 40| 0| } 41| | 42| | /* initialize tlv node */ 43| 8.64k| memset(tlv, 0, sizeof(ogs_tlv_t)); 44| 8.64k| return tlv; 45| 8.64k|} ogs_tlv_free: 48| 8.64k|{ 49| | /* free tlv node to the node pool */ 50| | ogs_pool_free(&pool, tlv); ------------------ | | 143| 8.64k|#define ogs_pool_free(pool, node) do { \ | | 144| 8.64k| if ((pool)->avail < (pool)->size) { \ | | ------------------ | | | Branch (144:9): [True: 8.64k, False: 0] | | ------------------ | | 145| 8.64k| (pool)->avail++; \ | | 146| 8.64k| (pool)->free[(pool)->tail] = (void*)(node); \ | | 147| 8.64k| (pool)->tail = ((pool)->tail + 1) % ((pool)->size); \ | | 148| 8.64k| (pool)->index[ogs_pool_index(pool, node)-1] = NULL; \ | | ------------------ | | | | 152| 8.64k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 149| 8.64k| } \ | | 150| 8.64k|} while (0) | | ------------------ | | | Branch (150:10): [Folded, False: 8.64k] | | ------------------ ------------------ 51| 8.64k|} ogs_tlv_init: 54| 1|{ 55| | ogs_pool_init(&pool, ogs_core()->tlv.pool); ------------------ | | 52| 1|#define ogs_pool_init(pool, _size) do { \ | | 53| 1| int i; \ | | 54| 1| (pool)->name = #pool; \ | | 55| 1| (pool)->free = malloc(sizeof(*(pool)->free) * _size); \ | | 56| 1| ogs_assert((pool)->free); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 57| 1| (pool)->array = malloc(sizeof(*(pool)->array) * _size); \ | | 58| 1| ogs_assert((pool)->array); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 59| 1| (pool)->index = malloc(sizeof(*(pool)->index) * _size); \ | | 60| 1| ogs_assert((pool)->index); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 61| 1| (pool)->size = (pool)->avail = _size; \ | | 62| 1| (pool)->head = (pool)->tail = 0; \ | | 63| 513| for (i = 0; i < _size; i++) { \ | | ------------------ | | | Branch (63:17): [True: 512, False: 1] | | ------------------ | | 64| 512| (pool)->free[i] = &((pool)->array[i]); \ | | 65| 512| (pool)->index[i] = NULL; \ | | 66| 512| } \ | | 67| 1| \ | | 68| 1| (pool)->id_hash = ogs_hash_make(); \ | | 69| 1| ogs_assert((pool)->id_hash); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 70| 1|} while (0) | | ------------------ | | | Branch (70:10): [Folded, False: 1] | | ------------------ ------------------ 56| 1|} ogs_tlv_free_all: 69| 798|{ 70| | /* free all tlv node to the node pool */ 71| 798| ogs_tlv_t *iter = root; 72| 798| ogs_tlv_t *next = NULL; 73| 9.44k| while (iter) { ------------------ | Branch (73:12): [True: 8.64k, False: 798] ------------------ 74| 8.64k| if(iter->embedded != NULL) { ------------------ | Branch (74:12): [True: 324, False: 8.31k] ------------------ 75| 324| ogs_tlv_free_all(iter->embedded); 76| 324| } 77| 8.64k| next = iter->next; 78| 8.64k| ogs_tlv_free(iter); 79| 8.64k| iter = next; 80| 8.64k| } 81| 798|} tlv_get_element: 224| 8.64k|{ 225| 8.64k| uint8_t *pos = blk; 226| 8.64k| uint32_t header_length; 227| | 228| 8.64k| tlv->mode = mode; 229| | 230| 8.64k| switch(mode) { 231| 0| case OGS_TLV_MODE_T1_L1: ------------------ | | 32| 0|#define OGS_TLV_MODE_T1_L1 1 ------------------ | Branch (231:5): [True: 0, False: 8.64k] ------------------ 232| 0| header_length = 2; 233| 0| if (size < header_length) ------------------ | Branch (233:13): [True: 0, False: 0] ------------------ 234| 0| return NULL; 235| 0| tlv->type = *(pos++); 236| 0| tlv->length = *(pos++); 237| 0| break; 238| 0| case OGS_TLV_MODE_T1_L2: ------------------ | | 33| 0|#define OGS_TLV_MODE_T1_L2 2 ------------------ | Branch (238:5): [True: 0, False: 8.64k] ------------------ 239| 0| header_length = 3; 240| 0| if (size < header_length) ------------------ | Branch (240:13): [True: 0, False: 0] ------------------ 241| 0| return NULL; 242| 0| tlv->type = *(pos++); 243| 0| tlv->length = *(pos++) << 8; 244| 0| tlv->length += *(pos++); 245| 0| break; 246| 8.64k| case OGS_TLV_MODE_T1_L2_I1: ------------------ | | 34| 8.64k|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ | Branch (246:5): [True: 8.64k, False: 0] ------------------ 247| 8.64k| header_length = 4; 248| 8.64k| if (size < header_length) ------------------ | Branch (248:13): [True: 76, False: 8.56k] ------------------ 249| 76| return NULL; 250| 8.56k| tlv->type = *(pos++); 251| 8.56k| tlv->length = *(pos++) << 8; 252| 8.56k| tlv->length += *(pos++); 253| 8.56k| tlv->instance = *(pos++) & 0b00001111; 254| 8.56k| break; 255| 0| case OGS_TLV_MODE_T2_L2: ------------------ | | 35| 0|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (255:5): [True: 0, False: 8.64k] ------------------ 256| 0| header_length = 4; 257| 0| if (size < header_length) ------------------ | Branch (257:13): [True: 0, False: 0] ------------------ 258| 0| return NULL; 259| 0| tlv->type = *(pos++) << 8; 260| 0| tlv->type += *(pos++); 261| 0| tlv->length = *(pos++) << 8; 262| 0| tlv->length += *(pos++); 263| 0| break; 264| 0| case OGS_TLV_MODE_T1: ------------------ | | 36| 0|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (264:5): [True: 0, False: 8.64k] ------------------ 265| 0| header_length = 1; 266| 0| if (size < header_length) ------------------ | Branch (266:13): [True: 0, False: 0] ------------------ 267| 0| return NULL; 268| 0| tlv->type = *(pos++); 269| 0| tlv->length = 0; 270| 0| break; 271| 0| default: ------------------ | Branch (271:5): [True: 0, False: 8.64k] ------------------ 272| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 273| 0| break; 274| 8.64k| } 275| | 276| 8.56k| if (tlv->length > size - header_length) ------------------ | Branch (276:9): [True: 96, False: 8.47k] ------------------ 277| 96| return NULL; 278| | 279| 8.47k| tlv->value = pos; 280| | 281| 8.47k| return (pos + ogs_tlv_length(tlv)); ------------------ | | 67| 8.47k|#define ogs_tlv_length(pTlv) pTlv->length ------------------ 282| 8.56k|} ogs_tlv_parse_block: 463| 798|{ 464| 798| uint8_t *pos = data; 465| 798| uint8_t *blk = data; 466| | 467| 798| ogs_tlv_t *root = NULL; 468| 798| ogs_tlv_t *prev = NULL; 469| 798| ogs_tlv_t *curr = NULL; 470| | 471| 798| root = curr = ogs_tlv_get(); 472| 798| if (!curr) { ------------------ | Branch (472:9): [True: 0, False: 798] ------------------ 473| 0| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d] - no tlv", ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 474| 0| length, mode); 475| |/* 476| | * Limit hexdump size to avoid excessive logging when handling malformed 477| | * or intentionally crafted messages. This prevents log flooding and 478| | * secondary DoS effects while still providing enough data for debugging. 479| | */ 480| 0| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 0| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 0, False: 0] | | ------------------ ------------------ 481| 0| return NULL; 482| 0| } 483| | 484| 798| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 485| 798| if (!pos) { ------------------ | Branch (485:9): [True: 118, False: 680] ------------------ 486| 118| ogs_error("ogs_tlv_parse_block() failed[LEN:%u,MODE:%u] - parse error", ------------------ | | 36| 118|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 118| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 118|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 118| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 118|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 118| 0, __VA_ARGS__) | | ------------------ ------------------ 487| 118| length, mode); 488| |/* 489| | * Limit hexdump size to avoid excessive logging when handling malformed 490| | * or intentionally crafted messages. This prevents log flooding and 491| | * secondary DoS effects while still providing enough data for debugging. 492| | */ 493| 118| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 236| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 118|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 116, False: 2] | | ------------------ ------------------ 494| 118| ogs_tlv_free_all(root); 495| 118| return NULL; 496| 118| } 497| | 498| 8.47k| while(pos - blk < length) { ------------------ | Branch (498:11): [True: 7.84k, False: 626] ------------------ 499| 7.84k| prev = curr; 500| | 501| 7.84k| curr = ogs_tlv_get(); 502| 7.84k| if (!curr) { ------------------ | Branch (502:13): [True: 0, False: 7.84k] ------------------ 503| 0| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 504| 0| length, mode); 505| |/* 506| | * Limit hexdump size to avoid excessive logging when handling malformed 507| | * or intentionally crafted messages. This prevents log flooding and 508| | * secondary DoS effects while still providing enough data for debugging. 509| | */ 510| 0| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 0| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 0, False: 0] | | ------------------ ------------------ 511| | 512| 0| ogs_tlv_free_all(root); 513| 0| return NULL; 514| 0| } 515| 7.84k| prev->next = curr; 516| | 517| 7.84k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 518| 7.84k| if (!pos) { ------------------ | Branch (518:13): [True: 54, False: 7.79k] ------------------ 519| 54| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 54|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 54| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 54|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 54| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 54|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 54| 0, __VA_ARGS__) | | ------------------ ------------------ 520| 54| length, mode); 521| |/* 522| | * Limit hexdump size to avoid excessive logging when handling malformed 523| | * or intentionally crafted messages. This prevents log flooding and 524| | * secondary DoS effects while still providing enough data for debugging. 525| | */ 526| 54| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 108| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 54|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 44, False: 10] | | ------------------ ------------------ 527| | 528| 54| ogs_tlv_free_all(root); 529| 54| return NULL; 530| 54| } 531| 7.84k| } 532| | 533| 626| if (length != (pos - blk)) { ------------------ | Branch (533:9): [True: 0, False: 626] ------------------ 534| 0| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", length, mode); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 535| 0| ogs_error("POS[%p] BLK[%p] POS-BLK[%d]", pos, blk, (int)(pos - blk)); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 536| 0| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 0| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 0, False: 0] | | ------------------ ------------------ 537| | 538| 0| ogs_tlv_free_all(root); 539| 0| return NULL; 540| 0| } 541| | 542| 626| return root; 543| 626|} ogs_tlv_parse_embedded_block: 546| 349|{ 547| 349| tlv->embedded = ogs_tlv_parse_block(tlv->length, tlv->value, mode); 548| | 549| 349| return tlv->embedded; 550| 349|} ogs_gtp2_parse_msg: 2910| 469|{ 2911| 469| int rv = OGS_ERROR; ------------------ | | 78| 469|#define OGS_ERROR -1 ------------------ 2912| 469| ogs_gtp2_header_t *h = NULL; 2913| 469| uint16_t size = 0; 2914| | 2915| 469| ogs_assert(gtp2_message); ------------------ | | 113| 469| do { \ | | 114| 469| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 469|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 469, False: 0] | | | | ------------------ | | ------------------ | | 115| 469| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 469| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 469] | | ------------------ ------------------ 2916| 469| ogs_assert(pkbuf); ------------------ | | 113| 469| do { \ | | 114| 469| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 469|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 469, False: 0] | | | | ------------------ | | ------------------ | | 115| 469| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 469| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 469] | | ------------------ ------------------ 2917| 469| ogs_assert(pkbuf->len); ------------------ | | 113| 469| do { \ | | 114| 469| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 469|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 469, False: 0] | | | | ------------------ | | ------------------ | | 115| 469| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 469| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 469] | | ------------------ ------------------ 2918| | 2919| 469| h = (ogs_gtp2_header_t *)pkbuf->data; 2920| 469| ogs_assert(h); ------------------ | | 113| 469| do { \ | | 114| 469| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 469|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 469, False: 0] | | | | ------------------ | | ------------------ | | 115| 469| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 469| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 469] | | ------------------ ------------------ 2921| | 2922| 469| memset(gtp2_message, 0, sizeof(ogs_gtp2_message_t)); 2923| | 2924| 469| if (h->teid_presence) ------------------ | Branch (2924:9): [True: 13, False: 456] ------------------ 2925| 13| size = OGS_GTPV2C_HEADER_LEN; ------------------ | | 40| 13|#define OGS_GTPV2C_HEADER_LEN 12 ------------------ 2926| 456| else 2927| 456| size = OGS_GTPV2C_HEADER_LEN-OGS_GTP2_TEID_LEN; ------------------ | | 40| 456|#define OGS_GTPV2C_HEADER_LEN 12 ------------------ size = OGS_GTPV2C_HEADER_LEN-OGS_GTP2_TEID_LEN; ------------------ | | 41| 456|#define OGS_GTP2_TEID_LEN 4 ------------------ 2928| | 2929| 469| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2929:9): [True: 8, False: 461] ------------------ 2930| 8| ogs_error("ogs_pkbuf_pull() failed [len:%d]", pkbuf->len); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 8|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2931| 8| return OGS_ERROR; ------------------ | | 78| 8|#define OGS_ERROR -1 ------------------ 2932| 8| } 2933| 461| memcpy(>p2_message->h, pkbuf->data - size, size); 2934| | 2935| 461| if (h->teid_presence) ------------------ | Branch (2935:9): [True: 8, False: 453] ------------------ 2936| 8| gtp2_message->h.teid = be32toh(gtp2_message->h.teid); 2937| | 2938| 461| if (pkbuf->len == 0) { ------------------ | Branch (2938:9): [True: 2, False: 459] ------------------ 2939| 2| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 2| do { \ | | 114| 2| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 115| 2| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 2| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2] | | ------------------ ------------------ 2940| 2| return OGS_OK; ------------------ | | 77| 2|#define OGS_OK 0 ------------------ 2941| 2| } 2942| | 2943| 459| switch(gtp2_message->h.type) { 2944| 16| case OGS_GTP2_ECHO_REQUEST_TYPE: ------------------ | | 83| 16|#define OGS_GTP2_ECHO_REQUEST_TYPE 1 ------------------ | Branch (2944:5): [True: 16, False: 443] ------------------ 2945| 16| rv = ogs_tlv_parse_msg(>p2_message->echo_request, 2946| 16| &ogs_gtp2_tlv_desc_echo_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 16|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2947| 16| break; 2948| 15| case OGS_GTP2_ECHO_RESPONSE_TYPE: ------------------ | | 84| 15|#define OGS_GTP2_ECHO_RESPONSE_TYPE 2 ------------------ | Branch (2948:5): [True: 15, False: 444] ------------------ 2949| 15| rv = ogs_tlv_parse_msg(>p2_message->echo_response, 2950| 15| &ogs_gtp2_tlv_desc_echo_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 15|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2951| 15| break; 2952| 113| case OGS_GTP2_CREATE_SESSION_REQUEST_TYPE: ------------------ | | 86| 113|#define OGS_GTP2_CREATE_SESSION_REQUEST_TYPE 32 ------------------ | Branch (2952:5): [True: 113, False: 346] ------------------ 2953| 113| rv = ogs_tlv_parse_msg(>p2_message->create_session_request, 2954| 113| &ogs_gtp2_tlv_desc_create_session_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 113|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2955| 113| break; 2956| 49| case OGS_GTP2_CREATE_SESSION_RESPONSE_TYPE: ------------------ | | 87| 49|#define OGS_GTP2_CREATE_SESSION_RESPONSE_TYPE 33 ------------------ | Branch (2956:5): [True: 49, False: 410] ------------------ 2957| 49| rv = ogs_tlv_parse_msg(>p2_message->create_session_response, 2958| 49| &ogs_gtp2_tlv_desc_create_session_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 49|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2959| 49| break; 2960| 48| case OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE: ------------------ | | 88| 48|#define OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE 34 ------------------ | Branch (2960:5): [True: 48, False: 411] ------------------ 2961| 48| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_request, 2962| 48| &ogs_gtp2_tlv_desc_modify_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 48|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2963| 48| break; 2964| 100| case OGS_GTP2_MODIFY_BEARER_RESPONSE_TYPE: ------------------ | | 89| 100|#define OGS_GTP2_MODIFY_BEARER_RESPONSE_TYPE 35 ------------------ | Branch (2964:5): [True: 100, False: 359] ------------------ 2965| 100| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_response, 2966| 100| &ogs_gtp2_tlv_desc_modify_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 100|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2967| 100| break; 2968| 6| case OGS_GTP2_DELETE_SESSION_REQUEST_TYPE: ------------------ | | 90| 6|#define OGS_GTP2_DELETE_SESSION_REQUEST_TYPE 36 ------------------ | Branch (2968:5): [True: 6, False: 453] ------------------ 2969| 6| rv = ogs_tlv_parse_msg(>p2_message->delete_session_request, 2970| 6| &ogs_gtp2_tlv_desc_delete_session_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 6|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2971| 6| break; 2972| 4| case OGS_GTP2_DELETE_SESSION_RESPONSE_TYPE: ------------------ | | 91| 4|#define OGS_GTP2_DELETE_SESSION_RESPONSE_TYPE 37 ------------------ | Branch (2972:5): [True: 4, False: 455] ------------------ 2973| 4| rv = ogs_tlv_parse_msg(>p2_message->delete_session_response, 2974| 4| &ogs_gtp2_tlv_desc_delete_session_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2975| 4| break; 2976| 2| case OGS_GTP2_MODIFY_BEARER_COMMAND_TYPE: ------------------ | | 96| 2|#define OGS_GTP2_MODIFY_BEARER_COMMAND_TYPE 64 ------------------ | Branch (2976:5): [True: 2, False: 457] ------------------ 2977| 2| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_command, 2978| 2| &ogs_gtp2_tlv_desc_modify_bearer_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2979| 2| break; 2980| 2| case OGS_GTP2_MODIFY_BEARER_FAILURE_INDICATION_TYPE: ------------------ | | 97| 2|#define OGS_GTP2_MODIFY_BEARER_FAILURE_INDICATION_TYPE 65 ------------------ | Branch (2980:5): [True: 2, False: 457] ------------------ 2981| 2| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_failure_indication, 2982| 2| &ogs_gtp2_tlv_desc_modify_bearer_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2983| 2| break; 2984| 2| case OGS_GTP2_DELETE_BEARER_COMMAND_TYPE: ------------------ | | 98| 2|#define OGS_GTP2_DELETE_BEARER_COMMAND_TYPE 66 ------------------ | Branch (2984:5): [True: 2, False: 457] ------------------ 2985| 2| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_command, 2986| 2| &ogs_gtp2_tlv_desc_delete_bearer_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2987| 2| break; 2988| 4| case OGS_GTP2_DELETE_BEARER_FAILURE_INDICATION_TYPE: ------------------ | | 99| 4|#define OGS_GTP2_DELETE_BEARER_FAILURE_INDICATION_TYPE 67 ------------------ | Branch (2988:5): [True: 4, False: 455] ------------------ 2989| 4| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_failure_indication, 2990| 4| &ogs_gtp2_tlv_desc_delete_bearer_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2991| 4| break; 2992| 4| case OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE: ------------------ | | 100| 4|#define OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE 68 ------------------ | Branch (2992:5): [True: 4, False: 455] ------------------ 2993| 4| rv = ogs_tlv_parse_msg(>p2_message->bearer_resource_command, 2994| 4| &ogs_gtp2_tlv_desc_bearer_resource_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2995| 4| break; 2996| 6| case OGS_GTP2_BEARER_RESOURCE_FAILURE_INDICATION_TYPE: ------------------ | | 101| 6|#define OGS_GTP2_BEARER_RESOURCE_FAILURE_INDICATION_TYPE 69 ------------------ | Branch (2996:5): [True: 6, False: 453] ------------------ 2997| 6| rv = ogs_tlv_parse_msg(>p2_message->bearer_resource_failure_indication, 2998| 6| &ogs_gtp2_tlv_desc_bearer_resource_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 6|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2999| 6| break; 3000| 5| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_FAILURE_INDICATION_TYPE: ------------------ | | 102| 5|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_FAILURE_INDICATION_TYPE 70 ------------------ | Branch (3000:5): [True: 5, False: 454] ------------------ 3001| 5| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification_failure_indication, 3002| 5| &ogs_gtp2_tlv_desc_downlink_data_notification_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 5|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3003| 5| break; 3004| 4| case OGS_GTP2_CREATE_BEARER_REQUEST_TYPE: ------------------ | | 106| 4|#define OGS_GTP2_CREATE_BEARER_REQUEST_TYPE 95 ------------------ | Branch (3004:5): [True: 4, False: 455] ------------------ 3005| 4| rv = ogs_tlv_parse_msg(>p2_message->create_bearer_request, 3006| 4| &ogs_gtp2_tlv_desc_create_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3007| 4| break; 3008| 25| case OGS_GTP2_CREATE_BEARER_RESPONSE_TYPE: ------------------ | | 107| 25|#define OGS_GTP2_CREATE_BEARER_RESPONSE_TYPE 96 ------------------ | Branch (3008:5): [True: 25, False: 434] ------------------ 3009| 25| rv = ogs_tlv_parse_msg(>p2_message->create_bearer_response, 3010| 25| &ogs_gtp2_tlv_desc_create_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 25|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3011| 25| break; 3012| 6| case OGS_GTP2_UPDATE_BEARER_REQUEST_TYPE: ------------------ | | 108| 6|#define OGS_GTP2_UPDATE_BEARER_REQUEST_TYPE 97 ------------------ | Branch (3012:5): [True: 6, False: 453] ------------------ 3013| 6| rv = ogs_tlv_parse_msg(>p2_message->update_bearer_request, 3014| 6| &ogs_gtp2_tlv_desc_update_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 6|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3015| 6| break; 3016| 2| case OGS_GTP2_UPDATE_BEARER_RESPONSE_TYPE: ------------------ | | 109| 2|#define OGS_GTP2_UPDATE_BEARER_RESPONSE_TYPE 98 ------------------ | Branch (3016:5): [True: 2, False: 457] ------------------ 3017| 2| rv = ogs_tlv_parse_msg(>p2_message->update_bearer_response, 3018| 2| &ogs_gtp2_tlv_desc_update_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3019| 2| break; 3020| 1| case OGS_GTP2_DELETE_BEARER_REQUEST_TYPE: ------------------ | | 110| 1|#define OGS_GTP2_DELETE_BEARER_REQUEST_TYPE 99 ------------------ | Branch (3020:5): [True: 1, False: 458] ------------------ 3021| 1| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_request, 3022| 1| &ogs_gtp2_tlv_desc_delete_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3023| 1| break; 3024| 3| case OGS_GTP2_DELETE_BEARER_RESPONSE_TYPE: ------------------ | | 111| 3|#define OGS_GTP2_DELETE_BEARER_RESPONSE_TYPE 100 ------------------ | Branch (3024:5): [True: 3, False: 456] ------------------ 3025| 3| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_response, 3026| 3| &ogs_gtp2_tlv_desc_delete_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3027| 3| break; 3028| 3| case OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE: ------------------ | | 122| 3|#define OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE 166 ------------------ | Branch (3028:5): [True: 3, False: 456] ------------------ 3029| 3| rv = ogs_tlv_parse_msg(>p2_message->create_indirect_data_forwarding_tunnel_request, 3030| 3| &ogs_gtp2_tlv_desc_create_indirect_data_forwarding_tunnel_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3031| 3| break; 3032| 2| case OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE: ------------------ | | 123| 2|#define OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE 167 ------------------ | Branch (3032:5): [True: 2, False: 457] ------------------ 3033| 2| rv = ogs_tlv_parse_msg(>p2_message->create_indirect_data_forwarding_tunnel_response, 3034| 2| &ogs_gtp2_tlv_desc_create_indirect_data_forwarding_tunnel_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3035| 2| break; 3036| 3| case OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE: ------------------ | | 124| 3|#define OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE 168 ------------------ | Branch (3036:5): [True: 3, False: 456] ------------------ 3037| 3| break; 3038| 3| case OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE: ------------------ | | 125| 3|#define OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE 169 ------------------ | Branch (3038:5): [True: 3, False: 456] ------------------ 3039| 3| rv = ogs_tlv_parse_msg(>p2_message->delete_indirect_data_forwarding_tunnel_response, 3040| 3| &ogs_gtp2_tlv_desc_delete_indirect_data_forwarding_tunnel_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3041| 3| break; 3042| 2| case OGS_GTP2_RELEASE_ACCESS_BEARERS_REQUEST_TYPE: ------------------ | | 126| 2|#define OGS_GTP2_RELEASE_ACCESS_BEARERS_REQUEST_TYPE 170 ------------------ | Branch (3042:5): [True: 2, False: 457] ------------------ 3043| 2| rv = ogs_tlv_parse_msg(>p2_message->release_access_bearers_request, 3044| 2| &ogs_gtp2_tlv_desc_release_access_bearers_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3045| 2| break; 3046| 1| case OGS_GTP2_RELEASE_ACCESS_BEARERS_RESPONSE_TYPE: ------------------ | | 127| 1|#define OGS_GTP2_RELEASE_ACCESS_BEARERS_RESPONSE_TYPE 171 ------------------ | Branch (3046:5): [True: 1, False: 458] ------------------ 3047| 1| rv = ogs_tlv_parse_msg(>p2_message->release_access_bearers_response, 3048| 1| &ogs_gtp2_tlv_desc_release_access_bearers_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3049| 1| break; 3050| 4| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_TYPE: ------------------ | | 128| 4|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_TYPE 176 ------------------ | Branch (3050:5): [True: 4, False: 455] ------------------ 3051| 4| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification, 3052| 4| &ogs_gtp2_tlv_desc_downlink_data_notification, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3053| 4| break; 3054| 4| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_ACKNOWLEDGE_TYPE: ------------------ | | 129| 4|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_ACKNOWLEDGE_TYPE 177 ------------------ | Branch (3054:5): [True: 4, False: 455] ------------------ 3055| 4| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification_acknowledge, 3056| 4| &ogs_gtp2_tlv_desc_downlink_data_notification_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3057| 4| break; 3058| 5| case OGS_GTP2_MODIFY_ACCESS_BEARERS_REQUEST_TYPE: ------------------ | | 134| 5|#define OGS_GTP2_MODIFY_ACCESS_BEARERS_REQUEST_TYPE 211 ------------------ | Branch (3058:5): [True: 5, False: 454] ------------------ 3059| 5| rv = ogs_tlv_parse_msg(>p2_message->modify_access_bearers_request, 3060| 5| &ogs_gtp2_tlv_desc_modify_access_bearers_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 5|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3061| 5| break; 3062| 8| case OGS_GTP2_MODIFY_ACCESS_BEARERS_RESPONSE_TYPE: ------------------ | | 135| 8|#define OGS_GTP2_MODIFY_ACCESS_BEARERS_RESPONSE_TYPE 212 ------------------ | Branch (3062:5): [True: 8, False: 451] ------------------ 3063| 8| rv = ogs_tlv_parse_msg(>p2_message->modify_access_bearers_response, 3064| 8| &ogs_gtp2_tlv_desc_modify_access_bearers_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 8|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3065| 8| break; 3066| 7| default: ------------------ | Branch (3066:5): [True: 7, False: 452] ------------------ 3067| 7| ogs_warn("Not implemented(type:%d)", gtp2_message->h.type); ------------------ | | 37| 7|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 7|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 3068| 7| break; 3069| 459| } 3070| | 3071| 459| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 459| do { \ | | 114| 459| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 459|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 459, False: 0] | | | | ------------------ | | ------------------ | | 115| 459| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 459| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 459] | | ------------------ ------------------ 3072| | 3073| 459| return rv; 3074| 459|} initialize: 24| 1|void initialize(void) { 25| | 26| 1| ogs_pkbuf_config_t config; 27| | 28| 1| ogs_core_initialize(); 29| | 30| 1| ogs_pkbuf_default_init(&config); 31| 1| ogs_pkbuf_default_create(&config); 32| | 33| 1| initialized = 1; 34| 1|} LLVMFuzzerTestOneInput: 30| 495|{ /* open5gs/tests/non3gpp/gtp-path.c */ 31| | 32| 495| if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 26| 990|#define kMinInputLength 5 ------------------ if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 27| 491|#define kMaxInputLength 1024 ------------------ | Branch (32:9): [True: 4, False: 491] | Branch (32:35): [True: 22, False: 469] ------------------ 33| 26| return 1; 34| 26| } 35| | 36| 469| if (!initialized) { ------------------ | Branch (36:9): [True: 1, False: 468] ------------------ 37| 1| initialize(); 38| 1| ogs_log_install_domain(&__ogs_gtp_domain, "gtp", OGS_LOG_NONE); 39| 1| ogs_log_install_domain(&__ogs_tlv_domain, "tlv", OGS_LOG_NONE); 40| 1| } 41| | 42| 469| ogs_pkbuf_t *pkbuf; 43| 469| pkbuf = ogs_pkbuf_alloc(NULL, OGS_MAX_SDU_LEN); ------------------ | | 87| 469| ogs_pkbuf_alloc_debug(pool, size, OGS_FILE_LINE) | | ------------------ | | | | 213| 469|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 167| 469|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 168| 469|#define OGS_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 44| | 45| 469| if (pkbuf == NULL) { ------------------ | Branch (45:9): [True: 0, False: 469] ------------------ 46| 0| return 1; 47| 0| } 48| 469| ogs_pkbuf_put_data(pkbuf, Data, Size); 49| | 50| 469| ogs_gtp2_message_t gtp_message; 51| 469| ogs_gtp2_parse_msg(>p_message, pkbuf); 52| | 53| 469| ogs_pkbuf_free(pkbuf); 54| | 55| 469| return 0; 56| 469|}