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| 11.5k|{ 52| 11.5k| return list->next; 53| 11.5k|} ogs-log.c:ogs_list_next: 61| 8.62k|{ 62| 8.62k| ogs_list_t *node = (ogs_list_t *)lnode; 63| 8.62k| return node->next; 64| 8.62k|} 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| 11.5k|{ 405| 11.5k| ogs_log_t *log = NULL; 406| 11.5k| ogs_log_domain_t *domain = NULL; 407| | 408| 11.5k| char logstr[OGS_HUGE_LEN]; 409| 11.5k| char *p, *last; 410| | 411| 11.5k| int wrote_stderr = 0; 412| | 413| 11.5k| ogs_list_for_each(&log_list, log) { ------------------ | | 76| 20.1k| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 11.5k, False: 8.59k] | | ------------------ | | 77| 11.5k| node = ogs_list_next(node)) ------------------ 414| 11.5k| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 11.5k| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 11.5k, False: 0] | | | Branch (154:20): [True: 11.5k, False: 0] | | ------------------ ------------------ 415| 11.5k| if (!domain) { ------------------ | Branch (415:13): [True: 0, False: 11.5k] ------------------ 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| 11.5k| if (domain->level < level) ------------------ | Branch (419:13): [True: 2.98k, False: 8.59k] ------------------ 420| 2.98k| return; 421| | 422| 8.59k| p = logstr; 423| 8.59k| last = logstr + OGS_HUGE_LEN; ------------------ | | 210| 8.59k|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 424| | 425| 8.59k| if (!content_only) { ------------------ | Branch (425:13): [True: 8.44k, False: 152] ------------------ 426| 8.44k| if (log->print.timestamp) ------------------ | Branch (426:17): [True: 8.44k, False: 0] ------------------ 427| 8.44k| p = log_timestamp(p, last, log->print.color); 428| 8.44k| if (log->print.domain) ------------------ | Branch (428:17): [True: 8.44k, False: 0] ------------------ 429| 8.44k| p = log_domain(p, last, domain->name, log->print.color); 430| 8.44k| if (log->print.level) ------------------ | Branch (430:17): [True: 8.44k, False: 0] ------------------ 431| 8.44k| p = log_level(p, last, level, log->print.color); 432| 8.44k| } 433| | 434| 8.59k| p = log_content(p, last, format, ap); 435| | 436| 8.59k| if (err) { ------------------ | Branch (436:13): [True: 0, False: 8.59k] ------------------ 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| 8.59k| if (!content_only) { ------------------ | Branch (442:13): [True: 8.44k, False: 152] ------------------ 443| 8.44k| if (log->print.fileline) ------------------ | Branch (443:17): [True: 8.44k, False: 0] ------------------ 444| 8.44k| p = ogs_slprintf(p, last, " (%s:%d)", file, line); 445| 8.44k| if (log->print.function) ------------------ | Branch (445:17): [True: 0, False: 8.44k] ------------------ 446| 0| p = ogs_slprintf(p, last, " %s()", func); 447| 8.44k| if (log->print.linefeed) ------------------ | Branch (447:17): [True: 8.44k, False: 0] ------------------ 448| 8.44k| p = log_linefeed(p, last); 449| 8.44k| } 450| | 451| 8.59k| log->writer(log, level, logstr); 452| | 453| 8.59k| if (log->type == OGS_LOG_STDERR_TYPE) ------------------ | Branch (453:13): [True: 8.59k, False: 0] ------------------ 454| 8.59k| wrote_stderr = 1; 455| 8.59k| } 456| | 457| 8.59k| if (!wrote_stderr) ------------------ | Branch (457:9): [True: 0, False: 8.59k] ------------------ 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| 8.59k|} ogs_log_printf: 486| 11.5k|{ 487| 11.5k| va_list args; 488| | 489| 11.5k| va_start(args, format); 490| 11.5k| ogs_log_vprintf(level, id, 491| 11.5k| err, file, line, func, content_only, format, args); 492| | va_end(args); 493| 11.5k|} ogs_log_hexdump_func: 497| 181|{ 498| 181| size_t n, m; 499| 181| char dumpstr[OGS_HUGE_LEN]; 500| 181| 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| 181| if (!len) ------------------ | Branch (506:9): [True: 29, False: 152] ------------------ 507| 29| return; 508| | 509| 152| last = dumpstr + OGS_HUGE_LEN; ------------------ | | 210| 152|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 510| 152| p = dumpstr; 511| | 512| 1.65k| for (n = 0; n < len; n += 16) { ------------------ | Branch (512:17): [True: 1.50k, False: 152] ------------------ 513| 1.50k| p = ogs_slprintf(p, last, "%04x: ", (int)n); 514| | 515| 25.5k| for (m = n; m < n + 16; m++) { ------------------ | Branch (515:21): [True: 24.0k, False: 1.50k] ------------------ 516| 24.0k| if (m > n && (m % 4) == 0) ------------------ | Branch (516:17): [True: 22.5k, False: 1.50k] | Branch (516:26): [True: 4.50k, False: 18.0k] ------------------ 517| 4.50k| p = ogs_slprintf(p, last, " "); 518| 24.0k| if (m < len) ------------------ | Branch (518:17): [True: 22.7k, False: 1.32k] ------------------ 519| 22.7k| p = ogs_slprintf(p, last, "%02x", data[m]); 520| 1.32k| else 521| 1.32k| p = ogs_slprintf(p, last, " "); 522| 24.0k| } 523| | 524| 1.50k| p = ogs_slprintf(p, last, " "); 525| | 526| 24.2k| for (m = n; m < len && m < n + 16; m++) ------------------ | Branch (526:21): [True: 24.0k, False: 152] | Branch (526:32): [True: 22.7k, False: 1.35k] ------------------ 527| 22.7k| p = ogs_slprintf(p, last, "%c", isprint(data[m]) ? data[m] : '.'); ------------------ | Branch (527:45): [True: 2.92k, False: 19.7k] ------------------ 528| | 529| 1.50k| p = ogs_slprintf(p, last, "\n"); 530| 1.50k| } 531| | 532| | ogs_log_print(level, "%s", dumpstr); ------------------ | | 48| 152| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | ------------------ | | | | 32| 152|#define OGS_LOG_DOMAIN 1 | | ------------------ | | 49| 152| 0, NULL, 0, NULL, \ | | 50| 152| 1, __VA_ARGS__) ------------------ 533| 152|} 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| 8.44k|{ 572| 8.44k| struct timeval tv; 573| 8.44k| struct tm tm; 574| 8.44k| char nowstr[32]; 575| | 576| 8.44k| ogs_gettimeofday(&tv); 577| 8.44k| ogs_localtime(tv.tv_sec, &tm); 578| 8.44k| strftime(nowstr, sizeof nowstr, "%m/%d %H:%M:%S", &tm); 579| | 580| 8.44k| buf = ogs_slprintf(buf, last, "%s%s.%03d%s: ", 581| 8.44k| use_color ? TA_FGC_GREEN : "", ------------------ | | 37| 8.44k|#define TA_FGC_GREEN "\033[32m" /* Green */ ------------------ | Branch (581:13): [True: 8.44k, False: 0] ------------------ 582| 8.44k| nowstr, (int)(tv.tv_usec/1000), 583| 8.44k| use_color ? TA_NOR : ""); ------------------ | | 32| 8.44k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (583:13): [True: 8.44k, False: 0] ------------------ 584| | 585| 8.44k| return buf; 586| 8.44k|} ogs-log.c:log_domain: 590| 8.44k|{ 591| 8.44k| buf = ogs_slprintf(buf, last, "[%s%s%s] ", 592| 8.44k| use_color ? TA_FGC_YELLOW : "", ------------------ | | 39| 8.44k|#define TA_FGC_YELLOW "\033[33m" /* Yellow */ ------------------ | Branch (592:13): [True: 8.44k, False: 0] ------------------ 593| 8.44k| name, 594| 8.44k| use_color ? TA_NOR : ""); ------------------ | | 32| 8.44k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (594:13): [True: 8.44k, False: 0] ------------------ 595| | 596| 8.44k| return buf; 597| 8.44k|} ogs-log.c:log_level: 601| 8.44k|{ 602| 8.44k| const char *colors[] = { 603| 8.44k| TA_NOR, ------------------ | | 32| 8.44k|#define TA_NOR "\033[0m" /* all off */ ------------------ 604| 8.44k| TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 36| 8.44k|#define TA_FGC_BOLD_RED "\033[1;31m" /* Bold Red */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 40| 8.44k|#define TA_FGC_BOLD_YELLOW "\033[1;33m" /* Bold Yellow */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 43| 8.44k|#define TA_FGC_BOLD_CYAN "\033[1;36m" /* Bold Cyan */ ------------------ 605| 8.44k| TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 38| 8.44k|#define TA_FGC_BOLD_GREEN "\033[1;32m" /* Bold Green */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 45| 8.44k|#define TA_FGC_BOLD_WHITE "\033[1;37m" /* Bold White */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 44| 8.44k|#define TA_FGC_WHITE "\033[37m" /* White */ ------------------ 606| 8.44k| }; 607| | 608| 8.44k| buf = ogs_slprintf(buf, last, "%s%s%s: ", 609| 8.44k| use_color ? colors[level] : "", ------------------ | Branch (609:13): [True: 8.44k, False: 0] ------------------ 610| 8.44k| level_strings[level], 611| 8.44k| use_color ? TA_NOR : ""); ------------------ | | 32| 8.44k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (611:13): [True: 8.44k, False: 0] ------------------ 612| | 613| 8.44k| return buf; 614| 8.44k|} ogs-log.c:log_content: 618| 8.59k|{ 619| 8.59k| va_list bp; 620| | 621| 8.59k| va_copy(bp, ap); 622| 8.59k|#pragma GCC diagnostic push 623| 8.59k|#pragma GCC diagnostic ignored "-Wformat-nonliteral" 624| 8.59k| buf = ogs_vslprintf(buf, last, format, bp); 625| 8.59k|#pragma GCC diagnostic pop 626| 8.59k| va_end(bp); 627| | 628| 8.59k| return buf; 629| 8.59k|} ogs-log.c:log_linefeed: 632| 8.44k|{ 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| 8.44k| if (buf > last - 2) ------------------ | Branch (639:9): [True: 0, False: 8.44k] ------------------ 640| 0| buf = last - 2; 641| | 642| 8.44k| buf = ogs_slprintf(buf, last, "\n"); 643| 8.44k|#endif 644| | 645| 8.44k| return buf; 646| 8.44k|} ogs-log.c:file_writer: 650| 8.59k|{ 651| 8.59k| fprintf(log->file.out, "%s", string); 652| 8.59k| fflush(log->file.out); 653| 8.59k|} 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| 1.10k|{ 74| 1.10k| void *ptr = NULL; 75| | 76| 1.10k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 1.10k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 77| | 78| 1.10k| ptr = _talloc_zero(ctx, size, name); 79| 1.10k| ogs_expect(ptr); ------------------ | | 128| 1.10k| do { \ | | 129| 1.10k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.10k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.10k, False: 0] | | | | ------------------ | | ------------------ | | 130| 1.10k| 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| 1.10k| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 1.10k] | | ------------------ ------------------ 80| | 81| 1.10k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 1.10k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 82| | 83| 1.10k| return ptr; 84| 1.10k|} ogs_talloc_free: 102| 1.10k|{ 103| 1.10k| int ret; 104| | 105| 1.10k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 1.10k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 106| | 107| 1.10k| ret = _talloc_free(ptr, location); 108| | 109| 1.10k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 1.10k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 110| | 111| 1.10k| return ret; 112| 1.10k|} ogs_pkbuf_put_data: 91| 550|{ 92| 550| void *tmp = ogs_pkbuf_put(pkbuf, len); 93| | 94| 550| memcpy(tmp, data, len); 95| 550| return tmp; 96| 550|} 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| 550|{ 223| 550|#if OGS_USE_TALLOC == 1 224| 550| ogs_pkbuf_t *pkbuf = NULL; 225| | 226| 550| pkbuf = ogs_talloc_zero_size(pool, sizeof(*pkbuf) + size, file_line); 227| 550| if (!pkbuf) { ------------------ | Branch (227:9): [True: 0, False: 550] ------------------ 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| 550| pkbuf->head = pkbuf->_data; 233| 550| pkbuf->end = pkbuf->_data + size; 234| | 235| 550| pkbuf->len = 0; 236| | 237| 550| pkbuf->data = pkbuf->_data; 238| 550| pkbuf->tail = pkbuf->_data; 239| | 240| 550| pkbuf->file_line = file_line; /* For debug */ 241| | 242| 550| 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| 550|} ogs_pkbuf_free: 290| 550|{ 291| 550|#if OGS_USE_TALLOC == 1 292| 550| ogs_talloc_free(pkbuf, OGS_FILE_LINE); ------------------ | | 213| 550|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | ------------------ | | | | 167| 550|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | ------------------ | | | | | | 168| 550|#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| 550|} message.c:ogs_pkbuf_pull: 165| 550|{ 166| 550| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 550|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 7, False: 543] | | ------------------ ------------------ 167| 550| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 550|} message.c:ogs_pkbuf_pull_inline: 159| 543|{ 160| 543| pkbuf->len -= len; 161| 543| return pkbuf->data += len; 162| 543|} ogs-pkbuf.c:ogs_pkbuf_put: 115| 550|{ 116| 550| void *tmp = pkbuf->tail; 117| | 118| 550| if (ogs_unlikely(ogs_pkbuf_tailroom(pkbuf) < (int)len)) ------------------ | | 55| 550|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 550] | | ------------------ ------------------ 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| 550| pkbuf->tail += len; 122| 550| pkbuf->len += len; 123| | 124| 550| return tmp; 125| 550|} ogs-pkbuf.c:ogs_pkbuf_tailroom: 99| 550|{ 100| 550| return pkbuf->end - pkbuf->tail; 101| 550|} ogs_rbtree_insert_color: 93| 7.51k|{ 94| 7.51k| ogs_rbnode_t *node = rb_node; 95| 7.51k| ogs_rbnode_t *parent; 96| 7.51k| ogs_assert(tree); ------------------ | | 113| 7.51k| do { \ | | 114| 7.51k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.51k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.51k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.51k| 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.51k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.51k] | | ------------------ ------------------ 97| 7.51k| ogs_assert(node); ------------------ | | 113| 7.51k| do { \ | | 114| 7.51k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.51k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.51k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.51k| 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.51k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.51k] | | ------------------ ------------------ 98| | 99| 12.9k| while ((parent = node->parent) && parent->color == OGS_RBTREE_RED) { ------------------ | Branch (99:12): [True: 10.8k, False: 2.02k] | Branch (99:39): [True: 5.40k, False: 5.49k] ------------------ 100| 5.40k| ogs_rbnode_t *gparent = parent->parent; 101| 5.40k| ogs_assert(gparent); ------------------ | | 113| 5.40k| do { \ | | 114| 5.40k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 5.40k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 5.40k, False: 0] | | | | ------------------ | | ------------------ | | 115| 5.40k| 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| 5.40k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 5.40k] | | ------------------ ------------------ 102| | 103| | /* parent == grandparent's left child */ 104| 5.40k| if (parent == gparent->left) { ------------------ | Branch (104:13): [True: 2.51k, False: 2.89k] ------------------ 105| 2.51k| ogs_rbnode_t *uncle = gparent->right; 106| | 107| 2.51k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (107:17): [True: 1.45k, False: 1.05k] | Branch (107:26): [True: 1.13k, False: 320] ------------------ 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.37k| } else { 124| | /* node's uncle == black */ 125| 1.37k| if (node == parent->right) { ------------------ | Branch (125:21): [True: 768, False: 610] ------------------ 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| 768| node = node->parent; 137| 768| rb_rotate_left(tree, node); 138| 768| } 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.37k| node->parent->color = OGS_RBTREE_BLACK; 151| 1.37k| gparent->color = OGS_RBTREE_RED; 152| 1.37k| rb_rotate_right(tree, gparent); 153| 1.37k| } 154| | /* parent == grandparent's right child */ 155| 2.89k| } else { 156| 2.89k| ogs_rbnode_t *uncle = gparent->left; 157| | 158| 2.89k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (158:17): [True: 1.77k, False: 1.11k] | Branch (158:26): [True: 1.40k, False: 369] ------------------ 159| | /* 160| | * node's uncle == red (color flips) 161| | * 162| | * G g 163| | * / \ / \ 164| | * u p --> U P 165| | * \ \ 166| | * n n 167| | */ 168| 1.40k| uncle->color = OGS_RBTREE_BLACK; 169| 1.40k| parent->color = OGS_RBTREE_BLACK; 170| | 171| 1.40k| gparent->color = OGS_RBTREE_RED; 172| | 173| 1.40k| node = gparent; 174| 1.48k| } else { 175| | /* node's uncle == black */ 176| 1.48k| if (node == parent->left) { ------------------ | Branch (176:21): [True: 761, False: 722] ------------------ 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| 761| node = node->parent; 188| 761| rb_rotate_right(tree, node); 189| 761| } 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.48k| node->parent->color = OGS_RBTREE_BLACK; 202| 1.48k| gparent->color = OGS_RBTREE_RED; 203| 1.48k| rb_rotate_left(tree, gparent); 204| 1.48k| } 205| 2.89k| } 206| 5.40k| } 207| | 208| 7.51k| ogs_assert(tree->root); ------------------ | | 113| 7.51k| do { \ | | 114| 7.51k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.51k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.51k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.51k| 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.51k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.51k] | | ------------------ ------------------ 209| 7.51k| tree->root->color = OGS_RBTREE_BLACK; 210| 7.51k|} ogs-rbtree.c:rb_rotate_left: 56| 2.25k|{ 57| 2.25k| ogs_rbnode_t *right = node->right; 58| 2.25k| node->right = right->left; 59| 2.25k| if (right->left) ------------------ | Branch (59:9): [True: 552, False: 1.69k] ------------------ 60| 552| right->left->parent = node; 61| | 62| 2.25k| rb_replace_node(tree, node, right, node->parent); 63| | 64| 2.25k| right->left = node; 65| 2.25k| node->parent = right; 66| 2.25k|} ogs-rbtree.c:rb_rotate_right: 80| 2.13k|{ 81| 2.13k| ogs_rbnode_t *left = node->left; 82| 2.13k| node->left = left->right; 83| 2.13k| if (left->right) ------------------ | Branch (83:9): [True: 501, False: 1.63k] ------------------ 84| 501| left->right->parent = node; 85| | 86| 2.13k| rb_replace_node(tree, node, left, node->parent); 87| | 88| 2.13k| left->right = node; 89| 2.13k| node->parent = left; 90| 2.13k|} ogs-rbtree.c:rb_replace_node: 37| 4.39k|{ 38| 4.39k| rb_change_child(tree, old, new, parent); 39| | 40| 4.39k| if (new) ------------------ | Branch (40:9): [True: 4.39k, False: 0] ------------------ 41| 4.39k| new->parent = parent; 42| 4.39k|} ogs-rbtree.c:rb_change_child: 24| 4.39k|{ 25| 4.39k| if (parent) { ------------------ | Branch (25:9): [True: 3.75k, False: 640] ------------------ 26| 3.75k| if (old == parent->left) ------------------ | Branch (26:13): [True: 1.82k, False: 1.92k] ------------------ 27| 1.82k| parent->left = new; 28| 1.92k| else 29| 1.92k| parent->right = new; 30| 3.75k| } else { 31| 640| tree->root = new; 32| 640| } 33| 4.39k|} ogs-tlv-msg.c:ogs_rbtree_link_node: 54| 7.51k|{ 55| 7.51k| ogs_rbnode_t *node = (ogs_rbnode_t *)rb_node; 56| 7.51k| node->parent = parent; 57| 7.51k| node->left = node->right = NULL; 58| 7.51k| node->color = OGS_RBTREE_RED; 59| | 60| 7.51k| *rb_link = node; 61| 7.51k|} 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| 106k|{ 64| 106k| 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| 106k| r = vsnprintf(str, size, format, ap); 78| 106k|#endif 79| 106k| str[size-1] = '\0'; 80| | 81| 106k| return r; 82| 106k|} ogs_vslprintf: 97| 106k|{ 98| 106k| int r = -1; 99| | 100| 106k| ogs_assert(last); ------------------ | | 113| 106k| do { \ | | 114| 106k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 106k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 106k, False: 0] | | | | ------------------ | | ------------------ | | 115| 106k| 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| 106k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 106k] | | ------------------ ------------------ 101| | 102| 106k| if (!str) ------------------ | Branch (102:9): [True: 0, False: 106k] ------------------ 103| 0| return NULL; 104| | 105| 106k| if (str < last) ------------------ | Branch (105:9): [True: 106k, False: 0] ------------------ 106| 106k| r = ogs_vsnprintf(str, last - str, format, ap); 107| | 108| 106k| return (str + r); 109| 106k|} ogs_slprintf: 112| 98.0k|{ 113| 98.0k| char *r; 114| 98.0k| va_list ap; 115| | 116| 98.0k| va_start(ap, format); 117| 98.0k| r = ogs_vslprintf(str, last, format, ap); 118| 98.0k| va_end(ap); 119| | 120| 98.0k| return r; 121| 98.0k|} ogs_gettimeofday: 74| 8.44k|{ 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| 8.44k| int rc = gettimeofday(tv, NULL); 115| 8.44k| ogs_assert(rc == 0); ------------------ | | 113| 8.44k| do { \ | | 114| 8.44k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 8.44k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 8.44k, False: 0] | | | | ------------------ | | ------------------ | | 115| 8.44k| 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| 8.44k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 8.44k] | | ------------------ ------------------ 116| 8.44k| return 0; 117| 8.44k|#endif 118| 8.44k|} 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| 8.44k|{ 277| 8.44k| ogs_assert(tm); ------------------ | | 113| 8.44k| do { \ | | 114| 8.44k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 8.44k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 8.44k, False: 0] | | | | ------------------ | | ------------------ | | 115| 8.44k| 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| 8.44k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 8.44k] | | ------------------ ------------------ 278| 8.44k| memset(tm, 0, sizeof(*tm)); 279| | 280| 8.44k|#if (HAVE_LOCALTIME_R) 281| 8.44k| (void)localtime_r(&s, tm); 282| |#else 283| | struct tm *t; 284| | 285| | t = localtime(&s); 286| | *tm = *t; 287| |#endif 288| 8.44k|} ogs_tlv_parse_msg: 743| 534|{ 744| 534| int rv; 745| 534| ogs_tlv_t *root; 746| | 747| 534| ogs_assert(msg); ------------------ | | 113| 534| do { \ | | 114| 534| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 534|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 534, False: 0] | | | | ------------------ | | ------------------ | | 115| 534| 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| 534| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 534] | | ------------------ ------------------ 748| 534| ogs_assert(desc); ------------------ | | 113| 534| do { \ | | 114| 534| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 534|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 534, False: 0] | | | | ------------------ | | ------------------ | | 115| 534| 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| 534| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 534] | | ------------------ ------------------ 749| 534| ogs_assert(pkbuf); ------------------ | | 113| 534| do { \ | | 114| 534| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 534|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 534, False: 0] | | | | ------------------ | | ------------------ | | 115| 534| 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| 534| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 534] | | ------------------ ------------------ 750| | 751| 534| ogs_assert(desc->ctype == OGS_TLV_MESSAGE); ------------------ | | 113| 534| do { \ | | 114| 534| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 534|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 534, False: 0] | | | | ------------------ | | ------------------ | | 115| 534| 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| 534| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 534] | | ------------------ ------------------ 752| 534| if (!desc->child_descs[0]) { ------------------ | Branch (752:9): [True: 0, False: 534] ------------------ 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| 534| root = ogs_tlv_parse_block(pkbuf->len, pkbuf->data, mode); 758| 534| if (root == NULL) { ------------------ | Branch (758:9): [True: 149, False: 385] ------------------ 759| 149| ogs_error("Can't parse TLV message"); ------------------ | | 36| 149|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 149| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 149|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 149| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 149|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 149| 0, __VA_ARGS__) | | ------------------ ------------------ 760| 149| return OGS_ERROR; ------------------ | | 78| 149|#define OGS_ERROR -1 ------------------ 761| 149| } 762| | 763| 385| rv = tlv_parse_compound(msg, desc, root, 0, mode); 764| | 765| 385| ogs_tlv_free_all(root); 766| | 767| 385| return rv; 768| 534|} ogs-tlv-msg.c:tlv_parse_compound: 643| 1.54k|{ 644| 1.54k| int rv; 645| 1.54k| ogs_tlv_presence_t *presence_p = (ogs_tlv_presence_t *)msg; 646| 1.54k| ogs_tlv_desc_t *desc = NULL, *next_desc = NULL; 647| 1.54k| ogs_tlv_t *tlv = NULL, *emb_tlv = NULL; 648| 1.54k| uint8_t *p = msg; 649| 1.54k| uint32_t offset = 0; 650| 1.54k| uint8_t index = 0; 651| 1.54k| int i = 0, j; 652| 1.54k| OGS_RBTREE(tree); ------------------ | | 48| 1.54k|#define OGS_RBTREE(name) ogs_rbtree_t name = { NULL } ------------------ 653| 1.54k| tlv_count_node_t count_node[OGS_TLV_MAX_CHILD_DESC]; 654| 1.54k| unsigned count_node_alloc_next = 0; 655| 1.54k| char indent[17] = " "; /* 16 spaces */ 656| | 657| 1.54k| ogs_assert(msg); ------------------ | | 113| 1.54k| do { \ | | 114| 1.54k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.54k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.54k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.54k| 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.54k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.54k] | | ------------------ ------------------ 658| 1.54k| ogs_assert(parent_desc); ------------------ | | 113| 1.54k| do { \ | | 114| 1.54k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.54k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.54k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.54k| 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.54k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.54k] | | ------------------ ------------------ 659| 1.54k| ogs_assert(parent_tlv); ------------------ | | 113| 1.54k| do { \ | | 114| 1.54k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.54k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.54k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.54k| 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.54k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.54k] | | ------------------ ------------------ 660| | 661| 1.54k| ogs_assert(depth <= 8); ------------------ | | 113| 1.54k| do { \ | | 114| 1.54k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.54k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.54k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.54k| 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.54k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.54k] | | ------------------ ------------------ 662| 1.54k| indent[depth*2] = 0; 663| | 664| 1.54k| tlv = parent_tlv; 665| 12.0k| while (tlv) { ------------------ | Branch (665:12): [True: 10.6k, False: 1.40k] ------------------ 666| 10.6k| tlv_count_node_t *curr_count = tlv_count_node_find(&tree, &count_node[0], 667| 10.6k| OGS_ARRAY_SIZE(count_node), &count_node_alloc_next, tlv->type, tlv->instance); ------------------ | | 165| 10.6k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 668| 10.6k| if (!curr_count) ------------------ | Branch (668:13): [True: 3, False: 10.6k] ------------------ 669| 3| return OGS_ERROR; ------------------ | | 78| 3|#define OGS_ERROR -1 ------------------ 670| 10.6k| desc = tlv_find_desc_by_type_inst(&index, &offset, parent_desc, tlv->type, tlv->instance, curr_count->count); 671| 10.6k| if (desc == NULL) { ------------------ | Branch (671:13): [True: 7.77k, False: 2.87k] ------------------ 672| 7.77k| ogs_warn("Unknown TLV type [%d]", tlv->type); ------------------ | | 37| 7.77k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7.77k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 7.77k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 7.77k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7.77k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7.77k| 0, __VA_ARGS__) | | ------------------ ------------------ 673| 7.77k| tlv = tlv->next; 674| 7.77k| continue; 675| 7.77k| } 676| | 677| 2.87k| presence_p = (ogs_tlv_presence_t *)(p + offset); 678| | 679| | /* Multiple of the same type TLV may be included */ 680| 2.87k| next_desc = parent_desc->child_descs[index+1]; 681| 2.87k| if (next_desc != NULL && next_desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (681:13): [True: 2.70k, False: 169] | Branch (681:34): [True: 1.82k, False: 886] ------------------ 682| 10.2k| for (j = 0; j < next_desc->length; j++) { ------------------ | Branch (682:25): [True: 9.95k, False: 309] ------------------ 683| 9.95k| presence_p = 684| 9.95k| (ogs_tlv_presence_t *)(p + offset + desc->vsize * j); 685| 9.95k| if (*presence_p == 0) { ------------------ | Branch (685:21): [True: 1.51k, False: 8.44k] ------------------ 686| 1.51k| offset += desc->vsize * j; 687| 1.51k| break; 688| 1.51k| } 689| 9.95k| } 690| 1.82k| if (j == next_desc->length) { ------------------ | Branch (690:17): [True: 309, False: 1.51k] ------------------ 691| 309| ogs_fatal("Multiple of the same type TLV need more room"); ------------------ | | 35| 309|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | ------------------ | | | | 43| 309| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 309|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 309| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 309|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 309| 0, __VA_ARGS__) | | ------------------ ------------------ 692| 309| tlv = tlv->next; 693| 309| continue; 694| 309| } 695| 1.82k| } else { 696| 1.05k| curr_count->count++; 697| 1.05k| } 698| | 699| 2.56k| if (desc->ctype == OGS_TLV_COMPOUND) { ------------------ | Branch (699:13): [True: 1.19k, False: 1.37k] ------------------ 700| 1.19k| emb_tlv = ogs_tlv_parse_embedded_block(tlv, mode); 701| 1.19k| if (emb_tlv == NULL) { ------------------ | Branch (701:17): [True: 32, False: 1.16k] ------------------ 702| 32| ogs_error("Error while parse TLV"); ------------------ | | 36| 32|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 32| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 32|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 32| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 32|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 32| 0, __VA_ARGS__) | | ------------------ ------------------ 703| 32| return OGS_ERROR; ------------------ | | 78| 32|#define OGS_ERROR -1 ------------------ 704| 32| } 705| | 706| 1.16k| ogs_trace("PARSE %sC#%d [%s] T:%d I:%d (vsz=%d) off:%p ", ------------------ | | 40| 1.16k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.16k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 1.16k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 1.16k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.16k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.16k| 0, __VA_ARGS__) | | ------------------ ------------------ 707| 1.16k| indent, i++, desc->name, desc->type, desc->instance, 708| 1.16k| desc->vsize, p + offset); 709| | 710| 1.16k| offset += sizeof(ogs_tlv_presence_t); 711| | 712| 1.16k| rv = tlv_parse_compound( 713| 1.16k| p + offset, desc, emb_tlv, depth + 1, mode); 714| 1.16k| if (rv != OGS_OK) { ------------------ | | 77| 1.16k|#define OGS_OK 0 ------------------ | Branch (714:17): [True: 40, False: 1.12k] ------------------ 715| 40| ogs_error("Can't parse compound TLV"); ------------------ | | 36| 40|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 40| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 40|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 40| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 40|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 40| 0, __VA_ARGS__) | | ------------------ ------------------ 716| 40| return OGS_ERROR; ------------------ | | 78| 40|#define OGS_ERROR -1 ------------------ 717| 40| } 718| | 719| 1.12k| *presence_p = 1; 720| 1.37k| } else { 721| 1.37k| ogs_trace("PARSE %sL#%d [%s] T:%d L:%d I:%d " ------------------ | | 40| 1.37k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.37k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 1.37k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 1.37k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.37k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.37k| 0, __VA_ARGS__) | | ------------------ ------------------ 722| 1.37k| "(cls:%d vsz:%d) off:%p ", 723| 1.37k| indent, i++, desc->name, desc->type, desc->length, 724| 1.37k| desc->instance, desc->ctype, desc->vsize, p + offset); 725| | 726| 1.37k| rv = tlv_parse_leaf(p + offset, desc, tlv); 727| 1.37k| if (rv != OGS_OK) { ------------------ | | 77| 1.37k|#define OGS_OK 0 ------------------ | Branch (727:17): [True: 69, False: 1.30k] ------------------ 728| 69| ogs_error("Can't parse leaf TLV"); ------------------ | | 36| 69|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 69| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 69|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 69| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 69|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 69| 0, __VA_ARGS__) | | ------------------ ------------------ 729| 69| return OGS_ERROR; ------------------ | | 78| 69|#define OGS_ERROR -1 ------------------ 730| 69| } 731| | 732| 1.30k| *presence_p = 1; 733| 1.30k| } 734| | 735| 2.42k| tlv = tlv->next; 736| 2.42k| } 737| | 738| 1.40k| return OGS_OK; ------------------ | | 77| 1.40k|#define OGS_OK 0 ------------------ 739| 1.54k|} ogs-tlv-msg.c:tlv_count_node_find: 608| 10.6k|{ 609| 10.6k| ogs_rbnode_t **new = NULL; 610| 10.6k| ogs_rbnode_t *parent = NULL; 611| 10.6k| tlv_count_node_t *this; 612| | 613| 10.6k| uint64_t key = (((uint32_t)type)<<8) | instance; 614| | 615| 10.6k| new = &tree->root; 616| 38.9k| while (*new) { ------------------ | Branch (616:12): [True: 31.4k, False: 7.51k] ------------------ 617| 31.4k| this = ogs_rb_entry(*new, tlv_count_node_t, node); ------------------ | | 50| 31.4k|#define ogs_rb_entry(ptr, type, member) ogs_container_of(ptr, type, member) | | ------------------ | | | | 188| 31.4k| (type *)((unsigned char *)ptr - offsetof(type, member)) | | ------------------ ------------------ 618| 31.4k| parent = *new; 619| 31.4k| if (key < this->key) { ------------------ | Branch (619:13): [True: 14.1k, False: 17.3k] ------------------ 620| 14.1k| new = &(*new)->left; 621| 17.3k| } else if (key > this->key) { ------------------ | Branch (621:20): [True: 14.1k, False: 3.13k] ------------------ 622| 14.1k| new = &(*new)->right; 623| 14.1k| } else { /* found entry: */ 624| 3.13k| return this; 625| 3.13k| } 626| 31.4k| } 627| | 628| | /* No entry, need to add one: */ 629| 7.51k| if (*count_alloc_next == count_node_arr_len) { ------------------ | Branch (629:9): [True: 3, False: 7.51k] ------------------ 630| 3| ogs_error("This TLV has to many entries, can't parse"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 3|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 631| 3| return NULL; 632| 3| } 633| 7.51k| this = &count_node_arr[(*count_alloc_next)++]; 634| 7.51k| this->key = key; 635| 7.51k| this->count = 0; 636| 7.51k| ogs_rbtree_link_node(&this->node, parent, new); 637| 7.51k| ogs_rbtree_insert_color(tree, &this->node); 638| 7.51k| return this; 639| 7.51k|} ogs-tlv-msg.c:tlv_find_desc_by_type_inst: 456| 10.6k|{ 457| 10.6k| ogs_tlv_desc_t *prev_desc = NULL, *desc = NULL; 458| 10.6k| int i, offset = 0; 459| 10.6k| unsigned match_i = 0; 460| | 461| 10.6k| ogs_assert(parent_desc); ------------------ | | 113| 10.6k| do { \ | | 114| 10.6k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 10.6k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 10.6k, False: 0] | | | | ------------------ | | ------------------ | | 115| 10.6k| 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| 10.6k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 10.6k] | | ------------------ ------------------ 462| | 463| 161k| for (i = 0, desc = parent_desc->child_descs[i]; desc != NULL; ------------------ | Branch (463:53): [True: 153k, False: 7.77k] ------------------ 464| 153k| i++, desc = parent_desc->child_descs[i]) { 465| 153k| if (desc->type == match_type && desc->instance == match_instance) { ------------------ | Branch (465:13): [True: 3.64k, False: 150k] | Branch (465:41): [True: 3.64k, False: 0] ------------------ 466| 3.64k| if (match_i == match_type_pos) { ------------------ | Branch (466:17): [True: 2.87k, False: 766] ------------------ 467| 2.87k| *desc_index = i; 468| 2.87k| *tlv_offset = offset; 469| 2.87k| break; 470| 2.87k| } 471| 766| match_i++; 472| 766| } 473| | 474| 151k| if (desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (474:13): [True: 8.70k, False: 142k] ------------------ 475| 8.70k| ogs_assert(prev_desc && prev_desc->ctype != OGS_TLV_MORE); ------------------ | | 113| 8.70k| do { \ | | 114| 8.70k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 17.4k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 8.70k, False: 0] | | | | | Branch (54:44): [True: 8.70k, False: 0] | | | | | Branch (54:44): [True: 8.70k, False: 0] | | | | ------------------ | | ------------------ | | 115| 8.70k| 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| 8.70k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 8.70k] | | ------------------ ------------------ 476| 8.70k| offset += prev_desc->vsize * (desc->length - 1); 477| 142k| } else { 478| 142k| offset += desc->vsize; 479| 142k| } 480| | 481| 151k| prev_desc = desc; 482| 151k| } 483| | 484| 10.6k| return desc; 485| 10.6k|} ogs-tlv-msg.c:tlv_parse_leaf: 488| 1.37k|{ 489| 1.37k| ogs_assert(msg); ------------------ | | 113| 1.37k| do { \ | | 114| 1.37k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.37k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.37k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.37k| 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.37k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.37k] | | ------------------ ------------------ 490| 1.37k| ogs_assert(desc); ------------------ | | 113| 1.37k| do { \ | | 114| 1.37k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.37k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.37k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.37k| 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.37k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.37k] | | ------------------ ------------------ 491| 1.37k| ogs_assert(tlv); ------------------ | | 113| 1.37k| do { \ | | 114| 1.37k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.37k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.37k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.37k| 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.37k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.37k] | | ------------------ ------------------ 492| | 493| 1.37k| switch (desc->ctype) { 494| 0| case OGS_TV_UINT8: ------------------ | Branch (494:5): [True: 0, False: 1.37k] ------------------ 495| 0| case OGS_TV_INT8: ------------------ | Branch (495:5): [True: 0, False: 1.37k] ------------------ 496| 80| case OGS_TLV_UINT8: ------------------ | Branch (496:5): [True: 80, False: 1.29k] ------------------ 497| 80| case OGS_TLV_INT8: ------------------ | Branch (497:5): [True: 0, False: 1.37k] ------------------ 498| 80| { 499| 80| ogs_tlv_uint8_t *v = (ogs_tlv_uint8_t *)msg; 500| | 501| 80| if (tlv->length != 1) { ------------------ | Branch (501:13): [True: 16, False: 64] ------------------ 502| 16| ogs_error("Invalid TLV length %d. It should be 1", 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__) | | ------------------ ------------------ 503| 16| return OGS_ERROR; ------------------ | | 78| 16|#define OGS_ERROR -1 ------------------ 504| 16| } 505| 64| v->u8 = *(uint8_t*)(tlv->value); 506| 64| break; 507| 80| } 508| 0| case OGS_TV_UINT16: ------------------ | Branch (508:5): [True: 0, False: 1.37k] ------------------ 509| 0| case OGS_TV_INT16: ------------------ | Branch (509:5): [True: 0, False: 1.37k] ------------------ 510| 111| case OGS_TLV_UINT16: ------------------ | Branch (510:5): [True: 111, False: 1.26k] ------------------ 511| 111| case OGS_TLV_INT16: ------------------ | Branch (511:5): [True: 0, False: 1.37k] ------------------ 512| 111| { 513| 111| ogs_tlv_uint16_t *v = (ogs_tlv_uint16_t *)msg; 514| | 515| 111| if (tlv->length != 2) { ------------------ | Branch (515:13): [True: 12, False: 99] ------------------ 516| 12| ogs_error("Invalid TLV length %d. It should be 2", tlv->length); ------------------ | | 36| 12|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 12|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 517| 12| return OGS_ERROR; ------------------ | | 78| 12|#define OGS_ERROR -1 ------------------ 518| 12| } 519| 99| v->u16 = ((((uint8_t*)tlv->value)[0]<< 8)&0xff00) | 520| 99| ((((uint8_t*)tlv->value)[1] )&0x00ff); 521| 99| break; 522| 111| } 523| 0| case OGS_TV_UINT24: ------------------ | Branch (523:5): [True: 0, False: 1.37k] ------------------ 524| 0| case OGS_TV_INT24: ------------------ | Branch (524:5): [True: 0, False: 1.37k] ------------------ 525| 44| case OGS_TLV_UINT24: ------------------ | Branch (525:5): [True: 44, False: 1.32k] ------------------ 526| 44| case OGS_TLV_INT24: ------------------ | Branch (526:5): [True: 0, False: 1.37k] ------------------ 527| 44| { 528| 44| ogs_tlv_uint24_t *v = (ogs_tlv_uint24_t *)msg; 529| | 530| 44| if (tlv->length != 3) { ------------------ | Branch (530:13): [True: 10, False: 34] ------------------ 531| 10| ogs_error("Invalid TLV length %d. It should be 3", tlv->length); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 10|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 532| 10| return OGS_ERROR; ------------------ | | 78| 10|#define OGS_ERROR -1 ------------------ 533| 10| } 534| 34| v->u24 = ((((uint8_t*)tlv->value)[0]<<16)&0x00ff0000) | 535| 34| ((((uint8_t*)tlv->value)[1]<< 8)&0x0000ff00) | 536| 34| ((((uint8_t*)tlv->value)[2] )&0x000000ff); 537| 34| break; 538| 44| } 539| 0| case OGS_TV_UINT32: ------------------ | Branch (539:5): [True: 0, False: 1.37k] ------------------ 540| 0| case OGS_TV_INT32: ------------------ | Branch (540:5): [True: 0, False: 1.37k] ------------------ 541| 83| case OGS_TLV_UINT32: ------------------ | Branch (541:5): [True: 83, False: 1.28k] ------------------ 542| 83| case OGS_TLV_INT32: ------------------ | Branch (542:5): [True: 0, False: 1.37k] ------------------ 543| 83| { 544| 83| ogs_tlv_uint32_t *v = (ogs_tlv_uint32_t *)msg; 545| | 546| 83| if (tlv->length != 4) { ------------------ | Branch (546:13): [True: 14, False: 69] ------------------ 547| 14| ogs_error("Invalid TLV length %d. It should be 4", 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__) | | ------------------ ------------------ 548| 14| return OGS_ERROR; ------------------ | | 78| 14|#define OGS_ERROR -1 ------------------ 549| 14| } 550| 69| v->u32 = (((uint32_t)((uint8_t*)tlv->value)[0]<<24)&0xff000000) | 551| 69| ((((uint8_t*)tlv->value)[1]<<16)&0x00ff0000) | 552| 69| ((((uint8_t*)tlv->value)[2]<< 8)&0x0000ff00) | 553| 69| ((((uint8_t*)tlv->value)[3] )&0x000000ff); 554| 69| break; 555| 83| } 556| 0| case OGS_TV_FIXED_STR: ------------------ | Branch (556:5): [True: 0, False: 1.37k] ------------------ 557| 0| case OGS_TLV_FIXED_STR: ------------------ | Branch (557:5): [True: 0, False: 1.37k] ------------------ 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| 1.03k| case OGS_TLV_VAR_STR: ------------------ | Branch (572:5): [True: 1.03k, False: 335] ------------------ 573| 1.03k| { 574| 1.03k| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 575| | 576| 1.03k| v->data = tlv->value; 577| 1.03k| v->len = tlv->length; 578| 1.03k| break; 579| 0| } 580| 0| case OGS_TV_NULL: ------------------ | Branch (580:5): [True: 0, False: 1.37k] ------------------ 581| 0| case OGS_TLV_NULL: ------------------ | Branch (581:5): [True: 0, False: 1.37k] ------------------ 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| 17| default: ------------------ | Branch (589:5): [True: 17, False: 1.35k] ------------------ 590| 17| ogs_error("Unknown type[%d]", desc->ctype); ------------------ | | 36| 17|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 17| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 17|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 17| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 17|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 17| 0, __VA_ARGS__) | | ------------------ ------------------ 591| 17| return OGS_ERROR; ------------------ | | 78| 17|#define OGS_ERROR -1 ------------------ 592| 1.37k| } 593| | 594| 1.30k| return OGS_OK; ------------------ | | 77| 1.30k|#define OGS_OK 0 ------------------ 595| 1.37k|} ogs_tlv_get: 30| 12.3k|{ 31| 12.3k| ogs_tlv_t *tlv = NULL; 32| | 33| | /* get tlv node from node pool */ 34| 12.3k| ogs_pool_alloc(&pool, &tlv); ------------------ | | 132| 12.3k|#define ogs_pool_alloc(pool, node) do { \ | | 133| 12.3k| *(node) = NULL; \ | | 134| 12.3k| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 12.3k, False: 0] | | ------------------ | | 135| 12.3k| (pool)->avail--; \ | | 136| 12.3k| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 12.3k| (pool)->free[(pool)->head] = NULL; \ | | 138| 12.3k| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 12.3k| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 12.3k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 12.3k| } \ | | 141| 12.3k|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 12.3k] | | ------------------ ------------------ 35| | 36| | /* check for error */ 37| 12.3k| if (!tlv) { ------------------ | Branch (37:9): [True: 0, False: 12.3k] ------------------ 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| 12.3k| memset(tlv, 0, sizeof(ogs_tlv_t)); 44| 12.3k| return tlv; 45| 12.3k|} ogs_tlv_free: 48| 12.3k|{ 49| | /* free tlv node to the node pool */ 50| | ogs_pool_free(&pool, tlv); ------------------ | | 143| 12.3k|#define ogs_pool_free(pool, node) do { \ | | 144| 12.3k| if ((pool)->avail < (pool)->size) { \ | | ------------------ | | | Branch (144:9): [True: 12.3k, False: 0] | | ------------------ | | 145| 12.3k| (pool)->avail++; \ | | 146| 12.3k| (pool)->free[(pool)->tail] = (void*)(node); \ | | 147| 12.3k| (pool)->tail = ((pool)->tail + 1) % ((pool)->size); \ | | 148| 12.3k| (pool)->index[ogs_pool_index(pool, node)-1] = NULL; \ | | ------------------ | | | | 152| 12.3k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 149| 12.3k| } \ | | 150| 12.3k|} while (0) | | ------------------ | | | Branch (150:10): [Folded, False: 12.3k] | | ------------------ ------------------ 51| 12.3k|} 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| 1.73k|{ 70| | /* free all tlv node to the node pool */ 71| 1.73k| ogs_tlv_t *iter = root; 72| 1.73k| ogs_tlv_t *next = NULL; 73| 14.1k| while (iter) { ------------------ | Branch (73:12): [True: 12.3k, False: 1.73k] ------------------ 74| 12.3k| if(iter->embedded != NULL) { ------------------ | Branch (74:12): [True: 1.16k, False: 11.2k] ------------------ 75| 1.16k| ogs_tlv_free_all(iter->embedded); 76| 1.16k| } 77| 12.3k| next = iter->next; 78| 12.3k| ogs_tlv_free(iter); 79| 12.3k| iter = next; 80| 12.3k| } 81| 1.73k|} tlv_get_element: 224| 12.3k|{ 225| 12.3k| uint8_t *pos = blk; 226| 12.3k| uint32_t header_length; 227| | 228| 12.3k| tlv->mode = mode; 229| | 230| 12.3k| 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: 12.3k] ------------------ 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: 12.3k] ------------------ 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| 0| case OGS_TLV_MODE_T1_L2_I1: ------------------ | | 34| 0|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ | Branch (246:5): [True: 0, False: 12.3k] ------------------ 247| 0| header_length = 4; 248| 0| if (size < header_length) ------------------ | Branch (248:13): [True: 0, False: 0] ------------------ 249| 0| return NULL; 250| 0| tlv->type = *(pos++); 251| 0| tlv->length = *(pos++) << 8; 252| 0| tlv->length += *(pos++); 253| 0| tlv->instance = *(pos++) & 0b00001111; 254| 0| break; 255| 12.3k| case OGS_TLV_MODE_T2_L2: ------------------ | | 35| 12.3k|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (255:5): [True: 12.3k, False: 0] ------------------ 256| 12.3k| header_length = 4; 257| 12.3k| if (size < header_length) ------------------ | Branch (257:13): [True: 82, False: 12.2k] ------------------ 258| 82| return NULL; 259| 12.2k| tlv->type = *(pos++) << 8; 260| 12.2k| tlv->type += *(pos++); 261| 12.2k| tlv->length = *(pos++) << 8; 262| 12.2k| tlv->length += *(pos++); 263| 12.2k| break; 264| 0| case OGS_TLV_MODE_T1: ------------------ | | 36| 0|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (264:5): [True: 0, False: 12.3k] ------------------ 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: 12.3k] ------------------ 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| 12.3k| } 275| | 276| 12.2k| if (tlv->length > size - header_length) ------------------ | Branch (276:9): [True: 99, False: 12.1k] ------------------ 277| 99| return NULL; 278| | 279| 12.1k| tlv->value = pos; 280| | 281| 12.1k| return (pos + ogs_tlv_length(tlv)); ------------------ | | 67| 12.1k|#define ogs_tlv_length(pTlv) pTlv->length ------------------ 282| 12.2k|} ogs_tlv_parse_block: 463| 1.73k|{ 464| 1.73k| uint8_t *pos = data; 465| 1.73k| uint8_t *blk = data; 466| | 467| 1.73k| ogs_tlv_t *root = NULL; 468| 1.73k| ogs_tlv_t *prev = NULL; 469| 1.73k| ogs_tlv_t *curr = NULL; 470| | 471| 1.73k| root = curr = ogs_tlv_get(); 472| 1.73k| if (!curr) { ------------------ | Branch (472:9): [True: 0, False: 1.73k] ------------------ 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| 1.73k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 485| 1.73k| if (!pos) { ------------------ | Branch (485:9): [True: 119, False: 1.61k] ------------------ 486| 119| ogs_error("ogs_tlv_parse_block() failed[LEN:%u,MODE:%u] - parse error", ------------------ | | 36| 119|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 119| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 119|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 119| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 119|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 119| 0, __VA_ARGS__) | | ------------------ ------------------ 487| 119| 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| 119| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 238| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 119|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 116, False: 3] | | ------------------ ------------------ 494| 119| ogs_tlv_free_all(root); 495| 119| return NULL; 496| 119| } 497| | 498| 12.1k| while(pos - blk < length) { ------------------ | Branch (498:11): [True: 10.6k, False: 1.54k] ------------------ 499| 10.6k| prev = curr; 500| | 501| 10.6k| curr = ogs_tlv_get(); 502| 10.6k| if (!curr) { ------------------ | Branch (502:13): [True: 0, False: 10.6k] ------------------ 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| 10.6k| prev->next = curr; 516| | 517| 10.6k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 518| 10.6k| if (!pos) { ------------------ | Branch (518:13): [True: 62, False: 10.5k] ------------------ 519| 62| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 62|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 62| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 62|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 62| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 62|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 62| 0, __VA_ARGS__) | | ------------------ ------------------ 520| 62| 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| 62| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 124| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 62|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 46, False: 16] | | ------------------ ------------------ 527| | 528| 62| ogs_tlv_free_all(root); 529| 62| return NULL; 530| 62| } 531| 10.6k| } 532| | 533| 1.54k| if (length != (pos - blk)) { ------------------ | Branch (533:9): [True: 0, False: 1.54k] ------------------ 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| 1.54k| return root; 543| 1.54k|} ogs_tlv_parse_embedded_block: 546| 1.19k|{ 547| 1.19k| tlv->embedded = ogs_tlv_parse_block(tlv->length, tlv->value, mode); 548| | 549| 1.19k| return tlv->embedded; 550| 1.19k|} ogs_pfcp_parse_msg: 5692| 550|{ 5693| 550| int rv = OGS_ERROR; ------------------ | | 78| 550|#define OGS_ERROR -1 ------------------ 5694| 550| ogs_pfcp_header_t *h = NULL; 5695| 550| uint16_t size = 0; 5696| | 5697| 550| ogs_pfcp_message_t *pfcp_message = NULL; 5698| | 5699| 550| ogs_assert(pkbuf); ------------------ | | 113| 550| do { \ | | 114| 550| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 550|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 550, False: 0] | | | | ------------------ | | ------------------ | | 115| 550| 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, \ | | | | | | ------------------ | | | | | | | | 57| 0|#define OGS_LOG_DOMAIN __ogs_pfcp_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| 550| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 550] | | ------------------ ------------------ 5700| 550| ogs_assert(pkbuf->len); ------------------ | | 113| 550| do { \ | | 114| 550| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 550|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 550, False: 0] | | | | ------------------ | | ------------------ | | 115| 550| 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, \ | | | | | | ------------------ | | | | | | | | 57| 0|#define OGS_LOG_DOMAIN __ogs_pfcp_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| 550| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 550] | | ------------------ ------------------ 5701| | 5702| 550| h = (ogs_pfcp_header_t *)pkbuf->data; 5703| 550| ogs_assert(h); ------------------ | | 113| 550| do { \ | | 114| 550| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 550|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 550, False: 0] | | | | ------------------ | | ------------------ | | 115| 550| 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, \ | | | | | | ------------------ | | | | | | | | 57| 0|#define OGS_LOG_DOMAIN __ogs_pfcp_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| 550| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 550] | | ------------------ ------------------ 5704| | 5705| 550| pfcp_message = ogs_calloc(1, sizeof(*pfcp_message)); ------------------ | | 70| 550| ogs_talloc_zero_size(__ogs_talloc_core, (nmemb) * (size), __location__) ------------------ 5706| 550| if (!pfcp_message) { ------------------ | Branch (5706:9): [True: 0, False: 550] ------------------ 5707| 0| ogs_error("No memory"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 0|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 5708| 0| return NULL; 5709| 0| } 5710| | 5711| 550| if (h->seid_presence) ------------------ | Branch (5711:9): [True: 12, False: 538] ------------------ 5712| 12| size = OGS_PFCP_HEADER_LEN; ------------------ | | 39| 12|#define OGS_PFCP_HEADER_LEN 16 ------------------ 5713| 538| else 5714| 538| size = OGS_PFCP_HEADER_LEN-OGS_PFCP_SEID_LEN; ------------------ | | 39| 538|#define OGS_PFCP_HEADER_LEN 16 ------------------ size = OGS_PFCP_HEADER_LEN-OGS_PFCP_SEID_LEN; ------------------ | | 40| 538|#define OGS_PFCP_SEID_LEN 8 ------------------ 5715| | 5716| 550| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (5716:9): [True: 7, False: 543] ------------------ 5717| 7| ogs_error("ogs_pkbuf_pull() failed [len:%d]", pkbuf->len); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 7|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 5718| 7| ogs_pfcp_message_free(pfcp_message); 5719| 7| return NULL; 5720| 7| } 5721| 543| memcpy(&pfcp_message->h, pkbuf->data - size, size); 5722| | 5723| 543| if (h->seid_presence) { ------------------ | Branch (5723:9): [True: 8, False: 535] ------------------ 5724| 8| pfcp_message->h.seid = be64toh(pfcp_message->h.seid); 5725| 535| } else { 5726| 535| pfcp_message->h.sqn = pfcp_message->h.sqn_only; 5727| 535| } 5728| | 5729| 543| if (pkbuf->len == 0) ------------------ | Branch (5729:9): [True: 2, False: 541] ------------------ 5730| 2| return pfcp_message; 5731| | 5732| 541| switch(pfcp_message->h.type) 5733| 541| { 5734| 27| case OGS_PFCP_HEARTBEAT_REQUEST_TYPE: ------------------ | | 67| 27|#define OGS_PFCP_HEARTBEAT_REQUEST_TYPE 1 ------------------ | Branch (5734:9): [True: 27, False: 514] ------------------ 5735| 27| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_heartbeat_request, 5736| 27| &ogs_pfcp_msg_desc_pfcp_heartbeat_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 27|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5737| 27| ogs_expect(rv == OGS_OK); ------------------ | | 128| 27| do { \ | | 129| 27| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 27|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 19, False: 8] | | | | ------------------ | | ------------------ | | 130| 27| else { \ | | 131| 8| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 8|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 8| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 8| } \ | | 133| 27| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 27] | | ------------------ ------------------ 5738| 27| break; 5739| 9| case OGS_PFCP_HEARTBEAT_RESPONSE_TYPE: ------------------ | | 68| 9|#define OGS_PFCP_HEARTBEAT_RESPONSE_TYPE 2 ------------------ | Branch (5739:9): [True: 9, False: 532] ------------------ 5740| 9| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_heartbeat_response, 5741| 9| &ogs_pfcp_msg_desc_pfcp_heartbeat_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 9|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5742| 9| ogs_expect(rv == OGS_OK); ------------------ | | 128| 9| do { \ | | 129| 9| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 9|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 6] | | | | ------------------ | | ------------------ | | 130| 9| else { \ | | 131| 6| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 6|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 6| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 6| } \ | | 133| 9| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 9] | | ------------------ ------------------ 5743| 9| break; 5744| 33| case OGS_PFCP_PFD_MANAGEMENT_REQUEST_TYPE: ------------------ | | 69| 33|#define OGS_PFCP_PFD_MANAGEMENT_REQUEST_TYPE 3 ------------------ | Branch (5744:9): [True: 33, False: 508] ------------------ 5745| 33| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_pfd_management_request, 5746| 33| &ogs_pfcp_msg_desc_pfcp_pfd_management_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 33|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5747| 33| ogs_expect(rv == OGS_OK); ------------------ | | 128| 33| do { \ | | 129| 33| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 33|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 27, False: 6] | | | | ------------------ | | ------------------ | | 130| 33| else { \ | | 131| 6| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 6|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 6| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 6| } \ | | 133| 33| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 33] | | ------------------ ------------------ 5748| 33| break; 5749| 14| case OGS_PFCP_PFD_MANAGEMENT_RESPONSE_TYPE: ------------------ | | 70| 14|#define OGS_PFCP_PFD_MANAGEMENT_RESPONSE_TYPE 4 ------------------ | Branch (5749:9): [True: 14, False: 527] ------------------ 5750| 14| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_pfd_management_response, 5751| 14| &ogs_pfcp_msg_desc_pfcp_pfd_management_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 14|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5752| 14| ogs_expect(rv == OGS_OK); ------------------ | | 128| 14| do { \ | | 129| 14| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 14|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 9, False: 5] | | | | ------------------ | | ------------------ | | 130| 14| else { \ | | 131| 5| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 5|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 5| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 5| } \ | | 133| 14| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 14] | | ------------------ ------------------ 5753| 14| break; 5754| 105| case OGS_PFCP_ASSOCIATION_SETUP_REQUEST_TYPE: ------------------ | | 71| 105|#define OGS_PFCP_ASSOCIATION_SETUP_REQUEST_TYPE 5 ------------------ | Branch (5754:9): [True: 105, False: 436] ------------------ 5755| 105| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_setup_request, 5756| 105| &ogs_pfcp_msg_desc_pfcp_association_setup_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 105|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5757| 105| ogs_expect(rv == OGS_OK); ------------------ | | 128| 105| do { \ | | 129| 105| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 105|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 65, False: 40] | | | | ------------------ | | ------------------ | | 130| 105| else { \ | | 131| 40| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 40|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 40| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 40|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 40| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 40|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 40| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 40| } \ | | 133| 105| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 105] | | ------------------ ------------------ 5758| 105| break; 5759| 10| case OGS_PFCP_ASSOCIATION_SETUP_RESPONSE_TYPE: ------------------ | | 72| 10|#define OGS_PFCP_ASSOCIATION_SETUP_RESPONSE_TYPE 6 ------------------ | Branch (5759:9): [True: 10, False: 531] ------------------ 5760| 10| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_setup_response, 5761| 10| &ogs_pfcp_msg_desc_pfcp_association_setup_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 10|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5762| 10| ogs_expect(rv == OGS_OK); ------------------ | | 128| 10| do { \ | | 129| 10| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 10|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 7] | | | | ------------------ | | ------------------ | | 130| 10| else { \ | | 131| 7| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 7|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 7| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 7| } \ | | 133| 10| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 10] | | ------------------ ------------------ 5763| 10| break; 5764| 26| case OGS_PFCP_ASSOCIATION_UPDATE_REQUEST_TYPE: ------------------ | | 73| 26|#define OGS_PFCP_ASSOCIATION_UPDATE_REQUEST_TYPE 7 ------------------ | Branch (5764:9): [True: 26, False: 515] ------------------ 5765| 26| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_update_request, 5766| 26| &ogs_pfcp_msg_desc_pfcp_association_update_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 26|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5767| 26| ogs_expect(rv == OGS_OK); ------------------ | | 128| 26| do { \ | | 129| 26| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 26|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 13, False: 13] | | | | ------------------ | | ------------------ | | 130| 26| else { \ | | 131| 13| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 13|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 13| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 13|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 13| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 13|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 13| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 13| } \ | | 133| 26| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 26] | | ------------------ ------------------ 5768| 26| break; 5769| 6| case OGS_PFCP_ASSOCIATION_UPDATE_RESPONSE_TYPE: ------------------ | | 74| 6|#define OGS_PFCP_ASSOCIATION_UPDATE_RESPONSE_TYPE 8 ------------------ | Branch (5769:9): [True: 6, False: 535] ------------------ 5770| 6| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_update_response, 5771| 6| &ogs_pfcp_msg_desc_pfcp_association_update_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 6|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5772| 6| ogs_expect(rv == OGS_OK); ------------------ | | 128| 6| do { \ | | 129| 6| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2, False: 4] | | | | ------------------ | | ------------------ | | 130| 6| else { \ | | 131| 4| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 4|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 4| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 4| } \ | | 133| 6| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 6] | | ------------------ ------------------ 5773| 6| break; 5774| 8| case OGS_PFCP_ASSOCIATION_RELEASE_REQUEST_TYPE: ------------------ | | 75| 8|#define OGS_PFCP_ASSOCIATION_RELEASE_REQUEST_TYPE 9 ------------------ | Branch (5774:9): [True: 8, False: 533] ------------------ 5775| 8| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_release_request, 5776| 8| &ogs_pfcp_msg_desc_pfcp_association_release_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 8|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5777| 8| ogs_expect(rv == OGS_OK); ------------------ | | 128| 8| do { \ | | 129| 8| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 8|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4, False: 4] | | | | ------------------ | | ------------------ | | 130| 8| else { \ | | 131| 4| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 4|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 4| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 4| } \ | | 133| 8| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 8] | | ------------------ ------------------ 5778| 8| break; 5779| 11| case OGS_PFCP_ASSOCIATION_RELEASE_RESPONSE_TYPE: ------------------ | | 76| 11|#define OGS_PFCP_ASSOCIATION_RELEASE_RESPONSE_TYPE 10 ------------------ | Branch (5779:9): [True: 11, False: 530] ------------------ 5780| 11| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_release_response, 5781| 11| &ogs_pfcp_msg_desc_pfcp_association_release_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 11|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5782| 11| ogs_expect(rv == OGS_OK); ------------------ | | 128| 11| do { \ | | 129| 11| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 11|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6, False: 5] | | | | ------------------ | | ------------------ | | 130| 11| else { \ | | 131| 5| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 5|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 5| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 5| } \ | | 133| 11| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 11] | | ------------------ ------------------ 5783| 11| break; 5784| 1| case OGS_PFCP_VERSION_NOT_SUPPORTED_RESPONSE_TYPE: ------------------ | | 77| 1|#define OGS_PFCP_VERSION_NOT_SUPPORTED_RESPONSE_TYPE 11 ------------------ | Branch (5784:9): [True: 1, False: 540] ------------------ 5785| 1| break; 5786| 5| case OGS_PFCP_NODE_REPORT_REQUEST_TYPE: ------------------ | | 78| 5|#define OGS_PFCP_NODE_REPORT_REQUEST_TYPE 12 ------------------ | Branch (5786:9): [True: 5, False: 536] ------------------ 5787| 5| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_node_report_request, 5788| 5| &ogs_pfcp_msg_desc_pfcp_node_report_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 5|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5789| 5| ogs_expect(rv == OGS_OK); ------------------ | | 128| 5| do { \ | | 129| 5| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 5|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2, False: 3] | | | | ------------------ | | ------------------ | | 130| 5| else { \ | | 131| 3| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 3|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 3| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 3| } \ | | 133| 5| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 5] | | ------------------ ------------------ 5790| 5| break; 5791| 17| case OGS_PFCP_NODE_REPORT_RESPONSE_TYPE: ------------------ | | 79| 17|#define OGS_PFCP_NODE_REPORT_RESPONSE_TYPE 13 ------------------ | Branch (5791:9): [True: 17, False: 524] ------------------ 5792| 17| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_node_report_response, 5793| 17| &ogs_pfcp_msg_desc_pfcp_node_report_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 17|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5794| 17| ogs_expect(rv == OGS_OK); ------------------ | | 128| 17| do { \ | | 129| 17| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 17|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 14] | | | | ------------------ | | ------------------ | | 130| 17| else { \ | | 131| 14| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 14|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 14| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 14|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 14| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 14|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 14| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 14| } \ | | 133| 17| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 17] | | ------------------ ------------------ 5795| 17| break; 5796| 13| case OGS_PFCP_SESSION_SET_DELETION_REQUEST_TYPE: ------------------ | | 80| 13|#define OGS_PFCP_SESSION_SET_DELETION_REQUEST_TYPE 14 ------------------ | Branch (5796:9): [True: 13, False: 528] ------------------ 5797| 13| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_deletion_request, 5798| 13| &ogs_pfcp_msg_desc_pfcp_session_set_deletion_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 13|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5799| 13| ogs_expect(rv == OGS_OK); ------------------ | | 128| 13| do { \ | | 129| 13| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 13|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7, False: 6] | | | | ------------------ | | ------------------ | | 130| 13| else { \ | | 131| 6| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 6|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 6| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 6| } \ | | 133| 13| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 13] | | ------------------ ------------------ 5800| 13| break; 5801| 8| case OGS_PFCP_SESSION_SET_DELETION_RESPONSE_TYPE: ------------------ | | 81| 8|#define OGS_PFCP_SESSION_SET_DELETION_RESPONSE_TYPE 15 ------------------ | Branch (5801:9): [True: 8, False: 533] ------------------ 5802| 8| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_deletion_response, 5803| 8| &ogs_pfcp_msg_desc_pfcp_session_set_deletion_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 8|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5804| 8| ogs_expect(rv == OGS_OK); ------------------ | | 128| 8| do { \ | | 129| 8| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 8|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 5] | | | | ------------------ | | ------------------ | | 130| 8| else { \ | | 131| 5| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 5|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 5| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 5| } \ | | 133| 8| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 8] | | ------------------ ------------------ 5805| 8| break; 5806| 4| case OGS_PFCP_SESSION_SET_MODIFICATION_REQUEST_TYPE: ------------------ | | 82| 4|#define OGS_PFCP_SESSION_SET_MODIFICATION_REQUEST_TYPE 16 ------------------ | Branch (5806:9): [True: 4, False: 537] ------------------ 5807| 4| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_modification_request, 5808| 4| &ogs_pfcp_msg_desc_pfcp_session_set_modification_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 4|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5809| 4| ogs_expect(rv == OGS_OK); ------------------ | | 128| 4| do { \ | | 129| 4| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2, False: 2] | | | | ------------------ | | ------------------ | | 130| 4| else { \ | | 131| 2| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 2|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 2| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 2| } \ | | 133| 4| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 4] | | ------------------ ------------------ 5810| 4| break; 5811| 8| case OGS_PFCP_SESSION_SET_MODIFICATION_RESPONSE_TYPE: ------------------ | | 83| 8|#define OGS_PFCP_SESSION_SET_MODIFICATION_RESPONSE_TYPE 17 ------------------ | Branch (5811:9): [True: 8, False: 533] ------------------ 5812| 8| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_modification_response, 5813| 8| &ogs_pfcp_msg_desc_pfcp_session_set_modification_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 8|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5814| 8| ogs_expect(rv == OGS_OK); ------------------ | | 128| 8| do { \ | | 129| 8| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 8|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2, False: 6] | | | | ------------------ | | ------------------ | | 130| 8| else { \ | | 131| 6| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 6|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 6| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 6| } \ | | 133| 8| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 8] | | ------------------ ------------------ 5815| 8| break; 5816| 98| case OGS_PFCP_SESSION_ESTABLISHMENT_REQUEST_TYPE: ------------------ | | 84| 98|#define OGS_PFCP_SESSION_ESTABLISHMENT_REQUEST_TYPE 50 ------------------ | Branch (5816:9): [True: 98, False: 443] ------------------ 5817| 98| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_establishment_request, 5818| 98| &ogs_pfcp_msg_desc_pfcp_session_establishment_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 98|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5819| 98| ogs_expect(rv == OGS_OK); ------------------ | | 128| 98| do { \ | | 129| 98| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 98|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 50, False: 48] | | | | ------------------ | | ------------------ | | 130| 98| else { \ | | 131| 48| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 48|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 48| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 48|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 48| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 48|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 48| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 48| } \ | | 133| 98| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 98] | | ------------------ ------------------ 5820| 98| break; 5821| 10| case OGS_PFCP_SESSION_ESTABLISHMENT_RESPONSE_TYPE: ------------------ | | 85| 10|#define OGS_PFCP_SESSION_ESTABLISHMENT_RESPONSE_TYPE 51 ------------------ | Branch (5821:9): [True: 10, False: 531] ------------------ 5822| 10| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_establishment_response, 5823| 10| &ogs_pfcp_msg_desc_pfcp_session_establishment_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 10|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5824| 10| ogs_expect(rv == OGS_OK); ------------------ | | 128| 10| do { \ | | 129| 10| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 10|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4, False: 6] | | | | ------------------ | | ------------------ | | 130| 10| else { \ | | 131| 6| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 6|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 6| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 6| } \ | | 133| 10| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 10] | | ------------------ ------------------ 5825| 10| break; 5826| 84| case OGS_PFCP_SESSION_MODIFICATION_REQUEST_TYPE: ------------------ | | 86| 84|#define OGS_PFCP_SESSION_MODIFICATION_REQUEST_TYPE 52 ------------------ | Branch (5826:9): [True: 84, False: 457] ------------------ 5827| 84| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_modification_request, 5828| 84| &ogs_pfcp_msg_desc_pfcp_session_modification_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 84|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5829| 84| ogs_expect(rv == OGS_OK); ------------------ | | 128| 84| do { \ | | 129| 84| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 84|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 44, False: 40] | | | | ------------------ | | ------------------ | | 130| 84| else { \ | | 131| 40| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 40|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 40| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 40|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 40| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 40|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 40| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 40| } \ | | 133| 84| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 84] | | ------------------ ------------------ 5830| 84| break; 5831| 7| case OGS_PFCP_SESSION_MODIFICATION_RESPONSE_TYPE: ------------------ | | 87| 7|#define OGS_PFCP_SESSION_MODIFICATION_RESPONSE_TYPE 53 ------------------ | Branch (5831:9): [True: 7, False: 534] ------------------ 5832| 7| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_modification_response, 5833| 7| &ogs_pfcp_msg_desc_pfcp_session_modification_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 7|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5834| 7| ogs_expect(rv == OGS_OK); ------------------ | | 128| 7| do { \ | | 129| 7| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 4] | | | | ------------------ | | ------------------ | | 130| 7| else { \ | | 131| 4| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 4|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 4| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 4| } \ | | 133| 7| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 7] | | ------------------ ------------------ 5835| 7| break; 5836| 1| case OGS_PFCP_SESSION_DELETION_REQUEST_TYPE: ------------------ | | 88| 1|#define OGS_PFCP_SESSION_DELETION_REQUEST_TYPE 54 ------------------ | Branch (5836:9): [True: 1, False: 540] ------------------ 5837| 1| break; 5838| 11| case OGS_PFCP_SESSION_DELETION_RESPONSE_TYPE: ------------------ | | 89| 11|#define OGS_PFCP_SESSION_DELETION_RESPONSE_TYPE 55 ------------------ | Branch (5838:9): [True: 11, False: 530] ------------------ 5839| 11| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_deletion_response, 5840| 11| &ogs_pfcp_msg_desc_pfcp_session_deletion_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 11|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5841| 11| ogs_expect(rv == OGS_OK); ------------------ | | 128| 11| do { \ | | 129| 11| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 11|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 8] | | | | ------------------ | | ------------------ | | 130| 11| else { \ | | 131| 8| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 8|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 8| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 8| } \ | | 133| 11| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 11] | | ------------------ ------------------ 5842| 11| break; 5843| 12| case OGS_PFCP_SESSION_REPORT_REQUEST_TYPE: ------------------ | | 90| 12|#define OGS_PFCP_SESSION_REPORT_REQUEST_TYPE 56 ------------------ | Branch (5843:9): [True: 12, False: 529] ------------------ 5844| 12| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_report_request, 5845| 12| &ogs_pfcp_msg_desc_pfcp_session_report_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 12|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5846| 12| ogs_expect(rv == OGS_OK); ------------------ | | 128| 12| do { \ | | 129| 12| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 12|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4, False: 8] | | | | ------------------ | | ------------------ | | 130| 12| else { \ | | 131| 8| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 8|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 8| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 8| } \ | | 133| 12| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 12] | | ------------------ ------------------ 5847| 12| break; 5848| 8| case OGS_PFCP_SESSION_REPORT_RESPONSE_TYPE: ------------------ | | 91| 8|#define OGS_PFCP_SESSION_REPORT_RESPONSE_TYPE 57 ------------------ | Branch (5848:9): [True: 8, False: 533] ------------------ 5849| 8| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_report_response, 5850| 8| &ogs_pfcp_msg_desc_pfcp_session_report_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 8|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5851| 8| ogs_expect(rv == OGS_OK); ------------------ | | 128| 8| do { \ | | 129| 8| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 8|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 5] | | | | ------------------ | | ------------------ | | 130| 8| else { \ | | 131| 5| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 5|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 5| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 5| } \ | | 133| 8| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 8] | | ------------------ ------------------ 5852| 8| break; 5853| 5| default: ------------------ | Branch (5853:9): [True: 5, False: 536] ------------------ 5854| 5| ogs_warn("Not implemented(type:%d)", pfcp_message->h.type); ------------------ | | 37| 5|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 5|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 5855| 5| break; 5856| 541| } 5857| | 5858| 541| if (rv != OGS_OK) { ------------------ | | 77| 541|#define OGS_OK 0 ------------------ | Branch (5858:9): [True: 260, False: 281] ------------------ 5859| 260| ogs_pfcp_message_free(pfcp_message); 5860| 260| return NULL; 5861| 260| } 5862| | 5863| 281| return pfcp_message; 5864| 541|} ogs_pfcp_message_free: 5867| 550|{ 5868| 550| ogs_assert(pfcp_message); ------------------ | | 113| 550| do { \ | | 114| 550| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 550|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 550, False: 0] | | | | ------------------ | | ------------------ | | 115| 550| 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, \ | | | | | | ------------------ | | | | | | | | 57| 0|#define OGS_LOG_DOMAIN __ogs_pfcp_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| 550| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 550] | | ------------------ ------------------ 5869| 550| ogs_free(pfcp_message); ------------------ | | 73| 550|#define ogs_free(ptr) ogs_talloc_free(ptr, __location__) ------------------ 5870| 550|} 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| 576|{ 31| | 32| 576| if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 26| 1.15k|#define kMinInputLength 5 ------------------ if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 27| 572|#define kMaxInputLength 2048 ------------------ | Branch (32:9): [True: 4, False: 572] | Branch (32:35): [True: 22, False: 550] ------------------ 33| 26| return 1; 34| 26| } 35| | 36| 550| if (!initialized) { ------------------ | Branch (36:9): [True: 1, False: 549] ------------------ 37| 1| initialize(); 38| 1| ogs_log_install_domain(&__ogs_pfcp_domain, "pfcp", OGS_LOG_NONE); 39| 1| ogs_log_install_domain(&__ogs_tlv_domain, "tlv", OGS_LOG_NONE); 40| 1| } 41| | 42| 550| ogs_pkbuf_t *pkbuf; 43| 550| pkbuf = ogs_pkbuf_alloc(NULL, OGS_MAX_SDU_LEN); ------------------ | | 87| 550| ogs_pkbuf_alloc_debug(pool, size, OGS_FILE_LINE) | | ------------------ | | | | 213| 550|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 167| 550|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 168| 550|#define OGS_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 44| 550| if (pkbuf == NULL) { ------------------ | Branch (44:9): [True: 0, False: 550] ------------------ 45| 0| return 1; 46| 0| } 47| 550| ogs_pkbuf_put_data(pkbuf, Data, Size); 48| | 49| 550| ogs_pfcp_message_t *message = ogs_pfcp_parse_msg(pkbuf); 50| 550| if (message) { ------------------ | Branch (50:9): [True: 283, False: 267] ------------------ 51| 283| ogs_pfcp_message_free(message); 52| 283| } 53| | 54| 550| ogs_pkbuf_free(pkbuf); 55| | 56| 550| return 0; 57| 550|}