ogs_buffer_to_uint64: 106| 36|{ 107| 36| uint64_t num = 0; 108| 36| uint8_t *buffer_p = buffer; 109| 36| int i; 110| | 111| 216| for (i = 0; i < size; i++) { ------------------ | Branch (111:17): [True: 180, False: 36] ------------------ 112| 180| num |= (((uint64_t)buffer_p[i]) << ((size-1-i) * 8)); 113| 180| } 114| | 115| 36| return num; 116| 36|} 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| 17.0k|{ 52| 17.0k| return list->next; 53| 17.0k|} ogs-log.c:ogs_list_next: 61| 8.61k|{ 62| 8.61k| ogs_list_t *node = (ogs_list_t *)lnode; 63| 8.61k| return node->next; 64| 8.61k|} 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| 17.0k|{ 405| 17.0k| ogs_log_t *log = NULL; 406| 17.0k| ogs_log_domain_t *domain = NULL; 407| | 408| 17.0k| char logstr[OGS_HUGE_LEN]; 409| 17.0k| char *p, *last; 410| | 411| 17.0k| int wrote_stderr = 0; 412| | 413| 17.0k| ogs_list_for_each(&log_list, log) { ------------------ | | 76| 25.6k| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 17.0k, False: 8.59k] | | ------------------ | | 77| 17.0k| node = ogs_list_next(node)) ------------------ 414| 17.0k| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 17.0k| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 17.0k, False: 0] | | | Branch (154:20): [True: 17.0k, False: 0] | | ------------------ ------------------ 415| 17.0k| if (!domain) { ------------------ | Branch (415:13): [True: 0, False: 17.0k] ------------------ 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| 17.0k| if (domain->level < level) ------------------ | Branch (419:13): [True: 8.49k, False: 8.59k] ------------------ 420| 8.49k| 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: 144] ------------------ 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: 144] ------------------ 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| 17.0k|{ 487| 17.0k| va_list args; 488| | 489| 17.0k| va_start(args, format); 490| 17.0k| ogs_log_vprintf(level, id, 491| 17.0k| err, file, line, func, content_only, format, args); 492| | va_end(args); 493| 17.0k|} ogs_log_hexdump_func: 497| 169|{ 498| 169| size_t n, m; 499| 169| char dumpstr[OGS_HUGE_LEN]; 500| 169| 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| 169| if (!len) ------------------ | Branch (506:9): [True: 25, False: 144] ------------------ 507| 25| return; 508| | 509| 144| last = dumpstr + OGS_HUGE_LEN; ------------------ | | 210| 144|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 510| 144| p = dumpstr; 511| | 512| 1.77k| for (n = 0; n < len; n += 16) { ------------------ | Branch (512:17): [True: 1.62k, False: 144] ------------------ 513| 1.62k| p = ogs_slprintf(p, last, "%04x: ", (int)n); 514| | 515| 27.6k| for (m = n; m < n + 16; m++) { ------------------ | Branch (515:21): [True: 26.0k, False: 1.62k] ------------------ 516| 26.0k| if (m > n && (m % 4) == 0) ------------------ | Branch (516:17): [True: 24.4k, False: 1.62k] | Branch (516:26): [True: 4.88k, False: 19.5k] ------------------ 517| 4.88k| p = ogs_slprintf(p, last, " "); 518| 26.0k| if (m < len) ------------------ | Branch (518:17): [True: 24.8k, False: 1.20k] ------------------ 519| 24.8k| p = ogs_slprintf(p, last, "%02x", data[m]); 520| 1.20k| else 521| 1.20k| p = ogs_slprintf(p, last, " "); 522| 26.0k| } 523| | 524| 1.62k| p = ogs_slprintf(p, last, " "); 525| | 526| 26.4k| for (m = n; m < len && m < n + 16; m++) ------------------ | Branch (526:21): [True: 26.3k, False: 144] | Branch (526:32): [True: 24.8k, False: 1.48k] ------------------ 527| 24.8k| p = ogs_slprintf(p, last, "%c", isprint(data[m]) ? data[m] : '.'); ------------------ | Branch (527:45): [True: 3.37k, False: 21.4k] ------------------ 528| | 529| 1.62k| p = ogs_slprintf(p, last, "\n"); 530| 1.62k| } 531| | 532| | ogs_log_print(level, "%s", dumpstr); ------------------ | | 48| 144| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | ------------------ | | | | 32| 144|#define OGS_LOG_DOMAIN 1 | | ------------------ | | 49| 144| 0, NULL, 0, NULL, \ | | 50| 144| 1, __VA_ARGS__) ------------------ 533| 144|} 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.94k|{ 74| 1.94k| void *ptr = NULL; 75| | 76| 1.94k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 1.94k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 77| | 78| 1.94k| ptr = _talloc_zero(ctx, size, name); 79| 1.94k| ogs_expect(ptr); ------------------ | | 128| 1.94k| do { \ | | 129| 1.94k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.94k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.94k, False: 0] | | | | ------------------ | | ------------------ | | 130| 1.94k| 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.94k| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 1.94k] | | ------------------ ------------------ 80| | 81| 1.94k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 1.94k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 82| | 83| 1.94k| return ptr; 84| 1.94k|} ogs_talloc_free: 102| 1.94k|{ 103| 1.94k| int ret; 104| | 105| 1.94k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 1.94k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 106| | 107| 1.94k| ret = _talloc_free(ptr, location); 108| | 109| 1.94k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 1.94k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 110| | 111| 1.94k| return ret; 112| 1.94k|} ogs_pkbuf_put_data: 91| 973|{ 92| 973| void *tmp = ogs_pkbuf_put(pkbuf, len); 93| | 94| 973| memcpy(tmp, data, len); 95| 973| return tmp; 96| 973|} 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| 973|{ 223| 973|#if OGS_USE_TALLOC == 1 224| 973| ogs_pkbuf_t *pkbuf = NULL; 225| | 226| 973| pkbuf = ogs_talloc_zero_size(pool, sizeof(*pkbuf) + size, file_line); 227| 973| if (!pkbuf) { ------------------ | Branch (227:9): [True: 0, False: 973] ------------------ 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| 973| pkbuf->head = pkbuf->_data; 233| 973| pkbuf->end = pkbuf->_data + size; 234| | 235| 973| pkbuf->len = 0; 236| | 237| 973| pkbuf->data = pkbuf->_data; 238| 973| pkbuf->tail = pkbuf->_data; 239| | 240| 973| pkbuf->file_line = file_line; /* For debug */ 241| | 242| 973| 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| 973|} ogs_pkbuf_free: 290| 973|{ 291| 973|#if OGS_USE_TALLOC == 1 292| 973| ogs_talloc_free(pkbuf, OGS_FILE_LINE); ------------------ | | 213| 973|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | ------------------ | | | | 167| 973|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | ------------------ | | | | | | 168| 973|#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| 973|} message.c:ogs_pkbuf_pull: 165| 973|{ 166| 973| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 973|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 7, False: 966] | | ------------------ ------------------ 167| 973| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 973|} message.c:ogs_pkbuf_pull_inline: 159| 966|{ 160| 966| pkbuf->len -= len; 161| 966| return pkbuf->data += len; 162| 966|} ogs-pkbuf.c:ogs_pkbuf_put: 115| 973|{ 116| 973| void *tmp = pkbuf->tail; 117| | 118| 973| if (ogs_unlikely(ogs_pkbuf_tailroom(pkbuf) < (int)len)) ------------------ | | 55| 973|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 973] | | ------------------ ------------------ 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| 973| pkbuf->tail += len; 122| 973| pkbuf->len += len; 123| | 124| 973| return tmp; 125| 973|} ogs-pkbuf.c:ogs_pkbuf_tailroom: 99| 973|{ 100| 973| return pkbuf->end - pkbuf->tail; 101| 973|} ogs_rbtree_insert_color: 93| 10.7k|{ 94| 10.7k| ogs_rbnode_t *node = rb_node; 95| 10.7k| ogs_rbnode_t *parent; 96| 10.7k| ogs_assert(tree); ------------------ | | 113| 10.7k| do { \ | | 114| 10.7k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 10.7k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 10.7k, False: 0] | | | | ------------------ | | ------------------ | | 115| 10.7k| 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.7k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 10.7k] | | ------------------ ------------------ 97| 10.7k| ogs_assert(node); ------------------ | | 113| 10.7k| do { \ | | 114| 10.7k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 10.7k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 10.7k, False: 0] | | | | ------------------ | | ------------------ | | 115| 10.7k| 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.7k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 10.7k] | | ------------------ ------------------ 98| | 99| 16.5k| while ((parent = node->parent) && parent->color == OGS_RBTREE_RED) { ------------------ | Branch (99:12): [True: 11.8k, False: 4.65k] | Branch (99:39): [True: 5.74k, False: 6.13k] ------------------ 100| 5.74k| ogs_rbnode_t *gparent = parent->parent; 101| 5.74k| ogs_assert(gparent); ------------------ | | 113| 5.74k| do { \ | | 114| 5.74k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 5.74k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 5.74k, False: 0] | | | | ------------------ | | ------------------ | | 115| 5.74k| 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.74k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 5.74k] | | ------------------ ------------------ 102| | 103| | /* parent == grandparent's left child */ 104| 5.74k| if (parent == gparent->left) { ------------------ | Branch (104:13): [True: 2.75k, False: 2.99k] ------------------ 105| 2.75k| ogs_rbnode_t *uncle = gparent->right; 106| | 107| 2.75k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (107:17): [True: 1.49k, False: 1.25k] | Branch (107:26): [True: 1.17k, 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.17k| uncle->color = OGS_RBTREE_BLACK; 118| 1.17k| parent->color = OGS_RBTREE_BLACK; 119| | 120| 1.17k| gparent->color = OGS_RBTREE_RED; 121| | 122| 1.17k| node = gparent; 123| 1.57k| } else { 124| | /* node's uncle == black */ 125| 1.57k| if (node == parent->right) { ------------------ | Branch (125:21): [True: 804, False: 770] ------------------ 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| 804| node = node->parent; 137| 804| rb_rotate_left(tree, node); 138| 804| } 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.57k| node->parent->color = OGS_RBTREE_BLACK; 151| 1.57k| gparent->color = OGS_RBTREE_RED; 152| 1.57k| rb_rotate_right(tree, gparent); 153| 1.57k| } 154| | /* parent == grandparent's right child */ 155| 2.99k| } else { 156| 2.99k| ogs_rbnode_t *uncle = gparent->left; 157| | 158| 2.99k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (158:17): [True: 1.83k, False: 1.15k] | Branch (158:26): [True: 1.44k, False: 389] ------------------ 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.44k| uncle->color = OGS_RBTREE_BLACK; 169| 1.44k| parent->color = OGS_RBTREE_BLACK; 170| | 171| 1.44k| gparent->color = OGS_RBTREE_RED; 172| | 173| 1.44k| node = gparent; 174| 1.54k| } else { 175| | /* node's uncle == black */ 176| 1.54k| if (node == parent->left) { ------------------ | Branch (176:21): [True: 774, False: 774] ------------------ 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| 774| node = node->parent; 188| 774| rb_rotate_right(tree, node); 189| 774| } 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.54k| node->parent->color = OGS_RBTREE_BLACK; 202| 1.54k| gparent->color = OGS_RBTREE_RED; 203| 1.54k| rb_rotate_left(tree, gparent); 204| 1.54k| } 205| 2.99k| } 206| 5.74k| } 207| | 208| 10.7k| ogs_assert(tree->root); ------------------ | | 113| 10.7k| do { \ | | 114| 10.7k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 10.7k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 10.7k, False: 0] | | | | ------------------ | | ------------------ | | 115| 10.7k| 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.7k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 10.7k] | | ------------------ ------------------ 209| 10.7k| tree->root->color = OGS_RBTREE_BLACK; 210| 10.7k|} ogs-rbtree.c:rb_rotate_left: 56| 2.35k|{ 57| 2.35k| ogs_rbnode_t *right = node->right; 58| 2.35k| node->right = right->left; 59| 2.35k| if (right->left) ------------------ | Branch (59:9): [True: 566, False: 1.78k] ------------------ 60| 566| right->left->parent = node; 61| | 62| 2.35k| rb_replace_node(tree, node, right, node->parent); 63| | 64| 2.35k| right->left = node; 65| 2.35k| node->parent = right; 66| 2.35k|} ogs-rbtree.c:rb_rotate_right: 80| 2.34k|{ 81| 2.34k| ogs_rbnode_t *left = node->left; 82| 2.34k| node->left = left->right; 83| 2.34k| if (left->right) ------------------ | Branch (83:9): [True: 513, False: 1.83k] ------------------ 84| 513| left->right->parent = node; 85| | 86| 2.34k| rb_replace_node(tree, node, left, node->parent); 87| | 88| 2.34k| left->right = node; 89| 2.34k| node->parent = left; 90| 2.34k|} ogs-rbtree.c:rb_replace_node: 37| 4.70k|{ 38| 4.70k| rb_change_child(tree, old, new, parent); 39| | 40| 4.70k| if (new) ------------------ | Branch (40:9): [True: 4.70k, False: 0] ------------------ 41| 4.70k| new->parent = parent; 42| 4.70k|} ogs-rbtree.c:rb_change_child: 24| 4.70k|{ 25| 4.70k| if (parent) { ------------------ | Branch (25:9): [True: 3.82k, False: 874] ------------------ 26| 3.82k| if (old == parent->left) ------------------ | Branch (26:13): [True: 1.85k, False: 1.97k] ------------------ 27| 1.85k| parent->left = new; 28| 1.97k| else 29| 1.97k| parent->right = new; 30| 3.82k| } else { 31| 874| tree->root = new; 32| 874| } 33| 4.70k|} ogs-tlv-msg.c:ogs_rbtree_link_node: 54| 10.7k|{ 55| 10.7k| ogs_rbnode_t *node = (ogs_rbnode_t *)rb_node; 56| 10.7k| node->parent = parent; 57| 10.7k| node->left = node->right = NULL; 58| 10.7k| node->color = OGS_RBTREE_RED; 59| | 60| 10.7k| *rb_link = node; 61| 10.7k|} 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| 111k|{ 64| 111k| 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| 111k| r = vsnprintf(str, size, format, ap); 78| 111k|#endif 79| 111k| str[size-1] = '\0'; 80| | 81| 111k| return r; 82| 111k|} ogs_vslprintf: 97| 111k|{ 98| 111k| int r = -1; 99| | 100| 111k| ogs_assert(last); ------------------ | | 113| 111k| do { \ | | 114| 111k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 111k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 111k, False: 0] | | | | ------------------ | | ------------------ | | 115| 111k| 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| 111k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 111k] | | ------------------ ------------------ 101| | 102| 111k| if (!str) ------------------ | Branch (102:9): [True: 0, False: 111k] ------------------ 103| 0| return NULL; 104| | 105| 111k| if (str < last) ------------------ | Branch (105:9): [True: 111k, False: 0] ------------------ 106| 111k| r = ogs_vsnprintf(str, last - str, format, ap); 107| | 108| 111k| return (str + r); 109| 111k|} ogs_slprintf: 112| 102k|{ 113| 102k| char *r; 114| 102k| va_list ap; 115| | 116| 102k| va_start(ap, format); 117| 102k| r = ogs_vslprintf(str, last, format, ap); 118| 102k| va_end(ap); 119| | 120| 102k| return r; 121| 102k|} 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| 955|{ 744| 955| int rv; 745| 955| ogs_tlv_t *root; 746| | 747| 955| ogs_assert(msg); ------------------ | | 113| 955| do { \ | | 114| 955| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 955|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 955, False: 0] | | | | ------------------ | | ------------------ | | 115| 955| 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| 955| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 955] | | ------------------ ------------------ 748| 955| ogs_assert(desc); ------------------ | | 113| 955| do { \ | | 114| 955| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 955|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 955, False: 0] | | | | ------------------ | | ------------------ | | 115| 955| 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| 955| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 955] | | ------------------ ------------------ 749| 955| ogs_assert(pkbuf); ------------------ | | 113| 955| do { \ | | 114| 955| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 955|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 955, False: 0] | | | | ------------------ | | ------------------ | | 115| 955| 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| 955| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 955] | | ------------------ ------------------ 750| | 751| 955| ogs_assert(desc->ctype == OGS_TLV_MESSAGE); ------------------ | | 113| 955| do { \ | | 114| 955| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 955|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 955, False: 0] | | | | ------------------ | | ------------------ | | 115| 955| 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| 955| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 955] | | ------------------ ------------------ 752| 955| if (!desc->child_descs[0]) { ------------------ | Branch (752:9): [True: 0, False: 955] ------------------ 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| 955| root = ogs_tlv_parse_block(pkbuf->len, pkbuf->data, mode); 758| 955| if (root == NULL) { ------------------ | Branch (758:9): [True: 142, False: 813] ------------------ 759| 142| ogs_error("Can't parse TLV message"); ------------------ | | 36| 142|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 142| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 142|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 142| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 142|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 142| 0, __VA_ARGS__) | | ------------------ ------------------ 760| 142| return OGS_ERROR; ------------------ | | 78| 142|#define OGS_ERROR -1 ------------------ 761| 142| } 762| | 763| 813| rv = tlv_parse_compound(msg, desc, root, 0, mode); 764| | 765| 813| ogs_tlv_free_all(root); 766| | 767| 813| return rv; 768| 955|} ogs-tlv-msg.c:tlv_parse_compound: 643| 4.10k|{ 644| 4.10k| int rv; 645| 4.10k| ogs_tlv_presence_t *presence_p = (ogs_tlv_presence_t *)msg; 646| 4.10k| ogs_tlv_desc_t *desc = NULL, *next_desc = NULL; 647| 4.10k| ogs_tlv_t *tlv = NULL, *emb_tlv = NULL; 648| 4.10k| uint8_t *p = msg; 649| 4.10k| uint32_t offset = 0; 650| 4.10k| uint8_t index = 0; 651| 4.10k| int i = 0, j; 652| 4.10k| OGS_RBTREE(tree); ------------------ | | 48| 4.10k|#define OGS_RBTREE(name) ogs_rbtree_t name = { NULL } ------------------ 653| 4.10k| tlv_count_node_t count_node[OGS_TLV_MAX_CHILD_DESC]; 654| 4.10k| unsigned count_node_alloc_next = 0; 655| 4.10k| char indent[17] = " "; /* 16 spaces */ 656| | 657| 4.10k| ogs_assert(msg); ------------------ | | 113| 4.10k| do { \ | | 114| 4.10k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4.10k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4.10k, False: 0] | | | | ------------------ | | ------------------ | | 115| 4.10k| 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| 4.10k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 4.10k] | | ------------------ ------------------ 658| 4.10k| ogs_assert(parent_desc); ------------------ | | 113| 4.10k| do { \ | | 114| 4.10k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4.10k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4.10k, False: 0] | | | | ------------------ | | ------------------ | | 115| 4.10k| 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| 4.10k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 4.10k] | | ------------------ ------------------ 659| 4.10k| ogs_assert(parent_tlv); ------------------ | | 113| 4.10k| do { \ | | 114| 4.10k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4.10k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4.10k, False: 0] | | | | ------------------ | | ------------------ | | 115| 4.10k| 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| 4.10k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 4.10k] | | ------------------ ------------------ 660| | 661| 4.10k| ogs_assert(depth <= 8); ------------------ | | 113| 4.10k| do { \ | | 114| 4.10k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4.10k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4.10k, False: 0] | | | | ------------------ | | ------------------ | | 115| 4.10k| 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| 4.10k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 4.10k] | | ------------------ ------------------ 662| 4.10k| indent[depth*2] = 0; 663| | 664| 4.10k| tlv = parent_tlv; 665| 18.8k| while (tlv) { ------------------ | Branch (665:12): [True: 14.8k, False: 3.98k] ------------------ 666| 14.8k| tlv_count_node_t *curr_count = tlv_count_node_find(&tree, &count_node[0], 667| 14.8k| OGS_ARRAY_SIZE(count_node), &count_node_alloc_next, tlv->type, tlv->instance); ------------------ | | 165| 14.8k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 668| 14.8k| if (!curr_count) ------------------ | Branch (668:13): [True: 2, False: 14.8k] ------------------ 669| 2| return OGS_ERROR; ------------------ | | 78| 2|#define OGS_ERROR -1 ------------------ 670| 14.8k| desc = tlv_find_desc_by_type_inst(&index, &offset, parent_desc, tlv->type, tlv->instance, curr_count->count); 671| 14.8k| if (desc == NULL) { ------------------ | Branch (671:13): [True: 7.76k, False: 7.11k] ------------------ 672| 7.76k| ogs_warn("Unknown TLV type [%d]", tlv->type); ------------------ | | 37| 7.76k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7.76k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 7.76k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 7.76k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7.76k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7.76k| 0, __VA_ARGS__) | | ------------------ ------------------ 673| 7.76k| tlv = tlv->next; 674| 7.76k| continue; 675| 7.76k| } 676| | 677| 7.11k| presence_p = (ogs_tlv_presence_t *)(p + offset); 678| | 679| | /* Multiple of the same type TLV may be included */ 680| 7.11k| next_desc = parent_desc->child_descs[index+1]; 681| 7.11k| if (next_desc != NULL && next_desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (681:13): [True: 6.90k, False: 209] | Branch (681:34): [True: 4.11k, False: 2.78k] ------------------ 682| 19.8k| for (j = 0; j < next_desc->length; j++) { ------------------ | Branch (682:25): [True: 19.5k, False: 353] ------------------ 683| 19.5k| presence_p = 684| 19.5k| (ogs_tlv_presence_t *)(p + offset + desc->vsize * j); 685| 19.5k| if (*presence_p == 0) { ------------------ | Branch (685:21): [True: 3.76k, False: 15.7k] ------------------ 686| 3.76k| offset += desc->vsize * j; 687| 3.76k| break; 688| 3.76k| } 689| 19.5k| } 690| 4.11k| if (j == next_desc->length) { ------------------ | Branch (690:17): [True: 353, False: 3.76k] ------------------ 691| 353| ogs_fatal("Multiple of the same type TLV need more room"); ------------------ | | 35| 353|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | ------------------ | | | | 43| 353| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 353|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 353| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 353|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 353| 0, __VA_ARGS__) | | ------------------ ------------------ 692| 353| tlv = tlv->next; 693| 353| continue; 694| 353| } 695| 4.11k| } else { 696| 2.99k| curr_count->count++; 697| 2.99k| } 698| | 699| 6.76k| if (desc->ctype == OGS_TLV_COMPOUND) { ------------------ | Branch (699:13): [True: 3.31k, False: 3.44k] ------------------ 700| 3.31k| emb_tlv = ogs_tlv_parse_embedded_block(tlv, mode); 701| 3.31k| if (emb_tlv == NULL) { ------------------ | Branch (701:17): [True: 27, False: 3.29k] ------------------ 702| 27| ogs_error("Error while parse TLV"); ------------------ | | 36| 27|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 27| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 27|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 27| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 27|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 27| 0, __VA_ARGS__) | | ------------------ ------------------ 703| 27| return OGS_ERROR; ------------------ | | 78| 27|#define OGS_ERROR -1 ------------------ 704| 27| } 705| | 706| 3.29k| ogs_trace("PARSE %sC#%d [%s] T:%d I:%d (vsz=%d) off:%p ", ------------------ | | 40| 3.29k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.29k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 3.29k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 3.29k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.29k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.29k| 0, __VA_ARGS__) | | ------------------ ------------------ 707| 3.29k| indent, i++, desc->name, desc->type, desc->instance, 708| 3.29k| desc->vsize, p + offset); 709| | 710| 3.29k| offset += sizeof(ogs_tlv_presence_t); 711| | 712| 3.29k| rv = tlv_parse_compound( 713| 3.29k| p + offset, desc, emb_tlv, depth + 1, mode); 714| 3.29k| if (rv != OGS_OK) { ------------------ | | 77| 3.29k|#define OGS_OK 0 ------------------ | Branch (714:17): [True: 28, False: 3.26k] ------------------ 715| 28| ogs_error("Can't parse compound TLV"); ------------------ | | 36| 28|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 28| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 28|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 28| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 28|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 28| 0, __VA_ARGS__) | | ------------------ ------------------ 716| 28| return OGS_ERROR; ------------------ | | 78| 28|#define OGS_ERROR -1 ------------------ 717| 28| } 718| | 719| 3.26k| *presence_p = 1; 720| 3.44k| } else { 721| 3.44k| ogs_trace("PARSE %sL#%d [%s] T:%d L:%d I:%d " ------------------ | | 40| 3.44k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.44k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 3.44k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 3.44k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.44k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.44k| 0, __VA_ARGS__) | | ------------------ ------------------ 722| 3.44k| "(cls:%d vsz:%d) off:%p ", 723| 3.44k| indent, i++, desc->name, desc->type, desc->length, 724| 3.44k| desc->instance, desc->ctype, desc->vsize, p + offset); 725| | 726| 3.44k| rv = tlv_parse_leaf(p + offset, desc, tlv); 727| 3.44k| if (rv != OGS_OK) { ------------------ | | 77| 3.44k|#define OGS_OK 0 ------------------ | Branch (727:17): [True: 65, False: 3.37k] ------------------ 728| 65| ogs_error("Can't parse leaf TLV"); ------------------ | | 36| 65|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 65| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 65|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 65| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 65|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 65| 0, __VA_ARGS__) | | ------------------ ------------------ 729| 65| return OGS_ERROR; ------------------ | | 78| 65|#define OGS_ERROR -1 ------------------ 730| 65| } 731| | 732| 3.37k| *presence_p = 1; 733| 3.37k| } 734| | 735| 6.64k| tlv = tlv->next; 736| 6.64k| } 737| | 738| 3.98k| return OGS_OK; ------------------ | | 77| 3.98k|#define OGS_OK 0 ------------------ 739| 4.10k|} ogs-tlv-msg.c:tlv_count_node_find: 608| 14.8k|{ 609| 14.8k| ogs_rbnode_t **new = NULL; 610| 14.8k| ogs_rbnode_t *parent = NULL; 611| 14.8k| tlv_count_node_t *this; 612| | 613| 14.8k| uint64_t key = (((uint32_t)type)<<8) | instance; 614| | 615| 14.8k| new = &tree->root; 616| 43.8k| while (*new) { ------------------ | Branch (616:12): [True: 33.0k, False: 10.7k] ------------------ 617| 33.0k| this = ogs_rb_entry(*new, tlv_count_node_t, node); ------------------ | | 50| 33.0k|#define ogs_rb_entry(ptr, type, member) ogs_container_of(ptr, type, member) | | ------------------ | | | | 188| 33.0k| (type *)((unsigned char *)ptr - offsetof(type, member)) | | ------------------ ------------------ 618| 33.0k| parent = *new; 619| 33.0k| if (key < this->key) { ------------------ | Branch (619:13): [True: 14.4k, False: 18.6k] ------------------ 620| 14.4k| new = &(*new)->left; 621| 18.6k| } else if (key > this->key) { ------------------ | Branch (621:20): [True: 14.5k, False: 4.08k] ------------------ 622| 14.5k| new = &(*new)->right; 623| 14.5k| } else { /* found entry: */ 624| 4.08k| return this; 625| 4.08k| } 626| 33.0k| } 627| | 628| | /* No entry, need to add one: */ 629| 10.7k| if (*count_alloc_next == count_node_arr_len) { ------------------ | Branch (629:9): [True: 2, False: 10.7k] ------------------ 630| 2| ogs_error("This TLV has to many entries, can't parse"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 2|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 631| 2| return NULL; 632| 2| } 633| 10.7k| this = &count_node_arr[(*count_alloc_next)++]; 634| 10.7k| this->key = key; 635| 10.7k| this->count = 0; 636| 10.7k| ogs_rbtree_link_node(&this->node, parent, new); 637| 10.7k| ogs_rbtree_insert_color(tree, &this->node); 638| 10.7k| return this; 639| 10.7k|} ogs-tlv-msg.c:tlv_find_desc_by_type_inst: 456| 14.8k|{ 457| 14.8k| ogs_tlv_desc_t *prev_desc = NULL, *desc = NULL; 458| 14.8k| int i, offset = 0; 459| 14.8k| unsigned match_i = 0; 460| | 461| 14.8k| ogs_assert(parent_desc); ------------------ | | 113| 14.8k| do { \ | | 114| 14.8k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 14.8k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 14.8k, False: 0] | | | | ------------------ | | ------------------ | | 115| 14.8k| 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| 14.8k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 14.8k] | | ------------------ ------------------ 462| | 463| 200k| for (i = 0, desc = parent_desc->child_descs[i]; desc != NULL; ------------------ | Branch (463:53): [True: 192k, False: 7.76k] ------------------ 464| 192k| i++, desc = parent_desc->child_descs[i]) { 465| 192k| if (desc->type == match_type && desc->instance == match_instance) { ------------------ | Branch (465:13): [True: 8.04k, False: 184k] | Branch (465:41): [True: 8.04k, False: 0] ------------------ 466| 8.04k| if (match_i == match_type_pos) { ------------------ | Branch (466:17): [True: 7.11k, False: 926] ------------------ 467| 7.11k| *desc_index = i; 468| 7.11k| *tlv_offset = offset; 469| 7.11k| break; 470| 7.11k| } 471| 926| match_i++; 472| 926| } 473| | 474| 185k| if (desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (474:13): [True: 13.5k, False: 171k] ------------------ 475| 13.5k| ogs_assert(prev_desc && prev_desc->ctype != OGS_TLV_MORE); ------------------ | | 113| 13.5k| do { \ | | 114| 13.5k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 27.0k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 13.5k, False: 0] | | | | | Branch (54:44): [True: 13.5k, False: 0] | | | | | Branch (54:44): [True: 13.5k, False: 0] | | | | ------------------ | | ------------------ | | 115| 13.5k| 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| 13.5k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 13.5k] | | ------------------ ------------------ 476| 13.5k| offset += prev_desc->vsize * (desc->length - 1); 477| 171k| } else { 478| 171k| offset += desc->vsize; 479| 171k| } 480| | 481| 185k| prev_desc = desc; 482| 185k| } 483| | 484| 14.8k| return desc; 485| 14.8k|} ogs-tlv-msg.c:tlv_parse_leaf: 488| 3.44k|{ 489| 3.44k| ogs_assert(msg); ------------------ | | 113| 3.44k| do { \ | | 114| 3.44k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.44k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.44k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.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| 3.44k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.44k] | | ------------------ ------------------ 490| 3.44k| ogs_assert(desc); ------------------ | | 113| 3.44k| do { \ | | 114| 3.44k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.44k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.44k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.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| 3.44k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.44k] | | ------------------ ------------------ 491| 3.44k| ogs_assert(tlv); ------------------ | | 113| 3.44k| do { \ | | 114| 3.44k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.44k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.44k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.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| 3.44k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.44k] | | ------------------ ------------------ 492| | 493| 3.44k| switch (desc->ctype) { 494| 0| case OGS_TV_UINT8: ------------------ | Branch (494:5): [True: 0, False: 3.44k] ------------------ 495| 0| case OGS_TV_INT8: ------------------ | Branch (495:5): [True: 0, False: 3.44k] ------------------ 496| 155| case OGS_TLV_UINT8: ------------------ | Branch (496:5): [True: 155, False: 3.28k] ------------------ 497| 155| case OGS_TLV_INT8: ------------------ | Branch (497:5): [True: 0, False: 3.44k] ------------------ 498| 155| { 499| 155| ogs_tlv_uint8_t *v = (ogs_tlv_uint8_t *)msg; 500| | 501| 155| if (tlv->length != 1) { ------------------ | Branch (501:13): [True: 16, False: 139] ------------------ 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| 139| v->u8 = *(uint8_t*)(tlv->value); 506| 139| break; 507| 155| } 508| 0| case OGS_TV_UINT16: ------------------ | Branch (508:5): [True: 0, False: 3.44k] ------------------ 509| 0| case OGS_TV_INT16: ------------------ | Branch (509:5): [True: 0, False: 3.44k] ------------------ 510| 149| case OGS_TLV_UINT16: ------------------ | Branch (510:5): [True: 149, False: 3.29k] ------------------ 511| 149| case OGS_TLV_INT16: ------------------ | Branch (511:5): [True: 0, False: 3.44k] ------------------ 512| 149| { 513| 149| ogs_tlv_uint16_t *v = (ogs_tlv_uint16_t *)msg; 514| | 515| 149| if (tlv->length != 2) { ------------------ | Branch (515:13): [True: 11, False: 138] ------------------ 516| 11| ogs_error("Invalid TLV length %d. It should be 2", tlv->length); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 11|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 517| 11| return OGS_ERROR; ------------------ | | 78| 11|#define OGS_ERROR -1 ------------------ 518| 11| } 519| 138| v->u16 = ((((uint8_t*)tlv->value)[0]<< 8)&0xff00) | 520| 138| ((((uint8_t*)tlv->value)[1] )&0x00ff); 521| 138| break; 522| 149| } 523| 0| case OGS_TV_UINT24: ------------------ | Branch (523:5): [True: 0, False: 3.44k] ------------------ 524| 0| case OGS_TV_INT24: ------------------ | Branch (524:5): [True: 0, False: 3.44k] ------------------ 525| 43| case OGS_TLV_UINT24: ------------------ | Branch (525:5): [True: 43, False: 3.40k] ------------------ 526| 43| case OGS_TLV_INT24: ------------------ | Branch (526:5): [True: 0, False: 3.44k] ------------------ 527| 43| { 528| 43| ogs_tlv_uint24_t *v = (ogs_tlv_uint24_t *)msg; 529| | 530| 43| if (tlv->length != 3) { ------------------ | Branch (530:13): [True: 9, False: 34] ------------------ 531| 9| ogs_error("Invalid TLV length %d. It should be 3", tlv->length); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 9|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 532| 9| return OGS_ERROR; ------------------ | | 78| 9|#define OGS_ERROR -1 ------------------ 533| 9| } 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| 43| } 539| 0| case OGS_TV_UINT32: ------------------ | Branch (539:5): [True: 0, False: 3.44k] ------------------ 540| 0| case OGS_TV_INT32: ------------------ | Branch (540:5): [True: 0, False: 3.44k] ------------------ 541| 257| case OGS_TLV_UINT32: ------------------ | Branch (541:5): [True: 257, False: 3.18k] ------------------ 542| 257| case OGS_TLV_INT32: ------------------ | Branch (542:5): [True: 0, False: 3.44k] ------------------ 543| 257| { 544| 257| ogs_tlv_uint32_t *v = (ogs_tlv_uint32_t *)msg; 545| | 546| 257| if (tlv->length != 4) { ------------------ | Branch (546:13): [True: 16, False: 241] ------------------ 547| 16| ogs_error("Invalid TLV length %d. It should be 4", tlv->length); ------------------ | | 36| 16|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 16| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 16|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 16| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 16|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 16| 0, __VA_ARGS__) | | ------------------ ------------------ 548| 16| return OGS_ERROR; ------------------ | | 78| 16|#define OGS_ERROR -1 ------------------ 549| 16| } 550| 241| v->u32 = (((uint32_t)((uint8_t*)tlv->value)[0]<<24)&0xff000000) | 551| 241| ((((uint8_t*)tlv->value)[1]<<16)&0x00ff0000) | 552| 241| ((((uint8_t*)tlv->value)[2]<< 8)&0x0000ff00) | 553| 241| ((((uint8_t*)tlv->value)[3] )&0x000000ff); 554| 241| break; 555| 257| } 556| 0| case OGS_TV_FIXED_STR: ------------------ | Branch (556:5): [True: 0, False: 3.44k] ------------------ 557| 0| case OGS_TLV_FIXED_STR: ------------------ | Branch (557:5): [True: 0, False: 3.44k] ------------------ 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| 2.82k| case OGS_TLV_VAR_STR: ------------------ | Branch (572:5): [True: 2.82k, False: 617] ------------------ 573| 2.82k| { 574| 2.82k| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 575| | 576| 2.82k| v->data = tlv->value; 577| 2.82k| v->len = tlv->length; 578| 2.82k| break; 579| 0| } 580| 0| case OGS_TV_NULL: ------------------ | Branch (580:5): [True: 0, False: 3.44k] ------------------ 581| 0| case OGS_TLV_NULL: ------------------ | Branch (581:5): [True: 0, False: 3.44k] ------------------ 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| 13| default: ------------------ | Branch (589:5): [True: 13, False: 3.43k] ------------------ 590| 13| ogs_error("Unknown type[%d]", desc->ctype); ------------------ | | 36| 13|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 13| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 13|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 13| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 13|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 13| 0, __VA_ARGS__) | | ------------------ ------------------ 591| 13| return OGS_ERROR; ------------------ | | 78| 13|#define OGS_ERROR -1 ------------------ 592| 3.44k| } 593| | 594| 3.37k| return OGS_OK; ------------------ | | 77| 3.37k|#define OGS_OK 0 ------------------ 595| 3.44k|} ogs_tlv_get: 30| 16.5k|{ 31| 16.5k| ogs_tlv_t *tlv = NULL; 32| | 33| | /* get tlv node from node pool */ 34| 16.5k| ogs_pool_alloc(&pool, &tlv); ------------------ | | 132| 16.5k|#define ogs_pool_alloc(pool, node) do { \ | | 133| 16.5k| *(node) = NULL; \ | | 134| 16.5k| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 16.5k, False: 0] | | ------------------ | | 135| 16.5k| (pool)->avail--; \ | | 136| 16.5k| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 16.5k| (pool)->free[(pool)->head] = NULL; \ | | 138| 16.5k| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 16.5k| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 16.5k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 16.5k| } \ | | 141| 16.5k|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 16.5k] | | ------------------ ------------------ 35| | 36| | /* check for error */ 37| 16.5k| if (!tlv) { ------------------ | Branch (37:9): [True: 0, False: 16.5k] ------------------ 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| 16.5k| memset(tlv, 0, sizeof(ogs_tlv_t)); 44| 16.5k| return tlv; 45| 16.5k|} ogs_tlv_free: 48| 16.5k|{ 49| | /* free tlv node to the node pool */ 50| | ogs_pool_free(&pool, tlv); ------------------ | | 143| 16.5k|#define ogs_pool_free(pool, node) do { \ | | 144| 16.5k| if ((pool)->avail < (pool)->size) { \ | | ------------------ | | | Branch (144:9): [True: 16.5k, False: 0] | | ------------------ | | 145| 16.5k| (pool)->avail++; \ | | 146| 16.5k| (pool)->free[(pool)->tail] = (void*)(node); \ | | 147| 16.5k| (pool)->tail = ((pool)->tail + 1) % ((pool)->size); \ | | 148| 16.5k| (pool)->index[ogs_pool_index(pool, node)-1] = NULL; \ | | ------------------ | | | | 152| 16.5k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 149| 16.5k| } \ | | 150| 16.5k|} while (0) | | ------------------ | | | Branch (150:10): [Folded, False: 16.5k] | | ------------------ ------------------ 51| 16.5k|} 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| 4.27k|{ 70| | /* free all tlv node to the node pool */ 71| 4.27k| ogs_tlv_t *iter = root; 72| 4.27k| ogs_tlv_t *next = NULL; 73| 20.8k| while (iter) { ------------------ | Branch (73:12): [True: 16.5k, False: 4.27k] ------------------ 74| 16.5k| if(iter->embedded != NULL) { ------------------ | Branch (74:12): [True: 3.29k, False: 13.3k] ------------------ 75| 3.29k| ogs_tlv_free_all(iter->embedded); 76| 3.29k| } 77| 16.5k| next = iter->next; 78| 16.5k| ogs_tlv_free(iter); 79| 16.5k| iter = next; 80| 16.5k| } 81| 4.27k|} tlv_get_element: 224| 16.5k|{ 225| 16.5k| uint8_t *pos = blk; 226| 16.5k| uint32_t header_length; 227| | 228| 16.5k| tlv->mode = mode; 229| | 230| 16.5k| 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: 16.5k] ------------------ 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: 16.5k] ------------------ 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: 16.5k] ------------------ 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| 16.5k| case OGS_TLV_MODE_T2_L2: ------------------ | | 35| 16.5k|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (255:5): [True: 16.5k, False: 0] ------------------ 256| 16.5k| header_length = 4; 257| 16.5k| if (size < header_length) ------------------ | Branch (257:13): [True: 79, False: 16.5k] ------------------ 258| 79| return NULL; 259| 16.5k| tlv->type = *(pos++) << 8; 260| 16.5k| tlv->type += *(pos++); 261| 16.5k| tlv->length = *(pos++) << 8; 262| 16.5k| tlv->length += *(pos++); 263| 16.5k| break; 264| 0| case OGS_TLV_MODE_T1: ------------------ | | 36| 0|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (264:5): [True: 0, False: 16.5k] ------------------ 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: 16.5k] ------------------ 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| 16.5k| } 275| | 276| 16.5k| if (tlv->length > size - header_length) ------------------ | Branch (276:9): [True: 90, False: 16.4k] ------------------ 277| 90| return NULL; 278| | 279| 16.4k| tlv->value = pos; 280| | 281| 16.4k| return (pos + ogs_tlv_length(tlv)); ------------------ | | 67| 16.4k|#define ogs_tlv_length(pTlv) pTlv->length ------------------ 282| 16.5k|} ogs_tlv_parse_block: 463| 4.27k|{ 464| 4.27k| uint8_t *pos = data; 465| 4.27k| uint8_t *blk = data; 466| | 467| 4.27k| ogs_tlv_t *root = NULL; 468| 4.27k| ogs_tlv_t *prev = NULL; 469| 4.27k| ogs_tlv_t *curr = NULL; 470| | 471| 4.27k| root = curr = ogs_tlv_get(); 472| 4.27k| if (!curr) { ------------------ | Branch (472:9): [True: 0, False: 4.27k] ------------------ 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| 4.27k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 485| 4.27k| if (!pos) { ------------------ | Branch (485:9): [True: 110, False: 4.16k] ------------------ 486| 110| ogs_error("ogs_tlv_parse_block() failed[LEN:%u,MODE:%u] - parse error", ------------------ | | 36| 110|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 110| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 110|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 110| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 110|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 110| 0, __VA_ARGS__) | | ------------------ ------------------ 487| 110| 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| 110| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 220| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 110|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 106, False: 4] | | ------------------ ------------------ 494| 110| ogs_tlv_free_all(root); 495| 110| return NULL; 496| 110| } 497| | 498| 16.4k| while(pos - blk < length) { ------------------ | Branch (498:11): [True: 12.3k, False: 4.10k] ------------------ 499| 12.3k| prev = curr; 500| | 501| 12.3k| curr = ogs_tlv_get(); 502| 12.3k| if (!curr) { ------------------ | Branch (502:13): [True: 0, False: 12.3k] ------------------ 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| 12.3k| prev->next = curr; 516| | 517| 12.3k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 518| 12.3k| if (!pos) { ------------------ | Branch (518:13): [True: 59, False: 12.2k] ------------------ 519| 59| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 59|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 59| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 59|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 59| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 59|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 59| 0, __VA_ARGS__) | | ------------------ ------------------ 520| 59| 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| 59| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 118| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 59|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 41, False: 18] | | ------------------ ------------------ 527| | 528| 59| ogs_tlv_free_all(root); 529| 59| return NULL; 530| 59| } 531| 12.3k| } 532| | 533| 4.10k| if (length != (pos - blk)) { ------------------ | Branch (533:9): [True: 0, False: 4.10k] ------------------ 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| 4.10k| return root; 543| 4.10k|} ogs_tlv_parse_embedded_block: 546| 3.31k|{ 547| 3.31k| tlv->embedded = ogs_tlv_parse_block(tlv->length, tlv->value, mode); 548| | 549| 3.31k| return tlv->embedded; 550| 3.31k|} ogs_pfcp_parse_msg: 5692| 973|{ 5693| 973| int rv = OGS_ERROR; ------------------ | | 78| 973|#define OGS_ERROR -1 ------------------ 5694| 973| ogs_pfcp_header_t *h = NULL; 5695| 973| uint16_t size = 0; 5696| | 5697| 973| ogs_pfcp_message_t *pfcp_message = NULL; 5698| | 5699| 973| ogs_assert(pkbuf); ------------------ | | 113| 973| do { \ | | 114| 973| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 973|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 973, False: 0] | | | | ------------------ | | ------------------ | | 115| 973| 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| 973| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 973] | | ------------------ ------------------ 5700| 973| ogs_assert(pkbuf->len); ------------------ | | 113| 973| do { \ | | 114| 973| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 973|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 973, False: 0] | | | | ------------------ | | ------------------ | | 115| 973| 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| 973| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 973] | | ------------------ ------------------ 5701| | 5702| 973| h = (ogs_pfcp_header_t *)pkbuf->data; 5703| 973| ogs_assert(h); ------------------ | | 113| 973| do { \ | | 114| 973| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 973|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 973, False: 0] | | | | ------------------ | | ------------------ | | 115| 973| 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| 973| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 973] | | ------------------ ------------------ 5704| | 5705| 973| pfcp_message = ogs_calloc(1, sizeof(*pfcp_message)); ------------------ | | 70| 973| ogs_talloc_zero_size(__ogs_talloc_core, (nmemb) * (size), __location__) ------------------ 5706| 973| if (!pfcp_message) { ------------------ | Branch (5706:9): [True: 0, False: 973] ------------------ 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| 973| if (h->seid_presence) ------------------ | Branch (5711:9): [True: 60, False: 913] ------------------ 5712| 60| size = OGS_PFCP_HEADER_LEN; ------------------ | | 39| 60|#define OGS_PFCP_HEADER_LEN 16 ------------------ 5713| 913| else 5714| 913| size = OGS_PFCP_HEADER_LEN-OGS_PFCP_SEID_LEN; ------------------ | | 39| 913|#define OGS_PFCP_HEADER_LEN 16 ------------------ size = OGS_PFCP_HEADER_LEN-OGS_PFCP_SEID_LEN; ------------------ | | 40| 913|#define OGS_PFCP_SEID_LEN 8 ------------------ 5715| | 5716| 973| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (5716:9): [True: 7, False: 966] ------------------ 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| 966| memcpy(&pfcp_message->h, pkbuf->data - size, size); 5722| | 5723| 966| if (h->seid_presence) { ------------------ | Branch (5723:9): [True: 56, False: 910] ------------------ 5724| 56| pfcp_message->h.seid = be64toh(pfcp_message->h.seid); 5725| 910| } else { 5726| 910| pfcp_message->h.sqn = pfcp_message->h.sqn_only; 5727| 910| } 5728| | 5729| 966| if (pkbuf->len == 0) ------------------ | Branch (5729:9): [True: 5, False: 961] ------------------ 5730| 5| return pfcp_message; 5731| | 5732| 961| switch(pfcp_message->h.type) 5733| 961| { 5734| 34| case OGS_PFCP_HEARTBEAT_REQUEST_TYPE: ------------------ | | 67| 34|#define OGS_PFCP_HEARTBEAT_REQUEST_TYPE 1 ------------------ | Branch (5734:9): [True: 34, False: 927] ------------------ 5735| 34| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_heartbeat_request, 5736| 34| &ogs_pfcp_msg_desc_pfcp_heartbeat_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 34|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5737| 34| ogs_expect(rv == OGS_OK); ------------------ | | 128| 34| do { \ | | 129| 34| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 34|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 19, False: 15] | | | | ------------------ | | ------------------ | | 130| 34| else { \ | | 131| 15| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 15|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 15| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 15|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 15| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 15|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 15| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 15| } \ | | 133| 34| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 34] | | ------------------ ------------------ 5738| 34| break; 5739| 10| case OGS_PFCP_HEARTBEAT_RESPONSE_TYPE: ------------------ | | 68| 10|#define OGS_PFCP_HEARTBEAT_RESPONSE_TYPE 2 ------------------ | Branch (5739:9): [True: 10, False: 951] ------------------ 5740| 10| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_heartbeat_response, 5741| 10| &ogs_pfcp_msg_desc_pfcp_heartbeat_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 10|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5742| 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: 7, False: 3] | | | | ------------------ | | ------------------ | | 130| 10| 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| 10| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 10] | | ------------------ ------------------ 5743| 10| break; 5744| 20| case OGS_PFCP_PFD_MANAGEMENT_REQUEST_TYPE: ------------------ | | 69| 20|#define OGS_PFCP_PFD_MANAGEMENT_REQUEST_TYPE 3 ------------------ | Branch (5744:9): [True: 20, False: 941] ------------------ 5745| 20| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_pfd_management_request, 5746| 20| &ogs_pfcp_msg_desc_pfcp_pfd_management_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 20|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5747| 20| ogs_expect(rv == OGS_OK); ------------------ | | 128| 20| do { \ | | 129| 20| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 20|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 18, False: 2] | | | | ------------------ | | ------------------ | | 130| 20| 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| 20| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 20] | | ------------------ ------------------ 5748| 20| break; 5749| 17| case OGS_PFCP_PFD_MANAGEMENT_RESPONSE_TYPE: ------------------ | | 70| 17|#define OGS_PFCP_PFD_MANAGEMENT_RESPONSE_TYPE 4 ------------------ | Branch (5749:9): [True: 17, False: 944] ------------------ 5750| 17| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_pfd_management_response, 5751| 17| &ogs_pfcp_msg_desc_pfcp_pfd_management_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 17|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5752| 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: 9, False: 8] | | | | ------------------ | | ------------------ | | 130| 17| 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| 17| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 17] | | ------------------ ------------------ 5753| 17| break; 5754| 88| case OGS_PFCP_ASSOCIATION_SETUP_REQUEST_TYPE: ------------------ | | 71| 88|#define OGS_PFCP_ASSOCIATION_SETUP_REQUEST_TYPE 5 ------------------ | Branch (5754:9): [True: 88, False: 873] ------------------ 5755| 88| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_setup_request, 5756| 88| &ogs_pfcp_msg_desc_pfcp_association_setup_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 88|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5757| 88| ogs_expect(rv == OGS_OK); ------------------ | | 128| 88| do { \ | | 129| 88| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 88|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 61, False: 27] | | | | ------------------ | | ------------------ | | 130| 88| else { \ | | 131| 27| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 27|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 27| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 27|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 27| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 27|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 27| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 27| } \ | | 133| 88| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 88] | | ------------------ ------------------ 5758| 88| break; 5759| 8| case OGS_PFCP_ASSOCIATION_SETUP_RESPONSE_TYPE: ------------------ | | 72| 8|#define OGS_PFCP_ASSOCIATION_SETUP_RESPONSE_TYPE 6 ------------------ | Branch (5759:9): [True: 8, False: 953] ------------------ 5760| 8| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_setup_response, 5761| 8| &ogs_pfcp_msg_desc_pfcp_association_setup_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 8|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5762| 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] | | ------------------ ------------------ 5763| 8| break; 5764| 19| case OGS_PFCP_ASSOCIATION_UPDATE_REQUEST_TYPE: ------------------ | | 73| 19|#define OGS_PFCP_ASSOCIATION_UPDATE_REQUEST_TYPE 7 ------------------ | Branch (5764:9): [True: 19, False: 942] ------------------ 5765| 19| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_update_request, 5766| 19| &ogs_pfcp_msg_desc_pfcp_association_update_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 19|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5767| 19| ogs_expect(rv == OGS_OK); ------------------ | | 128| 19| do { \ | | 129| 19| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 19|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 13, False: 6] | | | | ------------------ | | ------------------ | | 130| 19| 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| 19| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 19] | | ------------------ ------------------ 5768| 19| break; 5769| 7| case OGS_PFCP_ASSOCIATION_UPDATE_RESPONSE_TYPE: ------------------ | | 74| 7|#define OGS_PFCP_ASSOCIATION_UPDATE_RESPONSE_TYPE 8 ------------------ | Branch (5769:9): [True: 7, False: 954] ------------------ 5770| 7| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_update_response, 5771| 7| &ogs_pfcp_msg_desc_pfcp_association_update_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 7|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5772| 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: 4, False: 3] | | | | ------------------ | | ------------------ | | 130| 7| 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| 7| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 7] | | ------------------ ------------------ 5773| 7| break; 5774| 7| case OGS_PFCP_ASSOCIATION_RELEASE_REQUEST_TYPE: ------------------ | | 75| 7|#define OGS_PFCP_ASSOCIATION_RELEASE_REQUEST_TYPE 9 ------------------ | Branch (5774:9): [True: 7, False: 954] ------------------ 5775| 7| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_association_release_request, 5776| 7| &ogs_pfcp_msg_desc_pfcp_association_release_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 7|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5777| 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: 2, False: 5] | | | | ------------------ | | ------------------ | | 130| 7| 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| 7| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 7] | | ------------------ ------------------ 5778| 7| 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: 950] ------------------ 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: 1, False: 10] | | | | ------------------ | | ------------------ | | 130| 11| else { \ | | 131| 10| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 10|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 10| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 10| } \ | | 133| 11| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 11] | | ------------------ ------------------ 5783| 11| break; 5784| 2| case OGS_PFCP_VERSION_NOT_SUPPORTED_RESPONSE_TYPE: ------------------ | | 77| 2|#define OGS_PFCP_VERSION_NOT_SUPPORTED_RESPONSE_TYPE 11 ------------------ | Branch (5784:9): [True: 2, False: 959] ------------------ 5785| 2| break; 5786| 4| case OGS_PFCP_NODE_REPORT_REQUEST_TYPE: ------------------ | | 78| 4|#define OGS_PFCP_NODE_REPORT_REQUEST_TYPE 12 ------------------ | Branch (5786:9): [True: 4, False: 957] ------------------ 5787| 4| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_node_report_request, 5788| 4| &ogs_pfcp_msg_desc_pfcp_node_report_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 4|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5789| 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: 1, False: 3] | | | | ------------------ | | ------------------ | | 130| 4| 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| 4| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 4] | | ------------------ ------------------ 5790| 4| break; 5791| 12| case OGS_PFCP_NODE_REPORT_RESPONSE_TYPE: ------------------ | | 79| 12|#define OGS_PFCP_NODE_REPORT_RESPONSE_TYPE 13 ------------------ | Branch (5791:9): [True: 12, False: 949] ------------------ 5792| 12| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_node_report_response, 5793| 12| &ogs_pfcp_msg_desc_pfcp_node_report_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 12|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5794| 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: 2, False: 10] | | | | ------------------ | | ------------------ | | 130| 12| else { \ | | 131| 10| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 10|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 10| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 10| } \ | | 133| 12| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 12] | | ------------------ ------------------ 5795| 12| break; 5796| 9| case OGS_PFCP_SESSION_SET_DELETION_REQUEST_TYPE: ------------------ | | 80| 9|#define OGS_PFCP_SESSION_SET_DELETION_REQUEST_TYPE 14 ------------------ | Branch (5796:9): [True: 9, False: 952] ------------------ 5797| 9| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_deletion_request, 5798| 9| &ogs_pfcp_msg_desc_pfcp_session_set_deletion_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 9|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5799| 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: 6, False: 3] | | | | ------------------ | | ------------------ | | 130| 9| 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| 9| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 9] | | ------------------ ------------------ 5800| 9| break; 5801| 5| case OGS_PFCP_SESSION_SET_DELETION_RESPONSE_TYPE: ------------------ | | 81| 5|#define OGS_PFCP_SESSION_SET_DELETION_RESPONSE_TYPE 15 ------------------ | Branch (5801:9): [True: 5, False: 956] ------------------ 5802| 5| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_deletion_response, 5803| 5| &ogs_pfcp_msg_desc_pfcp_session_set_deletion_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 5|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5804| 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] | | ------------------ ------------------ 5805| 5| break; 5806| 5| case OGS_PFCP_SESSION_SET_MODIFICATION_REQUEST_TYPE: ------------------ | | 82| 5|#define OGS_PFCP_SESSION_SET_MODIFICATION_REQUEST_TYPE 16 ------------------ | Branch (5806:9): [True: 5, False: 956] ------------------ 5807| 5| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_modification_request, 5808| 5| &ogs_pfcp_msg_desc_pfcp_session_set_modification_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 5|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5809| 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: 3, False: 2] | | | | ------------------ | | ------------------ | | 130| 5| 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| 5| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 5] | | ------------------ ------------------ 5810| 5| break; 5811| 5| case OGS_PFCP_SESSION_SET_MODIFICATION_RESPONSE_TYPE: ------------------ | | 83| 5|#define OGS_PFCP_SESSION_SET_MODIFICATION_RESPONSE_TYPE 17 ------------------ | Branch (5811:9): [True: 5, False: 956] ------------------ 5812| 5| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_set_modification_response, 5813| 5| &ogs_pfcp_msg_desc_pfcp_session_set_modification_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 5|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5814| 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] | | ------------------ ------------------ 5815| 5| break; 5816| 300| case OGS_PFCP_SESSION_ESTABLISHMENT_REQUEST_TYPE: ------------------ | | 84| 300|#define OGS_PFCP_SESSION_ESTABLISHMENT_REQUEST_TYPE 50 ------------------ | Branch (5816:9): [True: 300, False: 661] ------------------ 5817| 300| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_establishment_request, 5818| 300| &ogs_pfcp_msg_desc_pfcp_session_establishment_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 300|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5819| 300| ogs_expect(rv == OGS_OK); ------------------ | | 128| 300| do { \ | | 129| 300| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 300|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 246, False: 54] | | | | ------------------ | | ------------------ | | 130| 300| else { \ | | 131| 54| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 54|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 54| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 54|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 54| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 54|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 54| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 54| } \ | | 133| 300| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 300] | | ------------------ ------------------ 5820| 300| 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: 951] ------------------ 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: 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] | | ------------------ ------------------ 5825| 10| break; 5826| 228| case OGS_PFCP_SESSION_MODIFICATION_REQUEST_TYPE: ------------------ | | 86| 228|#define OGS_PFCP_SESSION_MODIFICATION_REQUEST_TYPE 52 ------------------ | Branch (5826:9): [True: 228, False: 733] ------------------ 5827| 228| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_modification_request, 5828| 228| &ogs_pfcp_msg_desc_pfcp_session_modification_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 228|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5829| 228| ogs_expect(rv == OGS_OK); ------------------ | | 128| 228| do { \ | | 129| 228| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 228|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 185, False: 43] | | | | ------------------ | | ------------------ | | 130| 228| else { \ | | 131| 43| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 43|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 43| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 43|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 43| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 43|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 43| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 43| } \ | | 133| 228| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 228] | | ------------------ ------------------ 5830| 228| break; 5831| 6| case OGS_PFCP_SESSION_MODIFICATION_RESPONSE_TYPE: ------------------ | | 87| 6|#define OGS_PFCP_SESSION_MODIFICATION_RESPONSE_TYPE 53 ------------------ | Branch (5831:9): [True: 6, False: 955] ------------------ 5832| 6| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_modification_response, 5833| 6| &ogs_pfcp_msg_desc_pfcp_session_modification_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 6|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5834| 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] | | ------------------ ------------------ 5835| 6| 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: 960] ------------------ 5837| 1| break; 5838| 9| case OGS_PFCP_SESSION_DELETION_RESPONSE_TYPE: ------------------ | | 89| 9|#define OGS_PFCP_SESSION_DELETION_RESPONSE_TYPE 55 ------------------ | Branch (5838:9): [True: 9, False: 952] ------------------ 5839| 9| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_deletion_response, 5840| 9| &ogs_pfcp_msg_desc_pfcp_session_deletion_response, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 9|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5841| 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: 4, False: 5] | | | | ------------------ | | ------------------ | | 130| 9| 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| 9| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 9] | | ------------------ ------------------ 5842| 9| break; 5843| 133| case OGS_PFCP_SESSION_REPORT_REQUEST_TYPE: ------------------ | | 90| 133|#define OGS_PFCP_SESSION_REPORT_REQUEST_TYPE 56 ------------------ | Branch (5843:9): [True: 133, False: 828] ------------------ 5844| 133| rv = ogs_tlv_parse_msg(&pfcp_message->pfcp_session_report_request, 5845| 133| &ogs_pfcp_msg_desc_pfcp_session_report_request, pkbuf, OGS_TLV_MODE_T2_L2); ------------------ | | 35| 133|#define OGS_TLV_MODE_T2_L2 4 ------------------ 5846| 133| ogs_expect(rv == OGS_OK); ------------------ | | 128| 133| do { \ | | 129| 133| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 133|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 122, False: 11] | | | | ------------------ | | ------------------ | | 130| 133| else { \ | | 131| 11| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 57| 11|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | | | ------------------ | | | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 11| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 11| } \ | | 133| 133| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 133] | | ------------------ ------------------ 5847| 133| 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: 953] ------------------ 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| 3| default: ------------------ | Branch (5853:9): [True: 3, False: 958] ------------------ 5854| 3| ogs_warn("Not implemented(type:%d)", pfcp_message->h.type); ------------------ | | 37| 3|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 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__) | | ------------------ ------------------ 5855| 3| break; 5856| 961| } 5857| | 5858| 961| if (rv != OGS_OK) { ------------------ | | 77| 961|#define OGS_OK 0 ------------------ | Branch (5858:9): [True: 242, False: 719] ------------------ 5859| 242| ogs_pfcp_message_free(pfcp_message); 5860| 242| return NULL; 5861| 242| } 5862| | 5863| 719| return pfcp_message; 5864| 961|} ogs_pfcp_message_free: 5867| 973|{ 5868| 973| ogs_assert(pfcp_message); ------------------ | | 113| 973| do { \ | | 114| 973| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 973|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 973, False: 0] | | | | ------------------ | | ------------------ | | 115| 973| 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| 973| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 973] | | ------------------ ------------------ 5869| 973| ogs_free(pfcp_message); ------------------ | | 73| 973|#define ogs_free(ptr) ogs_talloc_free(ptr, __location__) ------------------ 5870| 973|} ogs_pfcp_parse_sdf_filter: 158| 480|{ 159| 480| uint32_t size = 0; 160| | 161| 480| ogs_assert(filter); ------------------ | | 113| 480| do { \ | | 114| 480| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 480|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 480, False: 0] | | | | ------------------ | | ------------------ | | 115| 480| 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| 480| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 480] | | ------------------ ------------------ 162| 480| ogs_assert(octet); ------------------ | | 113| 480| do { \ | | 114| 480| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 480|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 480, False: 0] | | | | ------------------ | | ------------------ | | 115| 480| 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| 480| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 480] | | ------------------ ------------------ 163| | 164| 480| memset(filter, 0, sizeof(ogs_pfcp_sdf_filter_t)); 165| | 166| 480| if (size + sizeof(filter->flags) > octet->len) { ------------------ | Branch (166:9): [True: 0, False: 480] ------------------ 167| 0| ogs_error("size[%d]+sizeof(filter->flags)[%d] > IE Length[%d]", ------------------ | | 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__) | | ------------------ ------------------ 168| 0| size, (int)sizeof(filter->flags), octet->len); 169| 0| return 0; 170| 0| } 171| 480| memcpy(&filter->flags, 172| 480| (unsigned char *)octet->data + size, sizeof(filter->flags)); 173| 480| size++; 174| | 175| 480| if (size + sizeof(filter->spare2) > octet->len) { ------------------ | Branch (175:9): [True: 74, False: 406] ------------------ 176| 74| ogs_error("size[%d]+sizeof(filter->spare2)[%d] > IE Length[%d]", ------------------ | | 36| 74|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 74| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 74|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 74| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 74|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 74| 0, __VA_ARGS__) | | ------------------ ------------------ 177| 74| size, (int)sizeof(filter->spare2), octet->len); 178| 74| return 0; 179| 74| } 180| 406| memcpy(&filter->spare2, 181| 406| (unsigned char *)octet->data + size, sizeof(filter->flags)); 182| 406| size++; 183| | 184| 406| if (filter->fd) { ------------------ | Branch (184:9): [True: 199, False: 207] ------------------ 185| 199| if (size + sizeof(filter->flow_description_len) > octet->len) { ------------------ | Branch (185:13): [True: 35, False: 164] ------------------ 186| 35| ogs_error("size[%d]+sizeof(filter->flow_description_len)[%d] " ------------------ | | 36| 35|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 35| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 35|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 35| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 35|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 35| 0, __VA_ARGS__) | | ------------------ ------------------ 187| 35| "> IE Length[%d]", 188| 35| size, (int)sizeof(filter->flow_description_len), 189| 35| octet->len); 190| 35| return 0; 191| 35| } 192| 164| memcpy(&filter->flow_description_len, 193| 164| (unsigned char *)octet->data + size, 194| 164| sizeof(filter->flow_description_len)); 195| 164| filter->flow_description_len = be16toh(filter->flow_description_len); 196| 164| size += sizeof(filter->flow_description_len); 197| | 198| 164| if (size + filter->flow_description_len > octet->len) { ------------------ | Branch (198:13): [True: 74, False: 90] ------------------ 199| 74| ogs_error("size[%d]+filter->flow_description_len[%d] " ------------------ | | 36| 74|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 74| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 74|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 74| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 74|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 74| 0, __VA_ARGS__) | | ------------------ ------------------ 200| 74| "> IE Length[%d]", 201| 74| size, filter->flow_description_len, octet->len); 202| 74| return 0; 203| 74| } 204| 90| filter->flow_description = (char *)octet->data + size; 205| 90| size += filter->flow_description_len; 206| 90| } 207| | 208| 297| if (filter->ttc) { ------------------ | Branch (208:9): [True: 148, False: 149] ------------------ 209| 148| if (size + sizeof(filter->tos_traffic_class) > octet->len) { ------------------ | Branch (209:13): [True: 35, False: 113] ------------------ 210| 35| ogs_error("size[%d]+sizeof(filter->tos_traffic_class)[%d] " ------------------ | | 36| 35|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 35| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 35|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 35| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 35|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 35| 0, __VA_ARGS__) | | ------------------ ------------------ 211| 35| "> IE Length[%d]", 212| 35| size, (int)sizeof(filter->tos_traffic_class), octet->len); 213| 35| return 0; 214| 35| } 215| 113| memcpy(&filter->tos_traffic_class, 216| 113| (unsigned char *)octet->data + size, 217| 113| sizeof(filter->tos_traffic_class)); 218| 113| filter->tos_traffic_class = be32toh(filter->tos_traffic_class); 219| 113| size += sizeof(filter->tos_traffic_class); 220| 113| } 221| | 222| 262| if (filter->spi) { ------------------ | Branch (222:9): [True: 81, False: 181] ------------------ 223| 81| if (size + sizeof(filter->security_parameter_index) > octet->len) { ------------------ | Branch (223:13): [True: 37, False: 44] ------------------ 224| 37| ogs_error("size[%d]+sizeof(filter->security_parameter_index)[%d] " ------------------ | | 36| 37|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 37| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 37|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 37| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 37|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 37| 0, __VA_ARGS__) | | ------------------ ------------------ 225| 37| "> IE Length[%d]", 226| 37| size, (int)sizeof(filter->security_parameter_index), 227| 37| octet->len); 228| 37| return 0; 229| 37| } 230| 44| memcpy(&filter->security_parameter_index, 231| 44| (unsigned char *)octet->data + size, 232| 44| sizeof(filter->security_parameter_index)); 233| 44| filter->security_parameter_index = 234| 44| be32toh(filter->security_parameter_index); 235| 44| size += sizeof(filter->security_parameter_index); 236| 44| } 237| | 238| 225| if (filter->fl) { ------------------ | Branch (238:9): [True: 91, False: 134] ------------------ 239| 91| int bit24_len = 3; 240| 91| if (size + bit24_len > octet->len) { ------------------ | Branch (240:13): [True: 39, False: 52] ------------------ 241| 39| ogs_error("size[%d]+bit24_len[%d] > IE Length[%d]", ------------------ | | 36| 39|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 39| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 39|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 39| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 39|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 39| 0, __VA_ARGS__) | | ------------------ ------------------ 242| 39| size, bit24_len, octet->len); 243| 39| return 0; 244| 39| } 245| 52| memcpy(&filter->flow_label, 246| 52| (unsigned char *)octet->data + size, bit24_len); 247| 52| filter->flow_label = be32toh(filter->flow_label); 248| 52| size += bit24_len; 249| 52| } 250| | 251| 186| if (filter->bid) { ------------------ | Branch (251:9): [True: 91, False: 95] ------------------ 252| 91| if (size + sizeof(filter->sdf_filter_id) > octet->len) { ------------------ | Branch (252:13): [True: 40, False: 51] ------------------ 253| 40| ogs_error("size[%d]+sizeof(filter->sdf_filter_id)[%d]" ------------------ | | 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__) | | ------------------ ------------------ 254| 40| "> IE Length[%d]", 255| 40| size, (int)sizeof(filter->sdf_filter_id), octet->len); 256| 40| return 0; 257| 40| } 258| 51| memcpy(&filter->sdf_filter_id, (unsigned char *)octet->data + size, 259| 51| sizeof(filter->sdf_filter_id)); 260| 51| filter->sdf_filter_id = be32toh(filter->sdf_filter_id); 261| 51| size += sizeof(filter->sdf_filter_id); 262| 51| } 263| | 264| 146| if (size != octet->len) ------------------ | Branch (264:9): [True: 94, False: 52] ------------------ 265| 146| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", octet->len, size); ------------------ | | 36| 94|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 94| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 94|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 94| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 94|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 94| 0, __VA_ARGS__) | | ------------------ ------------------ 266| | 267| 146| return size; 268| 186|} ogs_pfcp_parse_bitrate: 310| 45|{ 311| 45| int16_t size = 0; 312| | 313| 45| ogs_assert(bitrate); ------------------ | | 113| 45| do { \ | | 114| 45| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 45|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 45, False: 0] | | | | ------------------ | | ------------------ | | 115| 45| 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| 45| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 45] | | ------------------ ------------------ 314| 45| ogs_assert(octet); ------------------ | | 113| 45| do { \ | | 114| 45| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 45|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 45, False: 0] | | | | ------------------ | | ------------------ | | 115| 45| 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| 45| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 45] | | ------------------ ------------------ 315| 45| if (octet->len != OGS_PFCP_BITRATE_LEN) { ------------------ | | 919| 45|#define OGS_PFCP_BITRATE_LEN 10 ------------------ | Branch (315:9): [True: 27, False: 18] ------------------ 316| 27| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", ------------------ | | 36| 27|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 27| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 27|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 27| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 27|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 27| 0, __VA_ARGS__) | | ------------------ ------------------ 317| 27| OGS_PFCP_BITRATE_LEN, octet->len); 318| 27| return 0; 319| 27| } 320| | 321| 18| memset(bitrate, 0, sizeof(ogs_pfcp_bitrate_t)); 322| | 323| | /* 324| | * Ch 8.15 Bearer QoS in TS 29.274 v15.9.0 325| | * 326| | * The UL/DL MBR and GBR fields are encoded as kilobits 327| | * per second (1 kbps = 1000 bps) in binary value. 328| | */ 329| 18| bitrate->uplink = ogs_buffer_to_uint64( 330| 18| (unsigned char *)octet->data + size, 5) * 1000; 331| 18| size += 5; 332| 18| bitrate->downlink = ogs_buffer_to_uint64( 333| 18| (unsigned char *)octet->data + size, 5) * 1000; 334| 18| size += 5; 335| | 336| 18| ogs_assert(size == octet->len); ------------------ | | 113| 18| do { \ | | 114| 18| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 18|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 18, False: 0] | | | | ------------------ | | ------------------ | | 115| 18| 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| 18| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 18] | | ------------------ ------------------ 337| | 338| 18| return size; 339| 18|} ogs_pfcp_parse_volume: 395| 446|{ 396| 446| int16_t size = 0; 397| | 398| 446| ogs_assert(volume); ------------------ | | 113| 446| do { \ | | 114| 446| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 446|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 446, False: 0] | | | | ------------------ | | ------------------ | | 115| 446| 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| 446| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 446] | | ------------------ ------------------ 399| 446| ogs_assert(octet); ------------------ | | 113| 446| do { \ | | 114| 446| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 446|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 446, False: 0] | | | | ------------------ | | ------------------ | | 115| 446| 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| 446| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 446] | | ------------------ ------------------ 400| | 401| 446| memset(volume, 0, sizeof(ogs_pfcp_volume_threshold_t)); 402| | 403| 446| if (size + sizeof(volume->flags) > octet->len) { ------------------ | Branch (403:9): [True: 0, False: 446] ------------------ 404| 0| ogs_error("size[%d]+sizeof(volume->flags)[%d] > IE Length[%d]", ------------------ | | 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__) | | ------------------ ------------------ 405| 0| size, (int)sizeof(volume->flags), octet->len); 406| 0| return 0; 407| 0| } 408| 446| volume->flags = ((unsigned char *)octet->data)[size]; 409| 446| size += sizeof(volume->flags); 410| | 411| 446| if (volume->tovol) { ------------------ | Branch (411:9): [True: 109, False: 337] ------------------ 412| 109| if (size + sizeof(volume->total_volume) > octet->len) { ------------------ | Branch (412:13): [True: 42, False: 67] ------------------ 413| 42| ogs_error("size[%d]+sizeof(volume->total_volume)[%d] " ------------------ | | 36| 42|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 42| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 42|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 42| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 42|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 42| 0, __VA_ARGS__) | | ------------------ ------------------ 414| 42| "> IE Length[%d]", 415| 42| size, (int)sizeof(volume->total_volume), octet->len); 416| 42| return 0; 417| 42| } 418| 67| memcpy(&volume->total_volume, (unsigned char *)octet->data + size, 419| 67| sizeof(volume->total_volume)); 420| 67| volume->total_volume = be64toh(volume->total_volume); 421| 67| size += sizeof(volume->total_volume); 422| 67| } 423| 404| if (volume->ulvol) { ------------------ | Branch (423:9): [True: 129, False: 275] ------------------ 424| 129| if (size + sizeof(volume->uplink_volume) > octet->len) { ------------------ | Branch (424:13): [True: 59, False: 70] ------------------ 425| 59| ogs_error("size[%d]+sizeof(volume->uplink_volume)[%d] " ------------------ | | 36| 59|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 59| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 59|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 59| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 59|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 59| 0, __VA_ARGS__) | | ------------------ ------------------ 426| 59| "> IE Length[%d]", 427| 59| size, (int)sizeof(volume->uplink_volume), octet->len); 428| 59| return 0; 429| 59| } 430| 70| memcpy(&volume->uplink_volume, (unsigned char *)octet->data + size, 431| 70| sizeof(volume->uplink_volume)); 432| 70| volume->uplink_volume = be64toh(volume->uplink_volume); 433| 70| size += sizeof(volume->uplink_volume); 434| 70| } 435| 345| if (volume->dlvol) { ------------------ | Branch (435:9): [True: 125, False: 220] ------------------ 436| 125| if (size + sizeof(volume->downlink_volume) > octet->len) { ------------------ | Branch (436:13): [True: 53, False: 72] ------------------ 437| 53| ogs_error("size[%d]+sizeof(volume->downlink_volume)[%d] " ------------------ | | 36| 53|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 53| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 53|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 53| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 53|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 53| 0, __VA_ARGS__) | | ------------------ ------------------ 438| 53| "> IE Length[%d]", 439| 53| size, (int)sizeof(volume->downlink_volume), octet->len); 440| 53| return 0; 441| 53| } 442| 72| memcpy(&volume->downlink_volume, (unsigned char *)octet->data + size, 443| 72| sizeof(volume->downlink_volume)); 444| 72| volume->downlink_volume = be64toh(volume->downlink_volume); 445| 72| size += sizeof(volume->downlink_volume); 446| 72| } 447| | 448| 292| if (size != octet->len) ------------------ | Branch (448:9): [True: 252, False: 40] ------------------ 449| 292| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", octet->len, size); ------------------ | | 36| 252|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 252| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 252|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 252| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 252|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 252| 0, __VA_ARGS__) | | ------------------ ------------------ 450| | 451| 292| return size; 452| 345|} ogs_pfcp_parse_dropped_dl_traffic_threshold: 498| 271|{ 499| 271| int16_t size = 0; 500| | 501| 271| ogs_assert(threshold); ------------------ | | 113| 271| do { \ | | 114| 271| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 271|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 271, False: 0] | | | | ------------------ | | ------------------ | | 115| 271| 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| 271| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 271] | | ------------------ ------------------ 502| 271| ogs_assert(octet); ------------------ | | 113| 271| do { \ | | 114| 271| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 271|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 271, False: 0] | | | | ------------------ | | ------------------ | | 115| 271| 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| 271| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 271] | | ------------------ ------------------ 503| | 504| 271| memset(threshold, 0, sizeof(ogs_pfcp_dropped_dl_traffic_threshold_t)); 505| | 506| 271| if (size + sizeof(threshold->flags) > octet->len) { ------------------ | Branch (506:9): [True: 0, False: 271] ------------------ 507| 0| ogs_error("size[%d]+sizeof(threshold->flags)[%d] > IE Length[%d]", ------------------ | | 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__) | | ------------------ ------------------ 508| 0| size, (int)sizeof(threshold->flags), octet->len); 509| 0| return 0; 510| 0| } 511| 271| threshold->flags = ((unsigned char *)octet->data)[size]; 512| 271| size += sizeof(threshold->flags); 513| | 514| 271| if (threshold->dlpa) { ------------------ | Branch (514:9): [True: 106, False: 165] ------------------ 515| 106| if (size + sizeof(threshold->downlink_packets) > octet->len) { ------------------ | Branch (515:13): [True: 39, False: 67] ------------------ 516| 39| ogs_error("size[%d]+sizeof(threshold->downlink_packets)[%d] " ------------------ | | 36| 39|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 39| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 39|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 39| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 39|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 39| 0, __VA_ARGS__) | | ------------------ ------------------ 517| 39| "> IE Length[%d]", 518| 39| size, (int)sizeof(threshold->downlink_packets), 519| 39| octet->len); 520| 39| return 0; 521| 39| } 522| 67| memcpy(&threshold->downlink_packets, 523| 67| (unsigned char *)octet->data + size, 524| 67| sizeof(threshold->downlink_packets)); 525| 67| threshold->downlink_packets = be64toh(threshold->downlink_packets); 526| 67| size += sizeof(threshold->downlink_packets); 527| 67| } 528| 232| if (threshold->dlby) { ------------------ | Branch (528:9): [True: 135, False: 97] ------------------ 529| 135| if (size + sizeof(threshold->number_of_bytes_of_downlink_data) > ------------------ | Branch (529:13): [True: 73, False: 62] ------------------ 530| 135| octet->len) { 531| 73| ogs_error("size[%d]+" ------------------ | | 36| 73|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 73| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 73|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 73| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 73|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 73| 0, __VA_ARGS__) | | ------------------ ------------------ 532| 73| "sizeof(threshold->number_of_bytes_of_downlink_data)[%d] " 533| 73| "> IE Length[%d]", 534| 73| size, 535| 73| (int)sizeof(threshold->number_of_bytes_of_downlink_data), 536| 73| octet->len); 537| 73| return 0; 538| 73| } 539| 62| memcpy(&threshold->number_of_bytes_of_downlink_data, 540| 62| (unsigned char *)octet->data + size, 541| 62| sizeof(threshold->number_of_bytes_of_downlink_data)); 542| 62| threshold->number_of_bytes_of_downlink_data = 543| 62| be64toh(threshold->number_of_bytes_of_downlink_data); 544| 62| size += sizeof(threshold->number_of_bytes_of_downlink_data); 545| 62| } 546| | 547| 159| if (size != octet->len) ------------------ | Branch (547:9): [True: 99, False: 60] ------------------ 548| 159| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", octet->len, size); ------------------ | | 36| 99|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 99| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 99|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 99| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 99|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 99| 0, __VA_ARGS__) | | ------------------ ------------------ 549| | 550| 159| return size; 551| 232|} ogs_pfcp_parse_volume_measurement: 616| 288|{ 617| 288| int16_t size = 0; 618| | 619| 288| ogs_assert(volume); ------------------ | | 113| 288| do { \ | | 114| 288| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 288|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 288, False: 0] | | | | ------------------ | | ------------------ | | 115| 288| 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| 288| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 288] | | ------------------ ------------------ 620| 288| ogs_assert(octet); ------------------ | | 113| 288| do { \ | | 114| 288| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 288|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 288, False: 0] | | | | ------------------ | | ------------------ | | 115| 288| 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| 288| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 288] | | ------------------ ------------------ 621| | 622| 288| memset(volume, 0, sizeof(ogs_pfcp_volume_measurement_t)); 623| | 624| 288| if (size + sizeof(volume->flags) > octet->len) { ------------------ | Branch (624:9): [True: 0, False: 288] ------------------ 625| 0| ogs_error("size[%d]+sizeof(volume->flags)[%d] > IE Length[%d]", ------------------ | | 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__) | | ------------------ ------------------ 626| 0| size, (int)sizeof(volume->flags), octet->len); 627| 0| return 0; 628| 0| } 629| 288| volume->flags = ((unsigned char *)octet->data)[size]; 630| 288| size += sizeof(volume->flags); 631| | 632| 288| if (volume->tovol) { ------------------ | Branch (632:9): [True: 65, False: 223] ------------------ 633| 65| if (size + sizeof(volume->total_volume) > octet->len) { ------------------ | Branch (633:13): [True: 21, False: 44] ------------------ 634| 21| ogs_error("size[%d]+sizeof(volume->total_volume)[%d] " ------------------ | | 36| 21|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 21| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 21|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 21| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 21|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 21| 0, __VA_ARGS__) | | ------------------ ------------------ 635| 21| "> IE Length[%d]", 636| 21| size, (int)sizeof(volume->total_volume), octet->len); 637| 21| return 0; 638| 21| } 639| 44| memcpy(&volume->total_volume, (unsigned char *)octet->data + size, 640| 44| sizeof(volume->total_volume)); 641| 44| volume->total_volume = be64toh(volume->total_volume); 642| 44| size += sizeof(volume->total_volume); 643| 44| } 644| 267| if (volume->ulvol) { ------------------ | Branch (644:9): [True: 67, False: 200] ------------------ 645| 67| if (size + sizeof(volume->uplink_volume) > octet->len) { ------------------ | Branch (645:13): [True: 24, False: 43] ------------------ 646| 24| ogs_error("size[%d]+sizeof(volume->uplink_volume)[%d] " ------------------ | | 36| 24|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 24| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 24|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 24| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 24|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 24| 0, __VA_ARGS__) | | ------------------ ------------------ 647| 24| "> IE Length[%d]", 648| 24| size, (int)sizeof(volume->uplink_volume), octet->len); 649| 24| return 0; 650| 24| } 651| 43| memcpy(&volume->uplink_volume, (unsigned char *)octet->data + size, 652| 43| sizeof(volume->uplink_volume)); 653| 43| volume->uplink_volume = be64toh(volume->uplink_volume); 654| 43| size += sizeof(volume->uplink_volume); 655| 43| } 656| 243| if (volume->dlvol) { ------------------ | Branch (656:9): [True: 84, False: 159] ------------------ 657| 84| if (size + sizeof(volume->downlink_volume) > octet->len) { ------------------ | Branch (657:13): [True: 40, False: 44] ------------------ 658| 40| ogs_error("size[%d]+sizeof(volume->downlink_volume)[%d] " ------------------ | | 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__) | | ------------------ ------------------ 659| 40| "> IE Length[%d]", 660| 40| size, (int)sizeof(volume->downlink_volume), octet->len); 661| 40| return 0; 662| 40| } 663| 44| memcpy(&volume->downlink_volume, (unsigned char *)octet->data + size, 664| 44| sizeof(volume->downlink_volume)); 665| 44| volume->downlink_volume = be64toh(volume->downlink_volume); 666| 44| size += sizeof(volume->downlink_volume); 667| 44| } 668| 203| if (volume->tonop) { ------------------ | Branch (668:9): [True: 86, False: 117] ------------------ 669| 86| if (size + sizeof(volume->total_n_packets) > octet->len) { ------------------ | Branch (669:13): [True: 46, False: 40] ------------------ 670| 46| ogs_error("size[%d]+sizeof(volume->total_n_packets)[%d] " ------------------ | | 36| 46|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 46| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 46|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 46| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 46|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 46| 0, __VA_ARGS__) | | ------------------ ------------------ 671| 46| "> IE Length[%d]", 672| 46| size, (int)sizeof(volume->total_n_packets), octet->len); 673| 46| return 0; 674| 46| } 675| 40| memcpy(&volume->total_n_packets, (unsigned char *)octet->data + size, 676| 40| sizeof(volume->total_n_packets)); 677| 40| volume->total_n_packets = be64toh(volume->total_n_packets); 678| 40| size += sizeof(volume->total_n_packets); 679| 40| } 680| 157| if (volume->ulnop) { ------------------ | Branch (680:9): [True: 86, False: 71] ------------------ 681| 86| if (size + sizeof(volume->uplink_n_packets) > octet->len) { ------------------ | Branch (681:13): [True: 48, False: 38] ------------------ 682| 48| ogs_error("size[%d]+sizeof(volume->uplink_n_packets)[%d] " ------------------ | | 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__) | | ------------------ ------------------ 683| 48| "> IE Length[%d]", 684| 48| size, (int)sizeof(volume->uplink_n_packets), octet->len); 685| 48| return 0; 686| 48| } 687| 38| memcpy(&volume->uplink_n_packets, (unsigned char *)octet->data + size, 688| 38| sizeof(volume->uplink_n_packets)); 689| 38| volume->uplink_n_packets = be64toh(volume->uplink_n_packets); 690| 38| size += sizeof(volume->uplink_n_packets); 691| 38| } 692| 109| if (volume->dlnop) { ------------------ | Branch (692:9): [True: 62, False: 47] ------------------ 693| 62| if (size + sizeof(volume->downlink_n_packets) > octet->len) { ------------------ | Branch (693:13): [True: 24, False: 38] ------------------ 694| 24| ogs_error("size[%d]+sizeof(volume->downlink_n_packets)[%d] " ------------------ | | 36| 24|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 24| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 24|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 24| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 24|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 24| 0, __VA_ARGS__) | | ------------------ ------------------ 695| 24| "> IE Length[%d]", 696| 24| size, (int)sizeof(volume->downlink_n_packets), octet->len); 697| 24| return 0; 698| 24| } 699| 38| memcpy(&volume->downlink_n_packets, (unsigned char *)octet->data + size, 700| 38| sizeof(volume->downlink_n_packets)); 701| 38| volume->downlink_n_packets = be64toh(volume->downlink_n_packets); 702| 38| size += sizeof(volume->downlink_n_packets); 703| 38| } 704| | 705| 85| if (size != octet->len) ------------------ | Branch (705:9): [True: 66, False: 19] ------------------ 706| 85| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", octet->len, size); ------------------ | | 36| 66|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 66| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 57| 66|#define OGS_LOG_DOMAIN __ogs_pfcp_domain | | | | ------------------ | | | | 44| 66| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 66|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 66| 0, __VA_ARGS__) | | ------------------ ------------------ 707| | 708| 85| return size; 709| 109|} 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: 148| 999|{ 149| | 150| 999| if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 26| 1.99k|#define kMinInputLength 5 ------------------ if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 27| 995|#define kMaxInputLength 2048 ------------------ | Branch (150:9): [True: 4, False: 995] | Branch (150:35): [True: 22, False: 973] ------------------ 151| 26| return 1; 152| 26| } 153| | 154| 973| if (!initialized) { ------------------ | Branch (154:9): [True: 1, False: 972] ------------------ 155| 1| initialize(); 156| 1| ogs_log_install_domain(&__ogs_pfcp_domain, "pfcp", OGS_LOG_NONE); 157| 1| ogs_log_install_domain(&__ogs_tlv_domain, "tlv", OGS_LOG_NONE); 158| 1| } 159| | 160| 973| ogs_pkbuf_t *pkbuf; 161| 973| pkbuf = ogs_pkbuf_alloc(NULL, OGS_MAX_SDU_LEN); ------------------ | | 87| 973| ogs_pkbuf_alloc_debug(pool, size, OGS_FILE_LINE) | | ------------------ | | | | 213| 973|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 167| 973|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 168| 973|#define OGS_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 162| 973| if (pkbuf == NULL) { ------------------ | Branch (162:9): [True: 0, False: 973] ------------------ 163| 0| return 1; 164| 0| } 165| 973| ogs_pkbuf_put_data(pkbuf, Data, Size); 166| | 167| 973| ogs_pfcp_message_t *message = ogs_pfcp_parse_msg(pkbuf); 168| 973| if (message) { ------------------ | Branch (168:9): [True: 724, False: 249] ------------------ 169| 724| parse_pfcp_ies(message); 170| 724| ogs_pfcp_message_free(message); 171| 724| } 172| | 173| 973| ogs_pkbuf_free(pkbuf); 174| | 175| 973| return 0; 176| 973|} pfcp-message-fuzz.c:parse_pfcp_ies: 90| 724|{ 91| 724| ogs_pfcp_tlv_create_pdr_t *pdr = NULL; 92| 724| ogs_pfcp_tlv_create_qer_t *qer = NULL; 93| 724| ogs_pfcp_tlv_create_urr_t *urr = NULL; 94| 724| size_t pdr_count = 0, qer_count = 0, urr_count = 0; 95| 724| size_t index; 96| | 97| 724| switch (message->h.type) { 98| 247| case OGS_PFCP_SESSION_ESTABLISHMENT_REQUEST_TYPE: { ------------------ | | 84| 247|#define OGS_PFCP_SESSION_ESTABLISHMENT_REQUEST_TYPE 50 ------------------ | Branch (98:5): [True: 247, False: 477] ------------------ 99| 247| ogs_pfcp_session_establishment_request_t *request = 100| 247| &message->pfcp_session_establishment_request; 101| 247| pdr = request->create_pdr; 102| 247| pdr_count = OGS_ARRAY_SIZE(request->create_pdr); ------------------ | | 165| 247|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 103| 247| qer = request->create_qer; 104| 247| qer_count = OGS_ARRAY_SIZE(request->create_qer); ------------------ | | 165| 247|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 105| 247| urr = request->create_urr; 106| 247| urr_count = OGS_ARRAY_SIZE(request->create_urr); ------------------ | | 165| 247|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 107| 247| break; 108| 0| } 109| 186| case OGS_PFCP_SESSION_MODIFICATION_REQUEST_TYPE: { ------------------ | | 86| 186|#define OGS_PFCP_SESSION_MODIFICATION_REQUEST_TYPE 52 ------------------ | Branch (109:5): [True: 186, False: 538] ------------------ 110| 186| ogs_pfcp_session_modification_request_t *request = 111| 186| &message->pfcp_session_modification_request; 112| 186| pdr = request->create_pdr; 113| 186| pdr_count = OGS_ARRAY_SIZE(request->create_pdr); ------------------ | | 165| 186|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 114| 186| qer = request->create_qer; 115| 186| qer_count = OGS_ARRAY_SIZE(request->create_qer); ------------------ | | 165| 186|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 116| 186| urr = request->create_urr; 117| 186| urr_count = OGS_ARRAY_SIZE(request->create_urr); ------------------ | | 165| 186|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 118| 186| break; 119| 0| } 120| 123| case OGS_PFCP_SESSION_REPORT_REQUEST_TYPE: { ------------------ | | 90| 123|#define OGS_PFCP_SESSION_REPORT_REQUEST_TYPE 56 ------------------ | Branch (120:5): [True: 123, False: 601] ------------------ 121| 123| ogs_pfcp_session_report_request_t *request = 122| 123| &message->pfcp_session_report_request; 123| 1.10k| for (index = 0; index < OGS_ARRAY_SIZE(request->usage_report); index++) { ------------------ | | 165| 1.10k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ | Branch (123:25): [True: 984, False: 123] ------------------ 124| 984| ogs_pfcp_tlv_usage_report_session_report_request_t *report = 125| 984| &request->usage_report[index]; 126| 984| ogs_tlv_octet_t *volume = &report->volume_measurement; 127| 984| if (report->presence && volume->presence && volume->len && ------------------ | Branch (127:17): [True: 340, False: 644] | Branch (127:37): [True: 306, False: 34] | Branch (127:57): [True: 288, False: 18] ------------------ 128| 288| volume->data) { ------------------ | Branch (128:21): [True: 288, False: 0] ------------------ 129| 288| ogs_pfcp_volume_measurement_t decoded; 130| 288| ogs_pfcp_parse_volume_measurement(&decoded, volume); 131| 288| } 132| 984| } 133| 123| break; 134| 0| } 135| 168| default: ------------------ | Branch (135:5): [True: 168, False: 556] ------------------ 136| 168| break; 137| 724| } 138| | 139| 7.65k| for (index = 0; index < pdr_count; index++) ------------------ | Branch (139:21): [True: 6.92k, False: 724] ------------------ 140| 6.92k| parse_pdr_ies(&pdr[index]); 141| 2.45k| for (index = 0; index < qer_count; index++) ------------------ | Branch (141:21): [True: 1.73k, False: 724] ------------------ 142| 1.73k| parse_qer_ies(&qer[index]); 143| 7.65k| for (index = 0; index < urr_count; index++) ------------------ | Branch (143:21): [True: 6.92k, False: 724] ------------------ 144| 6.92k| parse_urr_ies(&urr[index]); 145| 724|} pfcp-message-fuzz.c:parse_pdr_ies: 30| 6.92k|{ 31| 6.92k| size_t index; 32| | 33| 6.92k| if (!pdr->presence || !pdr->pdi.presence) ------------------ | Branch (33:9): [True: 6.32k, False: 606] | Branch (33:27): [True: 109, False: 497] ------------------ 34| 6.43k| return; 35| | 36| 4.47k| for (index = 0; index < OGS_ARRAY_SIZE(pdr->pdi.sdf_filter); index++) { ------------------ | | 165| 4.47k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ | Branch (36:21): [True: 3.97k, False: 497] ------------------ 37| 3.97k| ogs_tlv_octet_t *filter = &pdr->pdi.sdf_filter[index]; 38| 3.97k| if (filter->presence && filter->len && filter->data) { ------------------ | Branch (38:13): [True: 572, False: 3.40k] | Branch (38:33): [True: 480, False: 92] | Branch (38:48): [True: 480, False: 0] ------------------ 39| 480| ogs_pfcp_sdf_filter_t decoded; 40| 480| ogs_pfcp_parse_sdf_filter(&decoded, filter); 41| 480| } 42| 3.97k| } 43| 497|} pfcp-message-fuzz.c:parse_qer_ies: 46| 1.73k|{ 47| 1.73k| ogs_tlv_octet_t *rates[] = { 48| 1.73k| &qer->maximum_bitrate, &qer->guaranteed_bitrate 49| 1.73k| }; 50| 1.73k| size_t index; 51| | 52| 1.73k| if (!qer->presence) ------------------ | Branch (52:9): [True: 1.63k, False: 99] ------------------ 53| 1.63k| return; 54| | 55| 297| for (index = 0; index < OGS_ARRAY_SIZE(rates); index++) { ------------------ | | 165| 297|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ | Branch (55:21): [True: 198, False: 99] ------------------ 56| 198| ogs_tlv_octet_t *rate = rates[index]; 57| 198| if (rate->presence && rate->len && rate->data) { ------------------ | Branch (57:13): [True: 66, False: 132] | Branch (57:31): [True: 45, False: 21] | Branch (57:44): [True: 45, False: 0] ------------------ 58| 45| ogs_pfcp_bitrate_t decoded; 59| 45| ogs_pfcp_parse_bitrate(&decoded, rate); 60| 45| } 61| 198| } 62| 99|} pfcp-message-fuzz.c:parse_urr_ies: 65| 6.92k|{ 66| 6.92k| ogs_tlv_octet_t *volumes[] = { 67| 6.92k| &urr->volume_threshold, &urr->volume_quota, 68| 6.92k| &urr->subsequent_volume_threshold, &urr->subsequent_volume_quota 69| 6.92k| }; 70| 6.92k| ogs_tlv_octet_t *dropped = &urr->dropped_dl_traffic_threshold; 71| 6.92k| size_t index; 72| | 73| 6.92k| if (!urr->presence) ------------------ | Branch (73:9): [True: 5.97k, False: 949] ------------------ 74| 5.97k| return; 75| | 76| 4.74k| for (index = 0; index < OGS_ARRAY_SIZE(volumes); index++) { ------------------ | | 165| 4.74k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ | Branch (76:21): [True: 3.79k, False: 949] ------------------ 77| 3.79k| ogs_tlv_octet_t *volume = volumes[index]; 78| 3.79k| if (volume->presence && volume->len && volume->data) { ------------------ | Branch (78:13): [True: 515, False: 3.28k] | Branch (78:33): [True: 446, False: 69] | Branch (78:48): [True: 446, False: 0] ------------------ 79| 446| ogs_pfcp_volume_threshold_t decoded; 80| 446| ogs_pfcp_parse_volume(&decoded, volume); 81| 446| } 82| 3.79k| } 83| 949| if (dropped->presence && dropped->len && dropped->data) { ------------------ | Branch (83:9): [True: 305, False: 644] | Branch (83:30): [True: 271, False: 34] | Branch (83:46): [True: 271, False: 0] ------------------ 84| 271| ogs_pfcp_dropped_dl_traffic_threshold_t decoded; 85| 271| ogs_pfcp_parse_dropped_dl_traffic_threshold(&decoded, dropped); 86| 271| } 87| 949|}