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| 9.30k|{ 52| 9.30k| return list->next; 53| 9.30k|} ogs-log.c:ogs_list_next: 61| 8.12k|{ 62| 8.12k| ogs_list_t *node = (ogs_list_t *)lnode; 63| 8.12k| return node->next; 64| 8.12k|} 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| 9.29k|{ 405| 9.29k| ogs_log_t *log = NULL; 406| 9.29k| ogs_log_domain_t *domain = NULL; 407| | 408| 9.29k| char logstr[OGS_HUGE_LEN]; 409| 9.29k| char *p, *last; 410| | 411| 9.29k| int wrote_stderr = 0; 412| | 413| 9.29k| ogs_list_for_each(&log_list, log) { ------------------ | | 76| 17.3k| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 9.29k, False: 8.09k] | | ------------------ | | 77| 9.29k| node = ogs_list_next(node)) ------------------ 414| 9.29k| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 9.29k| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 9.29k, False: 0] | | | Branch (154:20): [True: 9.29k, False: 0] | | ------------------ ------------------ 415| 9.29k| if (!domain) { ------------------ | Branch (415:13): [True: 0, False: 9.29k] ------------------ 416| 0| fprintf(stderr, "No LogDomain[id:%d] in %s:%d", id, file, line); 417| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 418| 0| } 419| 9.29k| if (domain->level < level) ------------------ | Branch (419:13): [True: 1.19k, False: 8.09k] ------------------ 420| 1.19k| return; 421| | 422| 8.09k| p = logstr; 423| 8.09k| last = logstr + OGS_HUGE_LEN; ------------------ | | 210| 8.09k|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 424| | 425| 8.09k| if (!content_only) { ------------------ | Branch (425:13): [True: 7.79k, False: 308] ------------------ 426| 7.79k| if (log->print.timestamp) ------------------ | Branch (426:17): [True: 7.79k, False: 0] ------------------ 427| 7.79k| p = log_timestamp(p, last, log->print.color); 428| 7.79k| if (log->print.domain) ------------------ | Branch (428:17): [True: 7.79k, False: 0] ------------------ 429| 7.79k| p = log_domain(p, last, domain->name, log->print.color); 430| 7.79k| if (log->print.level) ------------------ | Branch (430:17): [True: 7.79k, False: 0] ------------------ 431| 7.79k| p = log_level(p, last, level, log->print.color); 432| 7.79k| } 433| | 434| 8.09k| p = log_content(p, last, format, ap); 435| | 436| 8.09k| if (err) { ------------------ | Branch (436:13): [True: 0, False: 8.09k] ------------------ 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.09k| if (!content_only) { ------------------ | Branch (442:13): [True: 7.79k, False: 308] ------------------ 443| 7.79k| if (log->print.fileline) ------------------ | Branch (443:17): [True: 7.79k, False: 0] ------------------ 444| 7.79k| p = ogs_slprintf(p, last, " (%s:%d)", file, line); 445| 7.79k| if (log->print.function) ------------------ | Branch (445:17): [True: 0, False: 7.79k] ------------------ 446| 0| p = ogs_slprintf(p, last, " %s()", func); 447| 7.79k| if (log->print.linefeed) ------------------ | Branch (447:17): [True: 7.79k, False: 0] ------------------ 448| 7.79k| p = log_linefeed(p, last); 449| 7.79k| } 450| | 451| 8.09k| log->writer(log, level, logstr); 452| | 453| 8.09k| if (log->type == OGS_LOG_STDERR_TYPE) ------------------ | Branch (453:13): [True: 8.09k, False: 0] ------------------ 454| 8.09k| wrote_stderr = 1; 455| 8.09k| } 456| | 457| 8.09k| if (!wrote_stderr) ------------------ | Branch (457:9): [True: 0, False: 8.09k] ------------------ 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.09k|} ogs_log_printf: 486| 9.29k|{ 487| 9.29k| va_list args; 488| | 489| 9.29k| va_start(args, format); 490| 9.29k| ogs_log_vprintf(level, id, 491| 9.29k| err, file, line, func, content_only, format, args); 492| | va_end(args); 493| 9.29k|} ogs_log_hexdump_func: 497| 324|{ 498| 324| size_t n, m; 499| 324| char dumpstr[OGS_HUGE_LEN]; 500| 324| 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| 324| if (!len) ------------------ | Branch (506:9): [True: 16, False: 308] ------------------ 507| 16| return; 508| | 509| 308| last = dumpstr + OGS_HUGE_LEN; ------------------ | | 210| 308|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 510| 308| p = dumpstr; 511| | 512| 2.62k| for (n = 0; n < len; n += 16) { ------------------ | Branch (512:17): [True: 2.31k, False: 308] ------------------ 513| 2.31k| p = ogs_slprintf(p, last, "%04x: ", (int)n); 514| | 515| 39.3k| for (m = n; m < n + 16; m++) { ------------------ | Branch (515:21): [True: 37.0k, False: 2.31k] ------------------ 516| 37.0k| if (m > n && (m % 4) == 0) ------------------ | Branch (516:17): [True: 34.7k, False: 2.31k] | Branch (516:26): [True: 6.95k, False: 27.8k] ------------------ 517| 6.95k| p = ogs_slprintf(p, last, " "); 518| 37.0k| if (m < len) ------------------ | Branch (518:17): [True: 34.1k, False: 2.93k] ------------------ 519| 34.1k| p = ogs_slprintf(p, last, "%02x", data[m]); 520| 2.93k| else 521| 2.93k| p = ogs_slprintf(p, last, " "); 522| 37.0k| } 523| | 524| 2.31k| p = ogs_slprintf(p, last, " "); 525| | 526| 36.4k| for (m = n; m < len && m < n + 16; m++) ------------------ | Branch (526:21): [True: 36.1k, False: 308] | Branch (526:32): [True: 34.1k, False: 2.00k] ------------------ 527| 34.1k| p = ogs_slprintf(p, last, "%c", isprint(data[m]) ? data[m] : '.'); ------------------ | Branch (527:45): [True: 4.25k, False: 29.8k] ------------------ 528| | 529| 2.31k| p = ogs_slprintf(p, last, "\n"); 530| 2.31k| } 531| | 532| | ogs_log_print(level, "%s", dumpstr); ------------------ | | 48| 308| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | ------------------ | | | | 32| 308|#define OGS_LOG_DOMAIN 1 | | ------------------ | | 49| 308| 0, NULL, 0, NULL, \ | | 50| 308| 1, __VA_ARGS__) ------------------ 533| 308|} ogs-log.c:add_log: 536| 1|{ 537| 1| ogs_log_t *log = NULL; 538| | 539| 1| ogs_pool_alloc(&log_pool, &log); ------------------ | | 132| 1|#define ogs_pool_alloc(pool, node) do { \ | | 133| 1| *(node) = NULL; \ | | 134| 1| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 1, False: 0] | | ------------------ | | 135| 1| (pool)->avail--; \ | | 136| 1| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 1| (pool)->free[(pool)->head] = NULL; \ | | 138| 1| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 1| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 1|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 1| } \ | | 141| 1|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 1] | | ------------------ ------------------ 540| 1| ogs_assert(log); ------------------ | | 113| 1| do { \ | | 114| 1| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | 115| 1| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 1| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1] | | ------------------ ------------------ 541| 1| memset(log, 0, sizeof *log); 542| | 543| 1| log->type = type; 544| | 545| 1| log->print.timestamp = 1; 546| 1| log->print.domain = 1; 547| 1| log->print.level = 1; 548| 1| log->print.fileline = 1; 549| 1| log->print.linefeed = 1; 550| | 551| 1| ogs_list_add(&log_list, log); 552| | 553| 1| return log; 554| 1|} ogs-log.c:log_timestamp: 571| 7.79k|{ 572| 7.79k| struct timeval tv; 573| 7.79k| struct tm tm; 574| 7.79k| char nowstr[32]; 575| | 576| 7.79k| ogs_gettimeofday(&tv); 577| 7.79k| ogs_localtime(tv.tv_sec, &tm); 578| 7.79k| strftime(nowstr, sizeof nowstr, "%m/%d %H:%M:%S", &tm); 579| | 580| 7.79k| buf = ogs_slprintf(buf, last, "%s%s.%03d%s: ", 581| 7.79k| use_color ? TA_FGC_GREEN : "", ------------------ | | 37| 7.79k|#define TA_FGC_GREEN "\033[32m" /* Green */ ------------------ | Branch (581:13): [True: 7.79k, False: 0] ------------------ 582| 7.79k| nowstr, (int)(tv.tv_usec/1000), 583| 7.79k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.79k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (583:13): [True: 7.79k, False: 0] ------------------ 584| | 585| 7.79k| return buf; 586| 7.79k|} ogs-log.c:log_domain: 590| 7.79k|{ 591| 7.79k| buf = ogs_slprintf(buf, last, "[%s%s%s] ", 592| 7.79k| use_color ? TA_FGC_YELLOW : "", ------------------ | | 39| 7.79k|#define TA_FGC_YELLOW "\033[33m" /* Yellow */ ------------------ | Branch (592:13): [True: 7.79k, False: 0] ------------------ 593| 7.79k| name, 594| 7.79k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.79k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (594:13): [True: 7.79k, False: 0] ------------------ 595| | 596| 7.79k| return buf; 597| 7.79k|} ogs-log.c:log_level: 601| 7.79k|{ 602| 7.79k| const char *colors[] = { 603| 7.79k| TA_NOR, ------------------ | | 32| 7.79k|#define TA_NOR "\033[0m" /* all off */ ------------------ 604| 7.79k| TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 36| 7.79k|#define TA_FGC_BOLD_RED "\033[1;31m" /* Bold Red */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 40| 7.79k|#define TA_FGC_BOLD_YELLOW "\033[1;33m" /* Bold Yellow */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 43| 7.79k|#define TA_FGC_BOLD_CYAN "\033[1;36m" /* Bold Cyan */ ------------------ 605| 7.79k| TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 38| 7.79k|#define TA_FGC_BOLD_GREEN "\033[1;32m" /* Bold Green */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 45| 7.79k|#define TA_FGC_BOLD_WHITE "\033[1;37m" /* Bold White */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 44| 7.79k|#define TA_FGC_WHITE "\033[37m" /* White */ ------------------ 606| 7.79k| }; 607| | 608| 7.79k| buf = ogs_slprintf(buf, last, "%s%s%s: ", 609| 7.79k| use_color ? colors[level] : "", ------------------ | Branch (609:13): [True: 7.79k, False: 0] ------------------ 610| 7.79k| level_strings[level], 611| 7.79k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.79k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (611:13): [True: 7.79k, False: 0] ------------------ 612| | 613| 7.79k| return buf; 614| 7.79k|} ogs-log.c:log_content: 618| 8.09k|{ 619| 8.09k| va_list bp; 620| | 621| 8.09k| va_copy(bp, ap); 622| 8.09k|#pragma GCC diagnostic push 623| 8.09k|#pragma GCC diagnostic ignored "-Wformat-nonliteral" 624| 8.09k| buf = ogs_vslprintf(buf, last, format, bp); 625| 8.09k|#pragma GCC diagnostic pop 626| 8.09k| va_end(bp); 627| | 628| 8.09k| return buf; 629| 8.09k|} ogs-log.c:log_linefeed: 632| 7.79k|{ 633| |#if defined(_WIN32) 634| | if (buf > last - 3) 635| | buf = last - 3; 636| | 637| | buf = ogs_slprintf(buf, last, "\r\n"); 638| |#else 639| 7.79k| if (buf > last - 2) ------------------ | Branch (639:9): [True: 0, False: 7.79k] ------------------ 640| 0| buf = last - 2; 641| | 642| 7.79k| buf = ogs_slprintf(buf, last, "\n"); 643| 7.79k|#endif 644| | 645| 7.79k| return buf; 646| 7.79k|} ogs-log.c:file_writer: 650| 8.09k|{ 651| 8.09k| fprintf(log->file.out, "%s", string); 652| 8.09k| fflush(log->file.out); 653| 8.09k|} 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| 685|{ 74| 685| void *ptr = NULL; 75| | 76| 685| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 685|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 77| | 78| 685| ptr = _talloc_zero(ctx, size, name); 79| 685| ogs_expect(ptr); ------------------ | | 128| 685| do { \ | | 129| 685| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 685|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 685, False: 0] | | | | ------------------ | | ------------------ | | 130| 685| 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| 685| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 685] | | ------------------ ------------------ 80| | 81| 685| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 685|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 82| | 83| 685| return ptr; 84| 685|} ogs_talloc_free: 102| 682|{ 103| 682| int ret; 104| | 105| 682| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 682|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 106| | 107| 682| ret = _talloc_free(ptr, location); 108| | 109| 682| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 682|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 110| | 111| 682| return ret; 112| 682|} ogs_pkbuf_put_data: 91| 682|{ 92| 682| void *tmp = ogs_pkbuf_put(pkbuf, len); 93| | 94| 682| memcpy(tmp, data, len); 95| 682| return tmp; 96| 682|} 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| 682|{ 223| 682|#if OGS_USE_TALLOC == 1 224| 682| ogs_pkbuf_t *pkbuf = NULL; 225| | 226| 682| pkbuf = ogs_talloc_zero_size(pool, sizeof(*pkbuf) + size, file_line); 227| 682| if (!pkbuf) { ------------------ | Branch (227:9): [True: 0, False: 682] ------------------ 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| 682| pkbuf->head = pkbuf->_data; 233| 682| pkbuf->end = pkbuf->_data + size; 234| | 235| 682| pkbuf->len = 0; 236| | 237| 682| pkbuf->data = pkbuf->_data; 238| 682| pkbuf->tail = pkbuf->_data; 239| | 240| 682| pkbuf->file_line = file_line; /* For debug */ 241| | 242| 682| 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| 682|} ogs_pkbuf_free: 290| 682|{ 291| 682|#if OGS_USE_TALLOC == 1 292| 682| ogs_talloc_free(pkbuf, OGS_FILE_LINE); ------------------ | | 213| 682|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | ------------------ | | | | 167| 682|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | ------------------ | | | | | | 168| 682|#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| 682|} message.c:ogs_pkbuf_pull: 165| 682|{ 166| 682| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 682|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 14, False: 668] | | ------------------ ------------------ 167| 682| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 682|} message.c:ogs_pkbuf_pull_inline: 159| 668|{ 160| 668| pkbuf->len -= len; 161| 668| return pkbuf->data += len; 162| 668|} message.c:ogs_pkbuf_push: 147| 668|{ 148| 668| if (ogs_unlikely(ogs_pkbuf_headroom(pkbuf) < (int)len)) ------------------ | | 55| 668|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 668] | | ------------------ ------------------ 149| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 150| | 151| 668| pkbuf->data -= len; 152| 668| pkbuf->len += len; 153| | 154| 668| return pkbuf->data; 155| 668|} message.c:ogs_pkbuf_headroom: 104| 668|{ 105| 668| return pkbuf->data - pkbuf->head; 106| 668|} ogs-pkbuf.c:ogs_pkbuf_put: 115| 682|{ 116| 682| void *tmp = pkbuf->tail; 117| | 118| 682| if (ogs_unlikely(ogs_pkbuf_tailroom(pkbuf) < (int)len)) ------------------ | | 55| 682|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 682] | | ------------------ ------------------ 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| 682| pkbuf->tail += len; 122| 682| pkbuf->len += len; 123| | 124| 682| return tmp; 125| 682|} ogs-pkbuf.c:ogs_pkbuf_tailroom: 99| 682|{ 100| 682| return pkbuf->end - pkbuf->tail; 101| 682|} ogs_rbtree_insert_color: 93| 6.19k|{ 94| 6.19k| ogs_rbnode_t *node = rb_node; 95| 6.19k| ogs_rbnode_t *parent; 96| 6.19k| ogs_assert(tree); ------------------ | | 113| 6.19k| do { \ | | 114| 6.19k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.19k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.19k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.19k| 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.19k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.19k] | | ------------------ ------------------ 97| 6.19k| ogs_assert(node); ------------------ | | 113| 6.19k| do { \ | | 114| 6.19k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.19k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.19k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.19k| 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.19k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.19k] | | ------------------ ------------------ 98| | 99| 12.6k| while ((parent = node->parent) && parent->color == OGS_RBTREE_RED) { ------------------ | Branch (99:12): [True: 11.5k, False: 1.11k] | Branch (99:39): [True: 6.45k, False: 5.07k] ------------------ 100| 6.45k| ogs_rbnode_t *gparent = parent->parent; 101| 6.45k| ogs_assert(gparent); ------------------ | | 113| 6.45k| do { \ | | 114| 6.45k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.45k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.45k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.45k| 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.45k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.45k] | | ------------------ ------------------ 102| | 103| | /* parent == grandparent's left child */ 104| 6.45k| if (parent == gparent->left) { ------------------ | Branch (104:13): [True: 2.83k, False: 3.61k] ------------------ 105| 2.83k| ogs_rbnode_t *uncle = gparent->right; 106| | 107| 2.83k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (107:17): [True: 1.61k, False: 1.22k] | Branch (107:26): [True: 1.15k, False: 460] ------------------ 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.15k| uncle->color = OGS_RBTREE_BLACK; 118| 1.15k| parent->color = OGS_RBTREE_BLACK; 119| | 120| 1.15k| gparent->color = OGS_RBTREE_RED; 121| | 122| 1.15k| node = gparent; 123| 1.68k| } else { 124| | /* node's uncle == black */ 125| 1.68k| if (node == parent->right) { ------------------ | Branch (125:21): [True: 1.00k, False: 676] ------------------ 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| 1.00k| node = node->parent; 137| 1.00k| rb_rotate_left(tree, node); 138| 1.00k| } 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.68k| node->parent->color = OGS_RBTREE_BLACK; 151| 1.68k| gparent->color = OGS_RBTREE_RED; 152| 1.68k| rb_rotate_right(tree, gparent); 153| 1.68k| } 154| | /* parent == grandparent's right child */ 155| 3.61k| } else { 156| 3.61k| ogs_rbnode_t *uncle = gparent->left; 157| | 158| 3.61k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (158:17): [True: 2.53k, False: 1.08k] | Branch (158:26): [True: 1.92k, False: 606] ------------------ 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.92k| uncle->color = OGS_RBTREE_BLACK; 169| 1.92k| parent->color = OGS_RBTREE_BLACK; 170| | 171| 1.92k| gparent->color = OGS_RBTREE_RED; 172| | 173| 1.92k| node = gparent; 174| 1.92k| } else { 175| | /* node's uncle == black */ 176| 1.68k| if (node == parent->left) { ------------------ | Branch (176:21): [True: 722, False: 966] ------------------ 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| 722| node = node->parent; 188| 722| rb_rotate_right(tree, node); 189| 722| } 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.68k| node->parent->color = OGS_RBTREE_BLACK; 202| 1.68k| gparent->color = OGS_RBTREE_RED; 203| 1.68k| rb_rotate_left(tree, gparent); 204| 1.68k| } 205| 3.61k| } 206| 6.45k| } 207| | 208| 6.19k| ogs_assert(tree->root); ------------------ | | 113| 6.19k| do { \ | | 114| 6.19k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 6.19k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 6.19k, False: 0] | | | | ------------------ | | ------------------ | | 115| 6.19k| 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.19k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6.19k] | | ------------------ ------------------ 209| 6.19k| tree->root->color = OGS_RBTREE_BLACK; 210| 6.19k|} ogs-rbtree.c:rb_rotate_left: 56| 2.69k|{ 57| 2.69k| ogs_rbnode_t *right = node->right; 58| 2.69k| node->right = right->left; 59| 2.69k| if (right->left) ------------------ | Branch (59:9): [True: 930, False: 1.76k] ------------------ 60| 930| right->left->parent = node; 61| | 62| 2.69k| rb_replace_node(tree, node, right, node->parent); 63| | 64| 2.69k| right->left = node; 65| 2.69k| node->parent = right; 66| 2.69k|} ogs-rbtree.c:rb_rotate_right: 80| 2.40k|{ 81| 2.40k| ogs_rbnode_t *left = node->left; 82| 2.40k| node->left = left->right; 83| 2.40k| if (left->right) ------------------ | Branch (83:9): [True: 665, False: 1.74k] ------------------ 84| 665| left->right->parent = node; 85| | 86| 2.40k| rb_replace_node(tree, node, left, node->parent); 87| | 88| 2.40k| left->right = node; 89| 2.40k| node->parent = left; 90| 2.40k|} ogs-rbtree.c:rb_replace_node: 37| 5.10k|{ 38| 5.10k| rb_change_child(tree, old, new, parent); 39| | 40| 5.10k| if (new) ------------------ | Branch (40:9): [True: 5.10k, False: 0] ------------------ 41| 5.10k| new->parent = parent; 42| 5.10k|} ogs-rbtree.c:rb_change_child: 24| 5.10k|{ 25| 5.10k| if (parent) { ------------------ | Branch (25:9): [True: 4.56k, False: 540] ------------------ 26| 4.56k| if (old == parent->left) ------------------ | Branch (26:13): [True: 2.17k, False: 2.38k] ------------------ 27| 2.17k| parent->left = new; 28| 2.38k| else 29| 2.38k| parent->right = new; 30| 4.56k| } else { 31| 540| tree->root = new; 32| 540| } 33| 5.10k|} ogs-tlv-msg.c:ogs_rbtree_link_node: 54| 6.19k|{ 55| 6.19k| ogs_rbnode_t *node = (ogs_rbnode_t *)rb_node; 56| 6.19k| node->parent = parent; 57| 6.19k| node->left = node->right = NULL; 58| 6.19k| node->color = OGS_RBTREE_RED; 59| | 60| 6.19k| *rb_link = node; 61| 6.19k|} 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| 132k|{ 64| 132k| 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| 132k| r = vsnprintf(str, size, format, ap); 78| 132k|#endif 79| 132k| str[size-1] = '\0'; 80| | 81| 132k| return r; 82| 132k|} ogs_vslprintf: 97| 132k|{ 98| 132k| int r = -1; 99| | 100| 132k| ogs_assert(last); ------------------ | | 113| 132k| do { \ | | 114| 132k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 132k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 132k, False: 0] | | | | ------------------ | | ------------------ | | 115| 132k| 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| 132k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 132k] | | ------------------ ------------------ 101| | 102| 132k| if (!str) ------------------ | Branch (102:9): [True: 0, False: 132k] ------------------ 103| 0| return NULL; 104| | 105| 132k| if (str < last) ------------------ | Branch (105:9): [True: 132k, False: 0] ------------------ 106| 132k| r = ogs_vsnprintf(str, last - str, format, ap); 107| | 108| 132k| return (str + r); 109| 132k|} ogs_slprintf: 112| 124k|{ 113| 124k| char *r; 114| 124k| va_list ap; 115| | 116| 124k| va_start(ap, format); 117| 124k| r = ogs_vslprintf(str, last, format, ap); 118| 124k| va_end(ap); 119| | 120| 124k| return r; 121| 124k|} ogs_gettimeofday: 74| 7.79k|{ 75| |#if defined(_WIN32) 76| |#if defined(_MSC_VER) 77| |#define DELTA_EPOCH_IN_MICROSEC 11644473600000000Ui64 78| |#else 79| |#define DELTA_EPOCH_IN_MICROSEC 11644473600000000ULL 80| |#endif 81| | FILETIME ft; 82| | uint64_t tmp = 0; 83| | 84| | /* 85| | * The const value is shamelessy stolen from 86| | * http://www.boost.org/doc/libs/1_55_0/boost/chrono/detail/inlined/win/chrono.hpp 87| | * 88| | * File times are the number of 100 nanosecond intervals elapsed since 89| | * 12:00 am Jan 1, 1601 UTC. I haven't check the math particularly hard 90| | * 91| | * ... good luck 92| | */ 93| | 94| | if (tv) { 95| | GetSystemTimeAsFileTime (&ft); 96| | 97| | /* pull out of the filetime into a 64 bit uint */ 98| | tmp |= ft.dwHighDateTime; 99| | tmp <<= 32; 100| | tmp |= ft.dwLowDateTime; 101| | 102| | /* convert from 100's of nanosecs to microsecs */ 103| | tmp /= 10; 104| | 105| | /* adjust to unix epoch */ 106| | tmp -= DELTA_EPOCH_IN_MICROSEC; 107| | 108| | tv->tv_sec = (long) (tmp / 1000000UL); 109| | tv->tv_usec = (long) (tmp % 1000000UL); 110| | } 111| | 112| | return 0; 113| |#else 114| 7.79k| int rc = gettimeofday(tv, NULL); 115| 7.79k| ogs_assert(rc == 0); ------------------ | | 113| 7.79k| do { \ | | 114| 7.79k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.79k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.79k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.79k| 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.79k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.79k] | | ------------------ ------------------ 116| 7.79k| return 0; 117| 7.79k|#endif 118| 7.79k|} ogs_get_monotonic_time: 241| 3|{ 242| 3|#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) 243| 3| struct timespec ts; 244| 3| clock_gettime(CLOCK_MONOTONIC, &ts); 245| 3| return ogs_time_from_sec(ts.tv_sec) + ts.tv_nsec / 1000UL; ------------------ | | 97| 3|#define ogs_time_from_sec(sec) ((ogs_time_t)(sec) * OGS_USEC_PER_SEC) | | ------------------ | | | | 76| 3|#define OGS_USEC_PER_SEC (1000000LL) | | ------------------ ------------------ 246| |#elif defined(__APPLE__) 247| | static mach_timebase_info_data_t info = {0}; 248| | static double ratio = 0.0; 249| | 250| | if (!info.denom) { 251| | /* the value from mach_absolute_time () * info.numer / info.denom 252| | * is in nano seconds. So we have to divid by 1000.0 to get micro 253| | * seconds*/ 254| | mach_timebase_info(&info); 255| | ratio = (double) info.numer / (double) info.denom / 1000.0; 256| | } 257| | 258| | return mach_absolute_time() * ratio; 259| |#elif defined(_WIN32) 260| | /* Despite it's name, this is in milliseconds! */ 261| | ogs_time_t ticks = GetTickCount64(); 262| | return (ticks * 1000L); 263| |#elif defined(__hpux__) 264| | ogs_time_t nanosec = gethrtime(); 265| | return (nanosec / 1000UL); 266| |#else 267| |#warning "Monotonic clock is not yet supported on your platform." 268| | struct timeval tv; 269| | 270| | ogs_gettimeofday(&tv); 271| | return ogs_time_from_sec(tv.tv_sec) + tv.tv_usec; 272| |#endif 273| 3|} ogs_localtime: 276| 7.79k|{ 277| 7.79k| ogs_assert(tm); ------------------ | | 113| 7.79k| do { \ | | 114| 7.79k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.79k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.79k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.79k| 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.79k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.79k] | | ------------------ ------------------ 278| 7.79k| memset(tm, 0, sizeof(*tm)); 279| | 280| 7.79k|#if (HAVE_LOCALTIME_R) 281| 7.79k| (void)localtime_r(&s, tm); 282| |#else 283| | struct tm *t; 284| | 285| | t = localtime(&s); 286| | *tm = *t; 287| |#endif 288| 7.79k|} ogs_tlv_parse_msg: 743| 313|{ 744| 313| int rv; 745| 313| ogs_tlv_t *root; 746| | 747| 313| ogs_assert(msg); ------------------ | | 113| 313| do { \ | | 114| 313| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 313|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 313, False: 0] | | | | ------------------ | | ------------------ | | 115| 313| 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| 313| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 313] | | ------------------ ------------------ 748| 313| ogs_assert(desc); ------------------ | | 113| 313| do { \ | | 114| 313| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 313|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 313, False: 0] | | | | ------------------ | | ------------------ | | 115| 313| 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| 313| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 313] | | ------------------ ------------------ 749| 313| ogs_assert(pkbuf); ------------------ | | 113| 313| do { \ | | 114| 313| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 313|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 313, False: 0] | | | | ------------------ | | ------------------ | | 115| 313| 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| 313| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 313] | | ------------------ ------------------ 750| | 751| 313| ogs_assert(desc->ctype == OGS_TLV_MESSAGE); ------------------ | | 113| 313| do { \ | | 114| 313| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 313|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 313, False: 0] | | | | ------------------ | | ------------------ | | 115| 313| 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| 313| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 313] | | ------------------ ------------------ 752| 313| if (!desc->child_descs[0]) { ------------------ | Branch (752:9): [True: 0, False: 313] ------------------ 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| 313| root = ogs_tlv_parse_block(pkbuf->len, pkbuf->data, mode); 758| 313| if (root == NULL) { ------------------ | Branch (758:9): [True: 90, False: 223] ------------------ 759| 90| ogs_error("Can't parse TLV message"); ------------------ | | 36| 90|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 90| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 90|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 90| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 90|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 90| 0, __VA_ARGS__) | | ------------------ ------------------ 760| 90| return OGS_ERROR; ------------------ | | 78| 90|#define OGS_ERROR -1 ------------------ 761| 90| } 762| | 763| 223| rv = tlv_parse_compound(msg, desc, root, 0, mode); 764| | 765| 223| ogs_tlv_free_all(root); 766| | 767| 223| return rv; 768| 313|} ogs_tlv_parse_msg_desc: 898| 337|{ 899| 337| int rv; 900| 337| ogs_tlv_t *root; 901| | 902| 337| ogs_assert(msg); ------------------ | | 113| 337| do { \ | | 114| 337| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 337|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 337, False: 0] | | | | ------------------ | | ------------------ | | 115| 337| 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| 337| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 337] | | ------------------ ------------------ 903| 337| ogs_assert(desc); ------------------ | | 113| 337| do { \ | | 114| 337| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 337|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 337, False: 0] | | | | ------------------ | | ------------------ | | 115| 337| 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| 337| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 337] | | ------------------ ------------------ 904| 337| ogs_assert(pkbuf); ------------------ | | 113| 337| do { \ | | 114| 337| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 337|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 337, False: 0] | | | | ------------------ | | ------------------ | | 115| 337| 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| 337| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 337] | | ------------------ ------------------ 905| | 906| 337| ogs_assert(desc->ctype == OGS_TLV_MESSAGE); ------------------ | | 113| 337| do { \ | | 114| 337| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 337|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 337, False: 0] | | | | ------------------ | | ------------------ | | 115| 337| 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| 337| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 337] | | ------------------ ------------------ 907| 337| ogs_assert(desc->child_descs[0]); ------------------ | | 113| 337| do { \ | | 114| 337| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 337|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 337, False: 0] | | | | ------------------ | | ------------------ | | 115| 337| 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| 337| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 337] | | ------------------ ------------------ 908| | 909| 337| root = ogs_tlv_parse_block_desc(pkbuf->len, pkbuf->data, msg_mode, desc); 910| 337| if (root == NULL) { ------------------ | Branch (910:9): [True: 215, False: 122] ------------------ 911| 215| ogs_error("Can't parse TLV message"); ------------------ | | 36| 215|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 215| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 215|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 215| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 215|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 215| 0, __VA_ARGS__) | | ------------------ ------------------ 912| 215| return OGS_ERROR; ------------------ | | 78| 215|#define OGS_ERROR -1 ------------------ 913| 215| } 914| | 915| 122| rv = tlv_parse_compound(msg, desc, root, 0, msg_mode); 916| | 917| 122| ogs_tlv_free_all(root); 918| | 919| 122| return rv; 920| 337|} ogs-tlv-msg.c:tlv_ctype2mode: 59| 4.48k|{ 60| 4.48k| switch(ctype) { 61| 466| case OGS_TLV_UINT8: ------------------ | Branch (61:5): [True: 466, False: 4.02k] ------------------ 62| 466| case OGS_TLV_UINT16: ------------------ | Branch (62:5): [True: 0, False: 4.48k] ------------------ 63| 466| case OGS_TLV_UINT24: ------------------ | Branch (63:5): [True: 0, False: 4.48k] ------------------ 64| 466| case OGS_TLV_UINT32: ------------------ | Branch (64:5): [True: 0, False: 4.48k] ------------------ 65| 466| case OGS_TLV_INT8: ------------------ | Branch (65:5): [True: 0, False: 4.48k] ------------------ 66| 466| case OGS_TLV_INT16: ------------------ | Branch (66:5): [True: 0, False: 4.48k] ------------------ 67| 466| case OGS_TLV_INT24: ------------------ | Branch (67:5): [True: 0, False: 4.48k] ------------------ 68| 466| case OGS_TLV_INT32: ------------------ | Branch (68:5): [True: 0, False: 4.48k] ------------------ 69| 1.05k| case OGS_TLV_FIXED_STR: ------------------ | Branch (69:5): [True: 586, False: 3.90k] ------------------ 70| 1.35k| case OGS_TLV_VAR_STR: ------------------ | Branch (70:5): [True: 300, False: 4.18k] ------------------ 71| 1.35k| case OGS_TLV_NULL: ------------------ | Branch (71:5): [True: 0, False: 4.48k] ------------------ 72| 1.35k| case OGS_TLV_MORE: ------------------ | Branch (72:5): [True: 0, False: 4.48k] ------------------ 73| 1.35k| case OGS_TLV_COMPOUND: ------------------ | Branch (73:5): [True: 0, False: 4.48k] ------------------ 74| 1.35k| case OGS_TLV_MESSAGE: ------------------ | Branch (74:5): [True: 0, False: 4.48k] ------------------ 75| 1.35k| return msg_mode; 76| 1.28k| case OGS_TV_UINT8: ------------------ | Branch (76:5): [True: 1.28k, False: 3.19k] ------------------ 77| 1.65k| case OGS_TV_UINT16: ------------------ | Branch (77:5): [True: 366, False: 4.12k] ------------------ 78| 1.97k| case OGS_TV_UINT24: ------------------ | Branch (78:5): [True: 322, False: 4.16k] ------------------ 79| 2.39k| case OGS_TV_UINT32: ------------------ | Branch (79:5): [True: 413, False: 4.07k] ------------------ 80| 2.39k| case OGS_TV_INT8: ------------------ | Branch (80:5): [True: 0, False: 4.48k] ------------------ 81| 2.39k| case OGS_TV_INT16: ------------------ | Branch (81:5): [True: 0, False: 4.48k] ------------------ 82| 2.39k| case OGS_TV_INT24: ------------------ | Branch (82:5): [True: 0, False: 4.48k] ------------------ 83| 2.39k| case OGS_TV_INT32: ------------------ | Branch (83:5): [True: 0, False: 4.48k] ------------------ 84| 3.13k| case OGS_TV_FIXED_STR: ------------------ | Branch (84:5): [True: 744, False: 3.74k] ------------------ 85| 3.13k| case OGS_TV_VAR_STR: ------------------ | Branch (85:5): [True: 0, False: 4.48k] ------------------ 86| 3.13k| case OGS_TV_NULL: ------------------ | Branch (86:5): [True: 0, False: 4.48k] ------------------ 87| 3.13k| case OGS_TV_MORE: ------------------ | Branch (87:5): [True: 0, False: 4.48k] ------------------ 88| 3.13k| if (msg_mode == OGS_TLV_MODE_T2_L2) ------------------ | | 35| 3.13k|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (88:13): [True: 0, False: 3.13k] ------------------ 89| 0| return OGS_TLV_MODE_T1; /* Here return OGS_TLV_MODE_T2 if ever existing */ ------------------ | | 36| 0|#define OGS_TLV_MODE_T1 5 ------------------ 90| 3.13k| else 91| 3.13k| return OGS_TLV_MODE_T1; ------------------ | | 36| 3.13k|#define OGS_TLV_MODE_T1 5 ------------------ 92| 0| default: ------------------ | Branch (92:5): [True: 0, False: 4.48k] ------------------ 93| 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] | | ------------------ ------------------ 94| 0| break; 95| 4.48k| } 96| 4.48k|} ogs-tlv-msg.c:tlv_parse_compound: 643| 662|{ 644| 662| int rv; 645| 662| ogs_tlv_presence_t *presence_p = (ogs_tlv_presence_t *)msg; 646| 662| ogs_tlv_desc_t *desc = NULL, *next_desc = NULL; 647| 662| ogs_tlv_t *tlv = NULL, *emb_tlv = NULL; 648| 662| uint8_t *p = msg; 649| 662| uint32_t offset = 0; 650| 662| uint8_t index = 0; 651| 662| int i = 0, j; 652| 662| OGS_RBTREE(tree); ------------------ | | 48| 662|#define OGS_RBTREE(name) ogs_rbtree_t name = { NULL } ------------------ 653| 662| tlv_count_node_t count_node[OGS_TLV_MAX_CHILD_DESC]; 654| 662| unsigned count_node_alloc_next = 0; 655| 662| char indent[17] = " "; /* 16 spaces */ 656| | 657| 662| ogs_assert(msg); ------------------ | | 113| 662| do { \ | | 114| 662| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 662|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 662, False: 0] | | | | ------------------ | | ------------------ | | 115| 662| 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| 662| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 662] | | ------------------ ------------------ 658| 662| ogs_assert(parent_desc); ------------------ | | 113| 662| do { \ | | 114| 662| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 662|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 662, False: 0] | | | | ------------------ | | ------------------ | | 115| 662| 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| 662| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 662] | | ------------------ ------------------ 659| 662| ogs_assert(parent_tlv); ------------------ | | 113| 662| do { \ | | 114| 662| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 662|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 662, False: 0] | | | | ------------------ | | ------------------ | | 115| 662| 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| 662| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 662] | | ------------------ ------------------ 660| | 661| 662| ogs_assert(depth <= 8); ------------------ | | 113| 662| do { \ | | 114| 662| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 662|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 662, False: 0] | | | | ------------------ | | ------------------ | | 115| 662| 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| 662| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 662] | | ------------------ ------------------ 662| 662| indent[depth*2] = 0; 663| | 664| 662| tlv = parent_tlv; 665| 8.63k| while (tlv) { ------------------ | Branch (665:12): [True: 8.07k, False: 563] ------------------ 666| 8.07k| tlv_count_node_t *curr_count = tlv_count_node_find(&tree, &count_node[0], 667| 8.07k| OGS_ARRAY_SIZE(count_node), &count_node_alloc_next, tlv->type, tlv->instance); ------------------ | | 165| 8.07k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 668| 8.07k| if (!curr_count) ------------------ | Branch (668:13): [True: 1, False: 8.07k] ------------------ 669| 1| return OGS_ERROR; ------------------ | | 78| 1|#define OGS_ERROR -1 ------------------ 670| 8.07k| desc = tlv_find_desc_by_type_inst(&index, &offset, parent_desc, tlv->type, tlv->instance, curr_count->count); 671| 8.07k| if (desc == NULL) { ------------------ | Branch (671:13): [True: 6.55k, False: 1.52k] ------------------ 672| 6.55k| ogs_warn("Unknown TLV type [%d]", tlv->type); ------------------ | | 37| 6.55k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.55k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 6.55k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 6.55k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.55k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.55k| 0, __VA_ARGS__) | | ------------------ ------------------ 673| 6.55k| tlv = tlv->next; 674| 6.55k| continue; 675| 6.55k| } 676| | 677| 1.52k| presence_p = (ogs_tlv_presence_t *)(p + offset); 678| | 679| | /* Multiple of the same type TLV may be included */ 680| 1.52k| next_desc = parent_desc->child_descs[index+1]; 681| 1.52k| if (next_desc != NULL && next_desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (681:13): [True: 1.38k, False: 141] | Branch (681:34): [True: 735, False: 646] ------------------ 682| 5.02k| for (j = 0; j < next_desc->length; j++) { ------------------ | Branch (682:25): [True: 4.58k, False: 443] ------------------ 683| 4.58k| presence_p = 684| 4.58k| (ogs_tlv_presence_t *)(p + offset + desc->vsize * j); 685| 4.58k| if (*presence_p == 0) { ------------------ | Branch (685:21): [True: 292, False: 4.29k] ------------------ 686| 292| offset += desc->vsize * j; 687| 292| break; 688| 292| } 689| 4.58k| } 690| 735| if (j == next_desc->length) { ------------------ | Branch (690:17): [True: 443, False: 292] ------------------ 691| 443| ogs_fatal("Multiple of the same type TLV need more room"); ------------------ | | 35| 443|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | ------------------ | | | | 43| 443| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 443|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 443| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 443|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 443| 0, __VA_ARGS__) | | ------------------ ------------------ 692| 443| tlv = tlv->next; 693| 443| continue; 694| 443| } 695| 787| } else { 696| 787| curr_count->count++; 697| 787| } 698| | 699| 1.07k| if (desc->ctype == OGS_TLV_COMPOUND) { ------------------ | Branch (699:13): [True: 336, False: 743] ------------------ 700| 336| emb_tlv = ogs_tlv_parse_embedded_block(tlv, mode); 701| 336| if (emb_tlv == NULL) { ------------------ | Branch (701:17): [True: 19, False: 317] ------------------ 702| 19| ogs_error("Error while parse TLV"); ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 19|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 703| 19| return OGS_ERROR; ------------------ | | 78| 19|#define OGS_ERROR -1 ------------------ 704| 19| } 705| | 706| 317| ogs_trace("PARSE %sC#%d [%s] T:%d I:%d (vsz=%d) off:%p ", ------------------ | | 40| 317|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 317| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 317|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 317| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 317|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 317| 0, __VA_ARGS__) | | ------------------ ------------------ 707| 317| indent, i++, desc->name, desc->type, desc->instance, 708| 317| desc->vsize, p + offset); 709| | 710| 317| offset += sizeof(ogs_tlv_presence_t); 711| | 712| 317| rv = tlv_parse_compound( 713| 317| p + offset, desc, emb_tlv, depth + 1, mode); 714| 317| if (rv != OGS_OK) { ------------------ | | 77| 317|#define OGS_OK 0 ------------------ | Branch (714:17): [True: 2, False: 315] ------------------ 715| 2| ogs_error("Can't parse compound TLV"); ------------------ | | 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__) | | ------------------ ------------------ 716| 2| return OGS_ERROR; ------------------ | | 78| 2|#define OGS_ERROR -1 ------------------ 717| 2| } 718| | 719| 315| *presence_p = 1; 720| 743| } else { 721| 743| ogs_trace("PARSE %sL#%d [%s] T:%d L:%d I:%d " ------------------ | | 40| 743|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 743| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 743|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 743| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 743|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 743| 0, __VA_ARGS__) | | ------------------ ------------------ 722| 743| "(cls:%d vsz:%d) off:%p ", 723| 743| indent, i++, desc->name, desc->type, desc->length, 724| 743| desc->instance, desc->ctype, desc->vsize, p + offset); 725| | 726| 743| rv = tlv_parse_leaf(p + offset, desc, tlv); 727| 743| if (rv != OGS_OK) { ------------------ | | 77| 743|#define OGS_OK 0 ------------------ | Branch (727:17): [True: 77, False: 666] ------------------ 728| 77| ogs_error("Can't parse leaf TLV"); ------------------ | | 36| 77|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 77| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 77|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 77| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 77|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 77| 0, __VA_ARGS__) | | ------------------ ------------------ 729| 77| return OGS_ERROR; ------------------ | | 78| 77|#define OGS_ERROR -1 ------------------ 730| 77| } 731| | 732| 666| *presence_p = 1; 733| 666| } 734| | 735| 981| tlv = tlv->next; 736| 981| } 737| | 738| 563| return OGS_OK; ------------------ | | 77| 563|#define OGS_OK 0 ------------------ 739| 662|} ogs-tlv-msg.c:tlv_count_node_find: 608| 8.07k|{ 609| 8.07k| ogs_rbnode_t **new = NULL; 610| 8.07k| ogs_rbnode_t *parent = NULL; 611| 8.07k| tlv_count_node_t *this; 612| | 613| 8.07k| uint64_t key = (((uint32_t)type)<<8) | instance; 614| | 615| 8.07k| new = &tree->root; 616| 36.5k| while (*new) { ------------------ | Branch (616:12): [True: 30.3k, False: 6.19k] ------------------ 617| 30.3k| this = ogs_rb_entry(*new, tlv_count_node_t, node); ------------------ | | 50| 30.3k|#define ogs_rb_entry(ptr, type, member) ogs_container_of(ptr, type, member) | | ------------------ | | | | 188| 30.3k| (type *)((unsigned char *)ptr - offsetof(type, member)) | | ------------------ ------------------ 618| 30.3k| parent = *new; 619| 30.3k| if (key < this->key) { ------------------ | Branch (619:13): [True: 12.7k, False: 17.6k] ------------------ 620| 12.7k| new = &(*new)->left; 621| 17.6k| } else if (key > this->key) { ------------------ | Branch (621:20): [True: 15.7k, False: 1.87k] ------------------ 622| 15.7k| new = &(*new)->right; 623| 15.7k| } else { /* found entry: */ 624| 1.87k| return this; 625| 1.87k| } 626| 30.3k| } 627| | 628| | /* No entry, need to add one: */ 629| 6.19k| if (*count_alloc_next == count_node_arr_len) { ------------------ | Branch (629:9): [True: 1, False: 6.19k] ------------------ 630| 1| ogs_error("This TLV has to many entries, can't parse"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 1|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 631| 1| return NULL; 632| 1| } 633| 6.19k| this = &count_node_arr[(*count_alloc_next)++]; 634| 6.19k| this->key = key; 635| 6.19k| this->count = 0; 636| 6.19k| ogs_rbtree_link_node(&this->node, parent, new); 637| 6.19k| ogs_rbtree_insert_color(tree, &this->node); 638| 6.19k| return this; 639| 6.19k|} ogs-tlv-msg.c:tlv_find_desc_by_type_inst: 456| 12.6k|{ 457| 12.6k| ogs_tlv_desc_t *prev_desc = NULL, *desc = NULL; 458| 12.6k| int i, offset = 0; 459| 12.6k| unsigned match_i = 0; 460| | 461| 12.6k| ogs_assert(parent_desc); ------------------ | | 113| 12.6k| do { \ | | 114| 12.6k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 12.6k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 12.6k, False: 0] | | | | ------------------ | | ------------------ | | 115| 12.6k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 12.6k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 12.6k] | | ------------------ ------------------ 462| | 463| 236k| for (i = 0, desc = parent_desc->child_descs[i]; desc != NULL; ------------------ | Branch (463:53): [True: 229k, False: 6.64k] ------------------ 464| 229k| i++, desc = parent_desc->child_descs[i]) { 465| 229k| if (desc->type == match_type && desc->instance == match_instance) { ------------------ | Branch (465:13): [True: 8.55k, False: 221k] | Branch (465:41): [True: 7.01k, False: 1.54k] ------------------ 466| 7.01k| if (match_i == match_type_pos) { ------------------ | Branch (466:17): [True: 6.00k, False: 1.00k] ------------------ 467| 6.00k| *desc_index = i; 468| 6.00k| *tlv_offset = offset; 469| 6.00k| break; 470| 6.00k| } 471| 1.00k| match_i++; 472| 1.00k| } 473| | 474| 223k| if (desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (474:13): [True: 2.36k, False: 221k] ------------------ 475| 2.36k| ogs_assert(prev_desc && prev_desc->ctype != OGS_TLV_MORE); ------------------ | | 113| 2.36k| do { \ | | 114| 2.36k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4.73k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.36k, False: 0] | | | | | Branch (54:44): [True: 2.36k, False: 0] | | | | | Branch (54:44): [True: 2.36k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.36k| 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| 2.36k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.36k] | | ------------------ ------------------ 476| 2.36k| offset += prev_desc->vsize * (desc->length - 1); 477| 221k| } else { 478| 221k| offset += desc->vsize; 479| 221k| } 480| | 481| 223k| prev_desc = desc; 482| 223k| } 483| | 484| 12.6k| return desc; 485| 12.6k|} ogs-tlv-msg.c:tlv_parse_leaf: 488| 743|{ 489| 743| ogs_assert(msg); ------------------ | | 113| 743| do { \ | | 114| 743| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 743|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 743, False: 0] | | | | ------------------ | | ------------------ | | 115| 743| 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| 743| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 743] | | ------------------ ------------------ 490| 743| ogs_assert(desc); ------------------ | | 113| 743| do { \ | | 114| 743| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 743|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 743, False: 0] | | | | ------------------ | | ------------------ | | 115| 743| 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| 743| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 743] | | ------------------ ------------------ 491| 743| ogs_assert(tlv); ------------------ | | 113| 743| do { \ | | 114| 743| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 743|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 743, False: 0] | | | | ------------------ | | ------------------ | | 115| 743| 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| 743| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 743] | | ------------------ ------------------ 492| | 493| 743| switch (desc->ctype) { 494| 141| case OGS_TV_UINT8: ------------------ | Branch (494:5): [True: 141, False: 602] ------------------ 495| 141| case OGS_TV_INT8: ------------------ | Branch (495:5): [True: 0, False: 743] ------------------ 496| 175| case OGS_TLV_UINT8: ------------------ | Branch (496:5): [True: 34, False: 709] ------------------ 497| 175| case OGS_TLV_INT8: ------------------ | Branch (497:5): [True: 0, False: 743] ------------------ 498| 175| { 499| 175| ogs_tlv_uint8_t *v = (ogs_tlv_uint8_t *)msg; 500| | 501| 175| if (tlv->length != 1) { ------------------ | Branch (501:13): [True: 19, False: 156] ------------------ 502| 19| ogs_error("Invalid TLV length %d. It should be 1", tlv->length); ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 19|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 503| 19| return OGS_ERROR; ------------------ | | 78| 19|#define OGS_ERROR -1 ------------------ 504| 19| } 505| 156| v->u8 = *(uint8_t*)(tlv->value); 506| 156| break; 507| 175| } 508| 26| case OGS_TV_UINT16: ------------------ | Branch (508:5): [True: 26, False: 717] ------------------ 509| 26| case OGS_TV_INT16: ------------------ | Branch (509:5): [True: 0, False: 743] ------------------ 510| 45| case OGS_TLV_UINT16: ------------------ | Branch (510:5): [True: 19, False: 724] ------------------ 511| 45| case OGS_TLV_INT16: ------------------ | Branch (511:5): [True: 0, False: 743] ------------------ 512| 45| { 513| 45| ogs_tlv_uint16_t *v = (ogs_tlv_uint16_t *)msg; 514| | 515| 45| if (tlv->length != 2) { ------------------ | Branch (515:13): [True: 13, False: 32] ------------------ 516| 13| ogs_error("Invalid TLV length %d. It should be 2", tlv->length); ------------------ | | 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__) | | ------------------ ------------------ 517| 13| return OGS_ERROR; ------------------ | | 78| 13|#define OGS_ERROR -1 ------------------ 518| 13| } 519| 32| v->u16 = ((((uint8_t*)tlv->value)[0]<< 8)&0xff00) | 520| 32| ((((uint8_t*)tlv->value)[1] )&0x00ff); 521| 32| break; 522| 45| } 523| 1| case OGS_TV_UINT24: ------------------ | Branch (523:5): [True: 1, False: 742] ------------------ 524| 1| case OGS_TV_INT24: ------------------ | Branch (524:5): [True: 0, False: 743] ------------------ 525| 1| case OGS_TLV_UINT24: ------------------ | Branch (525:5): [True: 0, False: 743] ------------------ 526| 1| case OGS_TLV_INT24: ------------------ | Branch (526:5): [True: 0, False: 743] ------------------ 527| 1| { 528| 1| ogs_tlv_uint24_t *v = (ogs_tlv_uint24_t *)msg; 529| | 530| 1| if (tlv->length != 3) { ------------------ | Branch (530:13): [True: 0, False: 1] ------------------ 531| 0| ogs_error("Invalid TLV length %d. It should be 3", tlv->length); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 532| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 533| 0| } 534| 1| v->u24 = ((((uint8_t*)tlv->value)[0]<<16)&0x00ff0000) | 535| 1| ((((uint8_t*)tlv->value)[1]<< 8)&0x0000ff00) | 536| 1| ((((uint8_t*)tlv->value)[2] )&0x000000ff); 537| 1| break; 538| 1| } 539| 14| case OGS_TV_UINT32: ------------------ | Branch (539:5): [True: 14, False: 729] ------------------ 540| 14| case OGS_TV_INT32: ------------------ | Branch (540:5): [True: 0, False: 743] ------------------ 541| 64| case OGS_TLV_UINT32: ------------------ | Branch (541:5): [True: 50, False: 693] ------------------ 542| 64| case OGS_TLV_INT32: ------------------ | Branch (542:5): [True: 0, False: 743] ------------------ 543| 64| { 544| 64| ogs_tlv_uint32_t *v = (ogs_tlv_uint32_t *)msg; 545| | 546| 64| if (tlv->length != 4) { ------------------ | Branch (546:13): [True: 15, False: 49] ------------------ 547| 15| ogs_error("Invalid TLV length %d. It should be 4", tlv->length); ------------------ | | 36| 15|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 15| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 15|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 15| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 15|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 15| 0, __VA_ARGS__) | | ------------------ ------------------ 548| 15| return OGS_ERROR; ------------------ | | 78| 15|#define OGS_ERROR -1 ------------------ 549| 15| } 550| 49| v->u32 = (((uint32_t)((uint8_t*)tlv->value)[0]<<24)&0xff000000) | 551| 49| ((((uint8_t*)tlv->value)[1]<<16)&0x00ff0000) | 552| 49| ((((uint8_t*)tlv->value)[2]<< 8)&0x0000ff00) | 553| 49| ((((uint8_t*)tlv->value)[3] )&0x000000ff); 554| 49| break; 555| 64| } 556| 24| case OGS_TV_FIXED_STR: ------------------ | Branch (556:5): [True: 24, False: 719] ------------------ 557| 64| case OGS_TLV_FIXED_STR: ------------------ | Branch (557:5): [True: 40, False: 703] ------------------ 558| 64| { 559| 64| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 560| | 561| 64| if (tlv->length != desc->length) ------------------ | Branch (561:13): [True: 27, False: 37] ------------------ 562| 27| { 563| 27| ogs_error("Invalid TLV length %d. It should be %d", ------------------ | | 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__) | | ------------------ ------------------ 564| 27| tlv->length, desc->length); 565| 27| return OGS_ERROR; ------------------ | | 78| 27|#define OGS_ERROR -1 ------------------ 566| 27| } 567| | 568| 37| v->data = tlv->value; 569| 37| v->len = tlv->length; 570| 37| break; 571| 64| } 572| 391| case OGS_TLV_VAR_STR: ------------------ | Branch (572:5): [True: 391, False: 352] ------------------ 573| 391| { 574| 391| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 575| | 576| 391| v->data = tlv->value; 577| 391| v->len = tlv->length; 578| 391| break; 579| 64| } 580| 0| case OGS_TV_NULL: ------------------ | Branch (580:5): [True: 0, False: 743] ------------------ 581| 0| case OGS_TLV_NULL: ------------------ | Branch (581:5): [True: 0, False: 743] ------------------ 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| 3| default: ------------------ | Branch (589:5): [True: 3, False: 740] ------------------ 590| 3| ogs_error("Unknown type[%d]", desc->ctype); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 3|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 591| 3| return OGS_ERROR; ------------------ | | 78| 3|#define OGS_ERROR -1 ------------------ 592| 743| } 593| | 594| 666| return OGS_OK; ------------------ | | 77| 666|#define OGS_OK 0 ------------------ 595| 743|} ogs-tlv-msg.c:ogs_tlv_parse_block_desc: 828| 337|{ 829| 337| uint8_t *pos = data; 830| 337| uint8_t *blk = data; 831| | 832| 337| ogs_tlv_t *root = NULL; 833| 337| ogs_tlv_t *prev = NULL; 834| 337| ogs_tlv_t *curr = NULL; 835| | 836| 337| root = curr = ogs_tlv_get(); 837| 337| if (!curr) { ------------------ | Branch (837:9): [True: 0, False: 337] ------------------ 838| 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, \ | | | | ------------------ | | | | | | 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__) | | ------------------ ------------------ 839| 0| length, msg_mode); 840| 0| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 0| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | ------------------ | | | Branch (53:53): [True: 0, False: 0] | | ------------------ ------------------ 841| 0| return NULL; 842| 0| } 843| | 844| 337| pos = tlv_get_element_desc( 845| 337| curr, pos, length - (uint32_t)(pos - blk), msg_mode, desc); 846| 337| if (!pos) { ------------------ | Branch (846:9): [True: 109, False: 228] ------------------ 847| 109| ogs_error("ogs_tlv_parse_block() failed[LEN:%u,MODE:%u] - parse error", ------------------ | | 36| 109|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 109| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 109|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 109| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 109|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 109| 0, __VA_ARGS__) | | ------------------ ------------------ 848| 109| length, msg_mode); 849| 109| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 218| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 109|#define OGS_LOG_DOMAIN 1 | | ------------------ | | | Branch (53:53): [True: 108, False: 1] | | ------------------ ------------------ 850| 109| ogs_tlv_free_all(root); 851| 109| return NULL; 852| 109| } 853| | 854| 4.37k| while(pos - blk < length) { ------------------ | Branch (854:11): [True: 4.24k, False: 122] ------------------ 855| 4.24k| prev = curr; 856| | 857| 4.24k| curr = ogs_tlv_get(); 858| 4.24k| if (!curr) { ------------------ | Branch (858:13): [True: 0, False: 4.24k] ------------------ 859| 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, \ | | | | ------------------ | | | | | | 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__) | | ------------------ ------------------ 860| 0| length, msg_mode); 861| 0| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 0| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | ------------------ | | | Branch (53:53): [True: 0, False: 0] | | ------------------ ------------------ 862| | 863| 0| ogs_tlv_free_all(root); 864| 0| return NULL; 865| 0| } 866| 4.24k| prev->next = curr; 867| | 868| 4.24k| pos = tlv_get_element_desc( 869| 4.24k| curr, pos, length - (uint32_t)(pos - blk), msg_mode, desc); 870| 4.24k| if (!pos) { ------------------ | Branch (870:13): [True: 106, False: 4.14k] ------------------ 871| 106| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 106|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 106| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 106|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 106| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 106|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 106| 0, __VA_ARGS__) | | ------------------ ------------------ 872| 106| length, msg_mode); 873| 106| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 212| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 106|#define OGS_LOG_DOMAIN 1 | | ------------------ | | | Branch (53:53): [True: 97, False: 9] | | ------------------ ------------------ 874| | 875| 106| ogs_tlv_free_all(root); 876| 106| return NULL; 877| 106| } 878| 4.24k| } 879| | 880| 122| if (length != (pos - blk)) { ------------------ | Branch (880:9): [True: 0, False: 122] ------------------ 881| 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, \ | | | | ------------------ | | | | | | 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__) | | ------------------ ------------------ 882| 0| length, msg_mode); 883| 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, \ | | | | ------------------ | | | | | | 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__) | | ------------------ ------------------ 884| 0| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 0| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | ------------------ | | | Branch (53:53): [True: 0, False: 0] | | ------------------ ------------------ 885| | 886| 0| ogs_tlv_free_all(root); 887| 0| return NULL; 888| 0| } 889| | 890| 122| return root; 891| 122|} ogs-tlv-msg.c:tlv_get_element_desc: 798| 4.58k|{ 799| 4.58k| uint8_t instance; 800| 4.58k| unsigned tlv_tag_pos; 801| 4.58k| uint8_t desc_index = 0; 802| 4.58k| uint32_t tlv_offset = 0; 803| 4.58k| uint16_t tlv_tag; 804| 4.58k| uint8_t tlv_mode; 805| 4.58k| static ogs_tlv_desc_t* tlv_desc; 806| | 807| 4.58k| if ((msg_mode == OGS_TLV_MODE_T2_L2 && size < 2) || size < 1) ------------------ | | 35| 9.17k|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (807:10): [True: 0, False: 4.58k] | Branch (807:44): [True: 0, False: 0] | Branch (807:57): [True: 0, False: 4.58k] ------------------ 808| 0| return NULL; 809| | 810| 4.58k| tlv_tag = parse_get_element_type(blk, msg_mode); 811| 4.58k| instance = 0; /* TODO: support instance != 0 if ever really needed by looking it up in pos */ 812| 4.58k| tlv_tag_pos = 0; /* All tags with same instance should use the same tlv_desc, so take the first one */ 813| 4.58k| tlv_desc = tlv_find_desc_by_type_inst(&desc_index, &tlv_offset, desc, tlv_tag, instance, tlv_tag_pos); 814| 4.58k| if (!tlv_desc) { ------------------ | Branch (814:9): [True: 99, False: 4.48k] ------------------ 815| 99| ogs_error("Can't parse find TLV description for type %u", tlv_tag); ------------------ | | 36| 99|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 99| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 99|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 99| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 99|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 99| 0, __VA_ARGS__) | | ------------------ ------------------ 816| 99| return NULL; 817| 99| } 818| 4.48k| tlv_mode = tlv_ctype2mode(tlv_desc->ctype, msg_mode); 819| | 820| 4.48k| if (tlv_mode == OGS_TLV_MODE_T1) ------------------ | | 36| 4.48k|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (820:9): [True: 3.13k, False: 1.35k] ------------------ 821| 3.13k| return tlv_get_element_fixed( 822| 3.13k| tlv, blk, size, tlv_mode, tlv_desc->length); 823| 1.35k| return tlv_get_element(tlv, blk, size, tlv_mode); 824| 4.48k|} ogs-tlv-msg.c:parse_get_element_type: 771| 4.58k|{ 772| 4.58k| uint16_t type; 773| | 774| 4.58k| switch(mode) { 775| 0| case OGS_TLV_MODE_T1_L1: ------------------ | | 32| 0|#define OGS_TLV_MODE_T1_L1 1 ------------------ | Branch (775:5): [True: 0, False: 4.58k] ------------------ 776| 4.58k| case OGS_TLV_MODE_T1_L2: ------------------ | | 33| 4.58k|#define OGS_TLV_MODE_T1_L2 2 ------------------ | Branch (776:5): [True: 4.58k, False: 0] ------------------ 777| 4.58k| case OGS_TLV_MODE_T1_L2_I1: ------------------ | | 34| 4.58k|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ | Branch (777:5): [True: 0, False: 4.58k] ------------------ 778| 4.58k| case OGS_TLV_MODE_T1: ------------------ | | 36| 4.58k|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (778:5): [True: 0, False: 4.58k] ------------------ 779| 4.58k| type = *pos; 780| 4.58k| break; 781| 0| case OGS_TLV_MODE_T2_L2: ------------------ | | 35| 0|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (781:5): [True: 0, False: 4.58k] ------------------ 782| 0| type = *(pos++) << 8; 783| 0| type += *(pos++); 784| 0| break; 785| 0| default: ------------------ | Branch (785:5): [True: 0, False: 4.58k] ------------------ 786| 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] | | ------------------ ------------------ 787| 0| break; 788| 4.58k| } 789| | 790| 4.58k| return type; 791| 4.58k|} ogs_tlv_get: 30| 12.4k|{ 31| 12.4k| ogs_tlv_t *tlv = NULL; 32| | 33| | /* get tlv node from node pool */ 34| 12.4k| ogs_pool_alloc(&pool, &tlv); ------------------ | | 132| 12.4k|#define ogs_pool_alloc(pool, node) do { \ | | 133| 12.4k| *(node) = NULL; \ | | 134| 12.4k| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 12.4k, False: 0] | | ------------------ | | 135| 12.4k| (pool)->avail--; \ | | 136| 12.4k| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 12.4k| (pool)->free[(pool)->head] = NULL; \ | | 138| 12.4k| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 12.4k| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 12.4k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 12.4k| } \ | | 141| 12.4k|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 12.4k] | | ------------------ ------------------ 35| | 36| | /* check for error */ 37| 12.4k| if (!tlv) { ------------------ | Branch (37:9): [True: 0, False: 12.4k] ------------------ 38| 0| ogs_error("ogs_tlv_get() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 39| 0| return NULL; 40| 0| } 41| | 42| | /* initialize tlv node */ 43| 12.4k| memset(tlv, 0, sizeof(ogs_tlv_t)); 44| 12.4k| return tlv; 45| 12.4k|} ogs_tlv_free: 48| 12.4k|{ 49| | /* free tlv node to the node pool */ 50| | ogs_pool_free(&pool, tlv); ------------------ | | 143| 12.4k|#define ogs_pool_free(pool, node) do { \ | | 144| 12.4k| if ((pool)->avail < (pool)->size) { \ | | ------------------ | | | Branch (144:9): [True: 12.4k, False: 0] | | ------------------ | | 145| 12.4k| (pool)->avail++; \ | | 146| 12.4k| (pool)->free[(pool)->tail] = (void*)(node); \ | | 147| 12.4k| (pool)->tail = ((pool)->tail + 1) % ((pool)->size); \ | | 148| 12.4k| (pool)->index[ogs_pool_index(pool, node)-1] = NULL; \ | | ------------------ | | | | 152| 12.4k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 149| 12.4k| } \ | | 150| 12.4k|} while (0) | | ------------------ | | | Branch (150:10): [Folded, False: 12.4k] | | ------------------ ------------------ 51| 12.4k|} 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| 986|{ 70| | /* free all tlv node to the node pool */ 71| 986| ogs_tlv_t *iter = root; 72| 986| ogs_tlv_t *next = NULL; 73| 13.3k| while (iter) { ------------------ | Branch (73:12): [True: 12.4k, False: 986] ------------------ 74| 12.4k| if(iter->embedded != NULL) { ------------------ | Branch (74:12): [True: 317, False: 12.0k] ------------------ 75| 317| ogs_tlv_free_all(iter->embedded); 76| 317| } 77| 12.4k| next = iter->next; 78| 12.4k| ogs_tlv_free(iter); 79| 12.4k| iter = next; 80| 12.4k| } 81| 986|} tlv_get_element: 224| 9.17k|{ 225| 9.17k| uint8_t *pos = blk; 226| 9.17k| uint32_t header_length; 227| | 228| 9.17k| tlv->mode = mode; 229| | 230| 9.17k| 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: 9.17k] ------------------ 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| 1.35k| case OGS_TLV_MODE_T1_L2: ------------------ | | 33| 1.35k|#define OGS_TLV_MODE_T1_L2 2 ------------------ | Branch (238:5): [True: 1.35k, False: 7.82k] ------------------ 239| 1.35k| header_length = 3; 240| 1.35k| if (size < header_length) ------------------ | Branch (240:13): [True: 29, False: 1.32k] ------------------ 241| 29| return NULL; 242| 1.32k| tlv->type = *(pos++); 243| 1.32k| tlv->length = *(pos++) << 8; 244| 1.32k| tlv->length += *(pos++); 245| 1.32k| break; 246| 7.82k| case OGS_TLV_MODE_T1_L2_I1: ------------------ | | 34| 7.82k|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ | Branch (246:5): [True: 7.82k, False: 1.35k] ------------------ 247| 7.82k| header_length = 4; 248| 7.82k| if (size < header_length) ------------------ | Branch (248:13): [True: 65, False: 7.76k] ------------------ 249| 65| return NULL; 250| 7.76k| tlv->type = *(pos++); 251| 7.76k| tlv->length = *(pos++) << 8; 252| 7.76k| tlv->length += *(pos++); 253| 7.76k| tlv->instance = *(pos++) & 0b00001111; 254| 7.76k| break; 255| 0| case OGS_TLV_MODE_T2_L2: ------------------ | | 35| 0|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (255:5): [True: 0, False: 9.17k] ------------------ 256| 0| header_length = 4; 257| 0| if (size < header_length) ------------------ | Branch (257:13): [True: 0, False: 0] ------------------ 258| 0| return NULL; 259| 0| tlv->type = *(pos++) << 8; 260| 0| tlv->type += *(pos++); 261| 0| tlv->length = *(pos++) << 8; 262| 0| tlv->length += *(pos++); 263| 0| break; 264| 0| case OGS_TLV_MODE_T1: ------------------ | | 36| 0|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (264:5): [True: 0, False: 9.17k] ------------------ 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: 9.17k] ------------------ 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| 9.17k| } 275| | 276| 9.08k| if (tlv->length > size - header_length) ------------------ | Branch (276:9): [True: 75, False: 9.00k] ------------------ 277| 75| return NULL; 278| | 279| 9.00k| tlv->value = pos; 280| | 281| 9.00k| return (pos + ogs_tlv_length(tlv)); ------------------ | | 67| 9.00k|#define ogs_tlv_length(pTlv) pTlv->length ------------------ 282| 9.08k|} tlv_get_element_fixed: 286| 3.13k|{ 287| 3.13k| uint8_t *pos = blk; 288| | 289| 3.13k| switch(mode) { 290| 3.13k| case OGS_TLV_MODE_T1: ------------------ | | 36| 3.13k|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (290:5): [True: 3.13k, False: 0] ------------------ 291| 3.13k| if (size < 1 || fixed_length > size - 1) ------------------ | Branch (291:13): [True: 0, False: 3.13k] | Branch (291:25): [True: 56, False: 3.07k] ------------------ 292| 56| return NULL; 293| 3.07k| tlv->type = *(pos++); 294| 3.07k| tlv->length = fixed_length; 295| 3.07k| break; 296| 0| default: ------------------ | Branch (296:5): [True: 0, False: 3.13k] ------------------ 297| 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] | | ------------------ ------------------ 298| 0| break; 299| 3.13k| } 300| | 301| 3.07k| tlv->value = pos; 302| | 303| 3.07k| return (pos + ogs_tlv_length(tlv)); ------------------ | | 67| 3.07k|#define ogs_tlv_length(pTlv) pTlv->length ------------------ 304| 3.13k|} ogs_tlv_parse_block: 463| 649|{ 464| 649| uint8_t *pos = data; 465| 649| uint8_t *blk = data; 466| | 467| 649| ogs_tlv_t *root = NULL; 468| 649| ogs_tlv_t *prev = NULL; 469| 649| ogs_tlv_t *curr = NULL; 470| | 471| 649| root = curr = ogs_tlv_get(); 472| 649| if (!curr) { ------------------ | Branch (472:9): [True: 0, False: 649] ------------------ 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| 649| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 485| 649| if (!pos) { ------------------ | Branch (485:9): [True: 74, False: 575] ------------------ 486| 74| ogs_error("ogs_tlv_parse_block() failed[LEN:%u,MODE:%u] - parse error", ------------------ | | 36| 74|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 74| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 74|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 74| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 74|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 74| 0, __VA_ARGS__) | | ------------------ ------------------ 487| 74| 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| 74| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 148| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 74|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 72, False: 2] | | ------------------ ------------------ 494| 74| ogs_tlv_free_all(root); 495| 74| return NULL; 496| 74| } 497| | 498| 7.71k| while(pos - blk < length) { ------------------ | Branch (498:11): [True: 7.17k, False: 540] ------------------ 499| 7.17k| prev = curr; 500| | 501| 7.17k| curr = ogs_tlv_get(); 502| 7.17k| if (!curr) { ------------------ | Branch (502:13): [True: 0, False: 7.17k] ------------------ 503| 0| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 504| 0| length, mode); 505| |/* 506| | * Limit hexdump size to avoid excessive logging when handling malformed 507| | * or intentionally crafted messages. This prevents log flooding and 508| | * secondary DoS effects while still providing enough data for debugging. 509| | */ 510| 0| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 0| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 0, False: 0] | | ------------------ ------------------ 511| | 512| 0| ogs_tlv_free_all(root); 513| 0| return NULL; 514| 0| } 515| 7.17k| prev->next = curr; 516| | 517| 7.17k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 518| 7.17k| if (!pos) { ------------------ | Branch (518:13): [True: 35, False: 7.14k] ------------------ 519| 35| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 35|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 35| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 35|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 35| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 35|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 35| 0, __VA_ARGS__) | | ------------------ ------------------ 520| 35| 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| 35| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 70| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 35|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 30, False: 5] | | ------------------ ------------------ 527| | 528| 35| ogs_tlv_free_all(root); 529| 35| return NULL; 530| 35| } 531| 7.17k| } 532| | 533| 540| if (length != (pos - blk)) { ------------------ | Branch (533:9): [True: 0, False: 540] ------------------ 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| 540| return root; 543| 540|} ogs_tlv_parse_embedded_block: 546| 336|{ 547| 336| tlv->embedded = ogs_tlv_parse_block(tlv->length, tlv->value, mode); 548| | 549| 336| return tlv->embedded; 550| 336|} ogs_gtp1_parse_msg: 2283| 350|{ 2284| 350| int rv = OGS_ERROR; ------------------ | | 78| 350|#define OGS_ERROR -1 ------------------ 2285| 350| ogs_gtp1_header_t *h = NULL; 2286| 350| uint16_t size = 0; 2287| | 2288| 350| ogs_assert(gtp1_message); ------------------ | | 113| 350| do { \ | | 114| 350| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 350|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 350, False: 0] | | | | ------------------ | | ------------------ | | 115| 350| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 350| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 350] | | ------------------ ------------------ 2289| 350| ogs_assert(pkbuf); ------------------ | | 113| 350| do { \ | | 114| 350| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 350|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 350, False: 0] | | | | ------------------ | | ------------------ | | 115| 350| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 350| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 350] | | ------------------ ------------------ 2290| 350| ogs_assert(pkbuf->len); ------------------ | | 113| 350| do { \ | | 114| 350| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 350|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 350, False: 0] | | | | ------------------ | | ------------------ | | 115| 350| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 350| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 350] | | ------------------ ------------------ 2291| | 2292| 350| h = (ogs_gtp1_header_t *)pkbuf->data; 2293| 350| ogs_assert(h); ------------------ | | 113| 350| do { \ | | 114| 350| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 350|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 350, False: 0] | | | | ------------------ | | ------------------ | | 115| 350| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 350| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 350] | | ------------------ ------------------ 2294| | 2295| 350| memset(gtp1_message, 0, sizeof(ogs_gtp1_message_t)); 2296| | 2297| 350| if (h->e || h->s || h->pn) ------------------ | Branch (2297:9): [True: 5, False: 345] | Branch (2297:17): [True: 5, False: 340] | Branch (2297:25): [True: 2, False: 338] ------------------ 2298| 12| size = OGS_GTPV1C_HEADER_LEN; ------------------ | | 42| 12|#define OGS_GTPV1C_HEADER_LEN 12 ------------------ 2299| 338| else 2300| 338| size = OGS_GTPV1C_HEADER_LEN - 4; ------------------ | | 42| 338|#define OGS_GTPV1C_HEADER_LEN 12 ------------------ 2301| | 2302| 350| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2302:9): [True: 6, False: 344] ------------------ 2303| 6| ogs_error("ogs_pkbuf_pull() failed [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 6|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2304| 6| return OGS_ERROR; ------------------ | | 78| 6|#define OGS_ERROR -1 ------------------ 2305| 6| } 2306| 344| memcpy(>p1_message->h, pkbuf->data - size, size); 2307| | 2308| 344| gtp1_message->h.teid = be32toh(gtp1_message->h.teid); 2309| | 2310| 344| if (pkbuf->len == 0) { ------------------ | Branch (2310:9): [True: 1, False: 343] ------------------ 2311| 1| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 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, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 1| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1] | | ------------------ ------------------ 2312| 1| return OGS_OK; ------------------ | | 77| 1|#define OGS_OK 0 ------------------ 2313| 1| } 2314| | 2315| 343| switch(gtp1_message->h.type) { 2316| 1| case OGS_GTP1_ECHO_REQUEST_TYPE: ------------------ | | 83| 1|#define OGS_GTP1_ECHO_REQUEST_TYPE 1 ------------------ | Branch (2316:5): [True: 1, False: 342] ------------------ 2317| 1| break; 2318| 1| case OGS_GTP1_ECHO_RESPONSE_TYPE: ------------------ | | 84| 1|#define OGS_GTP1_ECHO_RESPONSE_TYPE 2 ------------------ | Branch (2318:5): [True: 1, False: 342] ------------------ 2319| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->echo_response, 2320| 1| &ogs_gtp1_tlv_desc_echo_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2321| 1| break; 2322| 120| case OGS_GTP1_CREATE_PDP_CONTEXT_REQUEST_TYPE: ------------------ | | 90| 120|#define OGS_GTP1_CREATE_PDP_CONTEXT_REQUEST_TYPE 16 ------------------ | Branch (2322:5): [True: 120, False: 223] ------------------ 2323| 120| rv = ogs_tlv_parse_msg_desc(>p1_message->create_pdp_context_request, 2324| 120| &ogs_gtp1_tlv_desc_create_pdp_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 120|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2325| 120| break; 2326| 46| case OGS_GTP1_CREATE_PDP_CONTEXT_RESPONSE_TYPE: ------------------ | | 91| 46|#define OGS_GTP1_CREATE_PDP_CONTEXT_RESPONSE_TYPE 17 ------------------ | Branch (2326:5): [True: 46, False: 297] ------------------ 2327| 46| rv = ogs_tlv_parse_msg_desc(>p1_message->create_pdp_context_response, 2328| 46| &ogs_gtp1_tlv_desc_create_pdp_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 46|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2329| 46| break; 2330| 1| case OGS_GTP1_UPDATE_PDP_CONTEXT_REQUEST_TYPE: ------------------ | | 92| 1|#define OGS_GTP1_UPDATE_PDP_CONTEXT_REQUEST_TYPE 18 ------------------ | Branch (2330:5): [True: 1, False: 342] ------------------ 2331| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->update_pdp_context_request, 2332| 1| &ogs_gtp1_tlv_desc_update_pdp_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2333| 1| break; 2334| 12| case OGS_GTP1_UPDATE_PDP_CONTEXT_RESPONSE_TYPE: ------------------ | | 93| 12|#define OGS_GTP1_UPDATE_PDP_CONTEXT_RESPONSE_TYPE 19 ------------------ | Branch (2334:5): [True: 12, False: 331] ------------------ 2335| 12| rv = ogs_tlv_parse_msg_desc(>p1_message->update_pdp_context_response, 2336| 12| &ogs_gtp1_tlv_desc_update_pdp_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 12|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2337| 12| break; 2338| 5| case OGS_GTP1_DELETE_PDP_CONTEXT_REQUEST_TYPE: ------------------ | | 94| 5|#define OGS_GTP1_DELETE_PDP_CONTEXT_REQUEST_TYPE 20 ------------------ | Branch (2338:5): [True: 5, False: 338] ------------------ 2339| 5| rv = ogs_tlv_parse_msg_desc(>p1_message->delete_pdp_context_request, 2340| 5| &ogs_gtp1_tlv_desc_delete_pdp_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 5|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2341| 5| break; 2342| 1| case OGS_GTP1_DELETE_PDP_CONTEXT_RESPONSE_TYPE: ------------------ | | 95| 1|#define OGS_GTP1_DELETE_PDP_CONTEXT_RESPONSE_TYPE 21 ------------------ | Branch (2342:5): [True: 1, False: 342] ------------------ 2343| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->delete_pdp_context_response, 2344| 1| &ogs_gtp1_tlv_desc_delete_pdp_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2345| 1| break; 2346| 1| case OGS_GTP1_INITIATE_PDP_CONTEXT_ACTIVATION_REQUEST_TYPE: ------------------ | | 96| 1|#define OGS_GTP1_INITIATE_PDP_CONTEXT_ACTIVATION_REQUEST_TYPE 22 ------------------ | Branch (2346:5): [True: 1, False: 342] ------------------ 2347| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->initiate_pdp_context_activation_request, 2348| 1| &ogs_gtp1_tlv_desc_initiate_pdp_context_activation_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2349| 1| break; 2350| 1| case OGS_GTP1_INITIATE_PDP_CONTEXT_ACTIVATION_RESPONSE_TYPE: ------------------ | | 97| 1|#define OGS_GTP1_INITIATE_PDP_CONTEXT_ACTIVATION_RESPONSE_TYPE 23 ------------------ | Branch (2350:5): [True: 1, False: 342] ------------------ 2351| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->initiate_pdp_context_activation_response, 2352| 1| &ogs_gtp1_tlv_desc_initiate_pdp_context_activation_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2353| 1| break; 2354| 3| case OGS_GTP1_PDU_NOTIFICATION_REQUEST_TYPE: ------------------ | | 99| 3|#define OGS_GTP1_PDU_NOTIFICATION_REQUEST_TYPE 27 ------------------ | Branch (2354:5): [True: 3, False: 340] ------------------ 2355| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_request, 2356| 3| &ogs_gtp1_tlv_desc_pdu_notification_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2357| 3| break; 2358| 1| case OGS_GTP1_PDU_NOTIFICATION_RESPONSE_TYPE: ------------------ | | 100| 1|#define OGS_GTP1_PDU_NOTIFICATION_RESPONSE_TYPE 28 ------------------ | Branch (2358:5): [True: 1, False: 342] ------------------ 2359| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_response, 2360| 1| &ogs_gtp1_tlv_desc_pdu_notification_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2361| 1| break; 2362| 1| case OGS_GTP1_PDU_NOTIFICATION_REJECT_REQUEST_TYPE: ------------------ | | 101| 1|#define OGS_GTP1_PDU_NOTIFICATION_REJECT_REQUEST_TYPE 29 ------------------ | Branch (2362:5): [True: 1, False: 342] ------------------ 2363| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_reject_request, 2364| 1| &ogs_gtp1_tlv_desc_pdu_notification_reject_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2365| 1| break; 2366| 1| case OGS_GTP1_PDU_NOTIFICATION_REJECT_RESPONSE_TYPE: ------------------ | | 102| 1|#define OGS_GTP1_PDU_NOTIFICATION_REJECT_RESPONSE_TYPE 30 ------------------ | Branch (2366:5): [True: 1, False: 342] ------------------ 2367| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_reject_response, 2368| 1| &ogs_gtp1_tlv_desc_pdu_notification_reject_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2369| 1| break; 2370| 1| case OGS_GTP1_SUPPORTED_EXTENSION_HEADERS_NOTIFICATION_TYPE: ------------------ | | 103| 1|#define OGS_GTP1_SUPPORTED_EXTENSION_HEADERS_NOTIFICATION_TYPE 31 ------------------ | Branch (2370:5): [True: 1, False: 342] ------------------ 2371| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->supported_extension_headers_notification, 2372| 1| &ogs_gtp1_tlv_desc_supported_extension_headers_notification, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2373| 1| break; 2374| 5| case OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_REQUEST_TYPE: ------------------ | | 104| 5|#define OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_REQUEST_TYPE 32 ------------------ | Branch (2374:5): [True: 5, False: 338] ------------------ 2375| 5| rv = ogs_tlv_parse_msg_desc(>p1_message->send_routeing_information_for_gprs_request, 2376| 5| &ogs_gtp1_tlv_desc_send_routeing_information_for_gprs_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 5|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2377| 5| break; 2378| 25| case OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_RESPONSE_TYPE: ------------------ | | 105| 25|#define OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_RESPONSE_TYPE 33 ------------------ | Branch (2378:5): [True: 25, False: 318] ------------------ 2379| 25| rv = ogs_tlv_parse_msg_desc(>p1_message->send_routeing_information_for_gprs_response, 2380| 25| &ogs_gtp1_tlv_desc_send_routeing_information_for_gprs_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 25|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2381| 25| break; 2382| 1| case OGS_GTP1_FAILURE_REPORT_REQUEST_TYPE: ------------------ | | 106| 1|#define OGS_GTP1_FAILURE_REPORT_REQUEST_TYPE 34 ------------------ | Branch (2382:5): [True: 1, False: 342] ------------------ 2383| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->failure_report_request, 2384| 1| &ogs_gtp1_tlv_desc_failure_report_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2385| 1| break; 2386| 3| case OGS_GTP1_FAILURE_REPORT_RESPONSE_TYPE: ------------------ | | 107| 3|#define OGS_GTP1_FAILURE_REPORT_RESPONSE_TYPE 35 ------------------ | Branch (2386:5): [True: 3, False: 340] ------------------ 2387| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->failure_report_response, 2388| 3| &ogs_gtp1_tlv_desc_failure_report_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2389| 3| break; 2390| 1| case OGS_GTP1_NOTE_MS_GPRS_PRESENT_REQUEST_TYPE: ------------------ | | 108| 1|#define OGS_GTP1_NOTE_MS_GPRS_PRESENT_REQUEST_TYPE 36 ------------------ | Branch (2390:5): [True: 1, False: 342] ------------------ 2391| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->note_ms_gprs_present_request, 2392| 1| &ogs_gtp1_tlv_desc_note_ms_gprs_present_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2393| 1| break; 2394| 2| case OGS_GTP1_NOTE_MS_GPRS_PRESENT_RESPONSE_TYPE: ------------------ | | 109| 2|#define OGS_GTP1_NOTE_MS_GPRS_PRESENT_RESPONSE_TYPE 37 ------------------ | Branch (2394:5): [True: 2, False: 341] ------------------ 2395| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->note_ms_gprs_present_response, 2396| 2| &ogs_gtp1_tlv_desc_note_ms_gprs_present_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2397| 2| break; 2398| 3| case OGS_GTP1_IDENTIFICATION_REQUEST_TYPE: ------------------ | | 110| 3|#define OGS_GTP1_IDENTIFICATION_REQUEST_TYPE 48 ------------------ | Branch (2398:5): [True: 3, False: 340] ------------------ 2399| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->identification_request, 2400| 3| &ogs_gtp1_tlv_desc_identification_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2401| 3| break; 2402| 10| case OGS_GTP1_IDENTIFICATION_RESPONSE_TYPE: ------------------ | | 111| 10|#define OGS_GTP1_IDENTIFICATION_RESPONSE_TYPE 49 ------------------ | Branch (2402:5): [True: 10, False: 333] ------------------ 2403| 10| rv = ogs_tlv_parse_msg_desc(>p1_message->identification_response, 2404| 10| &ogs_gtp1_tlv_desc_identification_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 10|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2405| 10| break; 2406| 13| case OGS_GTP1_SGSN_CONTEXT_REQUEST_TYPE: ------------------ | | 112| 13|#define OGS_GTP1_SGSN_CONTEXT_REQUEST_TYPE 50 ------------------ | Branch (2406:5): [True: 13, False: 330] ------------------ 2407| 13| rv = ogs_tlv_parse_msg_desc(>p1_message->sgsn_context_request, 2408| 13| &ogs_gtp1_tlv_desc_sgsn_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 13|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2409| 13| break; 2410| 24| case OGS_GTP1_SGSN_CONTEXT_RESPONSE_TYPE: ------------------ | | 113| 24|#define OGS_GTP1_SGSN_CONTEXT_RESPONSE_TYPE 51 ------------------ | Branch (2410:5): [True: 24, False: 319] ------------------ 2411| 24| rv = ogs_tlv_parse_msg_desc(>p1_message->sgsn_context_response, 2412| 24| &ogs_gtp1_tlv_desc_sgsn_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 24|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2413| 24| break; 2414| 1| case OGS_GTP1_SGSN_CONTEXT_ACKNOWLEDGE_TYPE: ------------------ | | 114| 1|#define OGS_GTP1_SGSN_CONTEXT_ACKNOWLEDGE_TYPE 52 ------------------ | Branch (2414:5): [True: 1, False: 342] ------------------ 2415| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->sgsn_context_acknowledge, 2416| 1| &ogs_gtp1_tlv_desc_sgsn_context_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2417| 1| break; 2418| 2| case OGS_GTP1_FORWARD_RELOCATION_REQUEST_TYPE: ------------------ | | 115| 2|#define OGS_GTP1_FORWARD_RELOCATION_REQUEST_TYPE 53 ------------------ | Branch (2418:5): [True: 2, False: 341] ------------------ 2419| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_relocation_request, 2420| 2| &ogs_gtp1_tlv_desc_forward_relocation_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2421| 2| break; 2422| 1| case OGS_GTP1_FORWARD_RELOCATION_RESPONSE_TYPE: ------------------ | | 116| 1|#define OGS_GTP1_FORWARD_RELOCATION_RESPONSE_TYPE 54 ------------------ | Branch (2422:5): [True: 1, False: 342] ------------------ 2423| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_relocation_response, 2424| 1| &ogs_gtp1_tlv_desc_forward_relocation_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2425| 1| break; 2426| 1| case OGS_GTP1_FORWARD_RELOCATION_COMPLETE_TYPE: ------------------ | | 117| 1|#define OGS_GTP1_FORWARD_RELOCATION_COMPLETE_TYPE 55 ------------------ | Branch (2426:5): [True: 1, False: 342] ------------------ 2427| 1| break; 2428| 1| case OGS_GTP1_RELOCATION_CANCEL_REQUEST_TYPE: ------------------ | | 118| 1|#define OGS_GTP1_RELOCATION_CANCEL_REQUEST_TYPE 56 ------------------ | Branch (2428:5): [True: 1, False: 342] ------------------ 2429| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->relocation_cancel_request, 2430| 1| &ogs_gtp1_tlv_desc_relocation_cancel_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2431| 1| break; 2432| 2| case OGS_GTP1_RELOCATION_CANCEL_RESPONSE_TYPE: ------------------ | | 119| 2|#define OGS_GTP1_RELOCATION_CANCEL_RESPONSE_TYPE 57 ------------------ | Branch (2432:5): [True: 2, False: 341] ------------------ 2433| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->relocation_cancel_response, 2434| 2| &ogs_gtp1_tlv_desc_relocation_cancel_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2435| 2| break; 2436| 1| case OGS_GTP1_FORWARD_SRNS_CONTEXT_TYPE: ------------------ | | 120| 1|#define OGS_GTP1_FORWARD_SRNS_CONTEXT_TYPE 58 ------------------ | Branch (2436:5): [True: 1, False: 342] ------------------ 2437| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_srns_context, 2438| 1| &ogs_gtp1_tlv_desc_forward_srns_context, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2439| 1| break; 2440| 1| case OGS_GTP1_FORWARD_RELOCATION_COMPLETE_ACKNOWLEDGE_TYPE: ------------------ | | 121| 1|#define OGS_GTP1_FORWARD_RELOCATION_COMPLETE_ACKNOWLEDGE_TYPE 59 ------------------ | Branch (2440:5): [True: 1, False: 342] ------------------ 2441| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_relocation_complete_acknowledge, 2442| 1| &ogs_gtp1_tlv_desc_forward_relocation_complete_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2443| 1| break; 2444| 1| case OGS_GTP1_FORWARD_SRNS_CONTEXT_ACKNOWLEDGE_TYPE: ------------------ | | 122| 1|#define OGS_GTP1_FORWARD_SRNS_CONTEXT_ACKNOWLEDGE_TYPE 60 ------------------ | Branch (2444:5): [True: 1, False: 342] ------------------ 2445| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_srns_context_acknowledge, 2446| 1| &ogs_gtp1_tlv_desc_forward_srns_context_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2447| 1| break; 2448| 2| case OGS_GTP1_UE_REGISTRATION_QUERY_REQUEST_TYPE: ------------------ | | 123| 2|#define OGS_GTP1_UE_REGISTRATION_QUERY_REQUEST_TYPE 61 ------------------ | Branch (2448:5): [True: 2, False: 341] ------------------ 2449| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->ue_registration_query_request, 2450| 2| &ogs_gtp1_tlv_desc_ue_registration_query_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2451| 2| break; 2452| 1| case OGS_GTP1_UE_REGISTRATION_QUERY_RESPONSE_TYPE: ------------------ | | 124| 1|#define OGS_GTP1_UE_REGISTRATION_QUERY_RESPONSE_TYPE 62 ------------------ | Branch (2452:5): [True: 1, False: 342] ------------------ 2453| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->ue_registration_query_response, 2454| 1| &ogs_gtp1_tlv_desc_ue_registration_query_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2455| 1| break; 2456| 1| case OGS_GTP1_RAN_INFORMATION_RELAY_TYPE: ------------------ | | 125| 1|#define OGS_GTP1_RAN_INFORMATION_RELAY_TYPE 70 ------------------ | Branch (2456:5): [True: 1, False: 342] ------------------ 2457| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->ran_information_relay, 2458| 1| &ogs_gtp1_tlv_desc_ran_information_relay, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2459| 1| break; 2460| 2| case OGS_GTP1_MBMS_NOTIFICATION_REQUEST_TYPE: ------------------ | | 126| 2|#define OGS_GTP1_MBMS_NOTIFICATION_REQUEST_TYPE 96 ------------------ | Branch (2460:5): [True: 2, False: 341] ------------------ 2461| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_notification_request, 2462| 2| &ogs_gtp1_tlv_desc_mbms_notification_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2463| 2| break; 2464| 1| case OGS_GTP1_MBMS_NOTIFICATION_RESPONSE_TYPE: ------------------ | | 127| 1|#define OGS_GTP1_MBMS_NOTIFICATION_RESPONSE_TYPE 97 ------------------ | Branch (2464:5): [True: 1, False: 342] ------------------ 2465| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_notification_response, 2466| 1| &ogs_gtp1_tlv_desc_mbms_notification_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2467| 1| break; 2468| 5| case OGS_GTP1_MBMS_NOTIFICATION_REJECT_REQUEST_TYPE: ------------------ | | 128| 5|#define OGS_GTP1_MBMS_NOTIFICATION_REJECT_REQUEST_TYPE 98 ------------------ | Branch (2468:5): [True: 5, False: 338] ------------------ 2469| 5| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_notification_reject_request, 2470| 5| &ogs_gtp1_tlv_desc_mbms_notification_reject_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 5|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2471| 5| break; 2472| 2| case OGS_GTP1_MBMS_NOTIFICATION_REJECT_RESPONSE_TYPE: ------------------ | | 129| 2|#define OGS_GTP1_MBMS_NOTIFICATION_REJECT_RESPONSE_TYPE 99 ------------------ | Branch (2472:5): [True: 2, False: 341] ------------------ 2473| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_notification_reject_response, 2474| 2| &ogs_gtp1_tlv_desc_mbms_notification_reject_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2475| 2| break; 2476| 2| case OGS_GTP1_CREATE_MBMS_CONTEXT_REQUEST_TYPE: ------------------ | | 130| 2|#define OGS_GTP1_CREATE_MBMS_CONTEXT_REQUEST_TYPE 100 ------------------ | Branch (2476:5): [True: 2, False: 341] ------------------ 2477| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->create_mbms_context_request, 2478| 2| &ogs_gtp1_tlv_desc_create_mbms_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2479| 2| break; 2480| 4| case OGS_GTP1_CREATE_MBMS_CONTEXT_RESPONSE_TYPE: ------------------ | | 131| 4|#define OGS_GTP1_CREATE_MBMS_CONTEXT_RESPONSE_TYPE 101 ------------------ | Branch (2480:5): [True: 4, False: 339] ------------------ 2481| 4| rv = ogs_tlv_parse_msg_desc(>p1_message->create_mbms_context_response, 2482| 4| &ogs_gtp1_tlv_desc_create_mbms_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 4|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2483| 4| break; 2484| 2| case OGS_GTP1_UPDATE_MBMS_CONTEXT_REQUEST_TYPE: ------------------ | | 132| 2|#define OGS_GTP1_UPDATE_MBMS_CONTEXT_REQUEST_TYPE 102 ------------------ | Branch (2484:5): [True: 2, False: 341] ------------------ 2485| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->update_mbms_context_request, 2486| 2| &ogs_gtp1_tlv_desc_update_mbms_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2487| 2| break; 2488| 4| case OGS_GTP1_UPDATE_MBMS_CONTEXT_RESPONSE_TYPE: ------------------ | | 133| 4|#define OGS_GTP1_UPDATE_MBMS_CONTEXT_RESPONSE_TYPE 103 ------------------ | Branch (2488:5): [True: 4, False: 339] ------------------ 2489| 4| rv = ogs_tlv_parse_msg_desc(>p1_message->update_mbms_context_response, 2490| 4| &ogs_gtp1_tlv_desc_update_mbms_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 4|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2491| 4| break; 2492| 1| case OGS_GTP1_DELETE_MBMS_CONTEXT_REQUEST_TYPE: ------------------ | | 134| 1|#define OGS_GTP1_DELETE_MBMS_CONTEXT_REQUEST_TYPE 104 ------------------ | Branch (2492:5): [True: 1, False: 342] ------------------ 2493| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->delete_mbms_context_request, 2494| 1| &ogs_gtp1_tlv_desc_delete_mbms_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2495| 1| break; 2496| 2| case OGS_GTP1_DELETE_MBMS_CONTEXT_RESPONSE_TYPE: ------------------ | | 135| 2|#define OGS_GTP1_DELETE_MBMS_CONTEXT_RESPONSE_TYPE 105 ------------------ | Branch (2496:5): [True: 2, False: 341] ------------------ 2497| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->delete_mbms_context_response, 2498| 2| &ogs_gtp1_tlv_desc_delete_mbms_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2499| 2| break; 2500| 1| case OGS_GTP1_MBMS_REGISTRATION_REQUEST_TYPE: ------------------ | | 136| 1|#define OGS_GTP1_MBMS_REGISTRATION_REQUEST_TYPE 112 ------------------ | Branch (2500:5): [True: 1, False: 342] ------------------ 2501| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_registration_request, 2502| 1| &ogs_gtp1_tlv_desc_mbms_registration_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2503| 1| break; 2504| 1| case OGS_GTP1_MBMS_REGISTRATION_RESPONSE_TYPE: ------------------ | | 137| 1|#define OGS_GTP1_MBMS_REGISTRATION_RESPONSE_TYPE 113 ------------------ | Branch (2504:5): [True: 1, False: 342] ------------------ 2505| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_registration_response, 2506| 1| &ogs_gtp1_tlv_desc_mbms_registration_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2507| 1| break; 2508| 2| case OGS_GTP1_MBMS_DE_REGISTRATION_REQUEST_TYPE: ------------------ | | 138| 2|#define OGS_GTP1_MBMS_DE_REGISTRATION_REQUEST_TYPE 114 ------------------ | Branch (2508:5): [True: 2, False: 341] ------------------ 2509| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_de_registration_request, 2510| 2| &ogs_gtp1_tlv_desc_mbms_de_registration_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2511| 2| break; 2512| 1| case OGS_GTP1_MBMS_DE_REGISTRATION_RESPONSE_TYPE: ------------------ | | 139| 1|#define OGS_GTP1_MBMS_DE_REGISTRATION_RESPONSE_TYPE 115 ------------------ | Branch (2512:5): [True: 1, False: 342] ------------------ 2513| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_de_registration_response, 2514| 1| &ogs_gtp1_tlv_desc_mbms_de_registration_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2515| 1| break; 2516| 2| case OGS_GTP1_MBMS_SESSION_START_REQUEST_TYPE: ------------------ | | 140| 2|#define OGS_GTP1_MBMS_SESSION_START_REQUEST_TYPE 116 ------------------ | Branch (2516:5): [True: 2, False: 341] ------------------ 2517| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_start_request, 2518| 2| &ogs_gtp1_tlv_desc_mbms_session_start_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2519| 2| break; 2520| 1| case OGS_GTP1_MBMS_SESSION_START_RESPONSE_TYPE: ------------------ | | 141| 1|#define OGS_GTP1_MBMS_SESSION_START_RESPONSE_TYPE 117 ------------------ | Branch (2520:5): [True: 1, False: 342] ------------------ 2521| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_start_response, 2522| 1| &ogs_gtp1_tlv_desc_mbms_session_start_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2523| 1| break; 2524| 3| case OGS_GTP1_MBMS_SESSION_STOP_REQUEST_TYPE: ------------------ | | 142| 3|#define OGS_GTP1_MBMS_SESSION_STOP_REQUEST_TYPE 118 ------------------ | Branch (2524:5): [True: 3, False: 340] ------------------ 2525| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_stop_request, 2526| 3| &ogs_gtp1_tlv_desc_mbms_session_stop_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2527| 3| break; 2528| 1| case OGS_GTP1_MBMS_SESSION_STOP_RESPONSE_TYPE: ------------------ | | 143| 1|#define OGS_GTP1_MBMS_SESSION_STOP_RESPONSE_TYPE 119 ------------------ | Branch (2528:5): [True: 1, False: 342] ------------------ 2529| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_stop_response, 2530| 1| &ogs_gtp1_tlv_desc_mbms_session_stop_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2531| 1| break; 2532| 1| case OGS_GTP1_MBMS_SESSION_UPDATE_REQUEST_TYPE: ------------------ | | 144| 1|#define OGS_GTP1_MBMS_SESSION_UPDATE_REQUEST_TYPE 120 ------------------ | Branch (2532:5): [True: 1, False: 342] ------------------ 2533| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_update_request, 2534| 1| &ogs_gtp1_tlv_desc_mbms_session_update_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2535| 1| break; 2536| 3| case OGS_GTP1_MBMS_SESSION_UPDATE_RESPONSE_TYPE: ------------------ | | 145| 3|#define OGS_GTP1_MBMS_SESSION_UPDATE_RESPONSE_TYPE 121 ------------------ | Branch (2536:5): [True: 3, False: 340] ------------------ 2537| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_update_response, 2538| 3| &ogs_gtp1_tlv_desc_mbms_session_update_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2539| 3| break; 2540| 4| default: ------------------ | Branch (2540:5): [True: 4, False: 339] ------------------ 2541| 4| ogs_warn("Not implemented(type:%d)", gtp1_message->h.type); ------------------ | | 37| 4|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 4|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2542| 4| break; 2543| 343| } 2544| | 2545| 343| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 343| do { \ | | 114| 343| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 343|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 343, False: 0] | | | | ------------------ | | ------------------ | | 115| 343| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 343| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 343] | | ------------------ ------------------ 2546| | 2547| 343| return rv; 2548| 343|} ogs_gtp2_parse_msg: 2910| 332|{ 2911| 332| int rv = OGS_ERROR; ------------------ | | 78| 332|#define OGS_ERROR -1 ------------------ 2912| 332| ogs_gtp2_header_t *h = NULL; 2913| 332| uint16_t size = 0; 2914| | 2915| 332| ogs_assert(gtp2_message); ------------------ | | 113| 332| do { \ | | 114| 332| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 332|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 332, False: 0] | | | | ------------------ | | ------------------ | | 115| 332| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 332| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 332] | | ------------------ ------------------ 2916| 332| ogs_assert(pkbuf); ------------------ | | 113| 332| do { \ | | 114| 332| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 332|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 332, False: 0] | | | | ------------------ | | ------------------ | | 115| 332| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 332| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 332] | | ------------------ ------------------ 2917| 332| ogs_assert(pkbuf->len); ------------------ | | 113| 332| do { \ | | 114| 332| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 332|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 332, False: 0] | | | | ------------------ | | ------------------ | | 115| 332| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 332| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 332] | | ------------------ ------------------ 2918| | 2919| 332| h = (ogs_gtp2_header_t *)pkbuf->data; 2920| 332| ogs_assert(h); ------------------ | | 113| 332| do { \ | | 114| 332| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 332|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 332, False: 0] | | | | ------------------ | | ------------------ | | 115| 332| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 332| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 332] | | ------------------ ------------------ 2921| | 2922| 332| memset(gtp2_message, 0, sizeof(ogs_gtp2_message_t)); 2923| | 2924| 332| if (h->teid_presence) ------------------ | Branch (2924:9): [True: 11, False: 321] ------------------ 2925| 11| size = OGS_GTPV2C_HEADER_LEN; ------------------ | | 40| 11|#define OGS_GTPV2C_HEADER_LEN 12 ------------------ 2926| 321| else 2927| 321| size = OGS_GTPV2C_HEADER_LEN-OGS_GTP2_TEID_LEN; ------------------ | | 40| 321|#define OGS_GTPV2C_HEADER_LEN 12 ------------------ size = OGS_GTPV2C_HEADER_LEN-OGS_GTP2_TEID_LEN; ------------------ | | 41| 321|#define OGS_GTP2_TEID_LEN 4 ------------------ 2928| | 2929| 332| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2929:9): [True: 8, False: 324] ------------------ 2930| 8| ogs_error("ogs_pkbuf_pull() failed [len:%d]", pkbuf->len); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 8|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2931| 8| return OGS_ERROR; ------------------ | | 78| 8|#define OGS_ERROR -1 ------------------ 2932| 8| } 2933| 324| memcpy(>p2_message->h, pkbuf->data - size, size); 2934| | 2935| 324| if (h->teid_presence) ------------------ | Branch (2935:9): [True: 7, False: 317] ------------------ 2936| 7| gtp2_message->h.teid = be32toh(gtp2_message->h.teid); 2937| | 2938| 324| if (pkbuf->len == 0) { ------------------ | Branch (2938:9): [True: 2, False: 322] ------------------ 2939| 2| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 2| do { \ | | 114| 2| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 115| 2| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 2| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2] | | ------------------ ------------------ 2940| 2| return OGS_OK; ------------------ | | 77| 2|#define OGS_OK 0 ------------------ 2941| 2| } 2942| | 2943| 322| switch(gtp2_message->h.type) { 2944| 15| case OGS_GTP2_ECHO_REQUEST_TYPE: ------------------ | | 83| 15|#define OGS_GTP2_ECHO_REQUEST_TYPE 1 ------------------ | Branch (2944:5): [True: 15, False: 307] ------------------ 2945| 15| rv = ogs_tlv_parse_msg(>p2_message->echo_request, 2946| 15| &ogs_gtp2_tlv_desc_echo_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 15|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2947| 15| break; 2948| 22| case OGS_GTP2_ECHO_RESPONSE_TYPE: ------------------ | | 84| 22|#define OGS_GTP2_ECHO_RESPONSE_TYPE 2 ------------------ | Branch (2948:5): [True: 22, False: 300] ------------------ 2949| 22| rv = ogs_tlv_parse_msg(>p2_message->echo_response, 2950| 22| &ogs_gtp2_tlv_desc_echo_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 22|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2951| 22| break; 2952| 59| case OGS_GTP2_CREATE_SESSION_REQUEST_TYPE: ------------------ | | 86| 59|#define OGS_GTP2_CREATE_SESSION_REQUEST_TYPE 32 ------------------ | Branch (2952:5): [True: 59, False: 263] ------------------ 2953| 59| rv = ogs_tlv_parse_msg(>p2_message->create_session_request, 2954| 59| &ogs_gtp2_tlv_desc_create_session_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 59|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2955| 59| break; 2956| 7| case OGS_GTP2_CREATE_SESSION_RESPONSE_TYPE: ------------------ | | 87| 7|#define OGS_GTP2_CREATE_SESSION_RESPONSE_TYPE 33 ------------------ | Branch (2956:5): [True: 7, False: 315] ------------------ 2957| 7| rv = ogs_tlv_parse_msg(>p2_message->create_session_response, 2958| 7| &ogs_gtp2_tlv_desc_create_session_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 7|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2959| 7| break; 2960| 52| case OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE: ------------------ | | 88| 52|#define OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE 34 ------------------ | Branch (2960:5): [True: 52, False: 270] ------------------ 2961| 52| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_request, 2962| 52| &ogs_gtp2_tlv_desc_modify_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 52|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2963| 52| break; 2964| 86| case OGS_GTP2_MODIFY_BEARER_RESPONSE_TYPE: ------------------ | | 89| 86|#define OGS_GTP2_MODIFY_BEARER_RESPONSE_TYPE 35 ------------------ | Branch (2964:5): [True: 86, False: 236] ------------------ 2965| 86| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_response, 2966| 86| &ogs_gtp2_tlv_desc_modify_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 86|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2967| 86| break; 2968| 1| case OGS_GTP2_DELETE_SESSION_REQUEST_TYPE: ------------------ | | 90| 1|#define OGS_GTP2_DELETE_SESSION_REQUEST_TYPE 36 ------------------ | Branch (2968:5): [True: 1, False: 321] ------------------ 2969| 1| rv = ogs_tlv_parse_msg(>p2_message->delete_session_request, 2970| 1| &ogs_gtp2_tlv_desc_delete_session_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2971| 1| break; 2972| 1| case OGS_GTP2_DELETE_SESSION_RESPONSE_TYPE: ------------------ | | 91| 1|#define OGS_GTP2_DELETE_SESSION_RESPONSE_TYPE 37 ------------------ | Branch (2972:5): [True: 1, False: 321] ------------------ 2973| 1| rv = ogs_tlv_parse_msg(>p2_message->delete_session_response, 2974| 1| &ogs_gtp2_tlv_desc_delete_session_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2975| 1| break; 2976| 2| case OGS_GTP2_MODIFY_BEARER_COMMAND_TYPE: ------------------ | | 96| 2|#define OGS_GTP2_MODIFY_BEARER_COMMAND_TYPE 64 ------------------ | Branch (2976:5): [True: 2, False: 320] ------------------ 2977| 2| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_command, 2978| 2| &ogs_gtp2_tlv_desc_modify_bearer_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2979| 2| break; 2980| 1| case OGS_GTP2_MODIFY_BEARER_FAILURE_INDICATION_TYPE: ------------------ | | 97| 1|#define OGS_GTP2_MODIFY_BEARER_FAILURE_INDICATION_TYPE 65 ------------------ | Branch (2980:5): [True: 1, False: 321] ------------------ 2981| 1| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_failure_indication, 2982| 1| &ogs_gtp2_tlv_desc_modify_bearer_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2983| 1| break; 2984| 1| case OGS_GTP2_DELETE_BEARER_COMMAND_TYPE: ------------------ | | 98| 1|#define OGS_GTP2_DELETE_BEARER_COMMAND_TYPE 66 ------------------ | Branch (2984:5): [True: 1, False: 321] ------------------ 2985| 1| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_command, 2986| 1| &ogs_gtp2_tlv_desc_delete_bearer_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2987| 1| break; 2988| 3| case OGS_GTP2_DELETE_BEARER_FAILURE_INDICATION_TYPE: ------------------ | | 99| 3|#define OGS_GTP2_DELETE_BEARER_FAILURE_INDICATION_TYPE 67 ------------------ | Branch (2988:5): [True: 3, False: 319] ------------------ 2989| 3| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_failure_indication, 2990| 3| &ogs_gtp2_tlv_desc_delete_bearer_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2991| 3| break; 2992| 3| case OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE: ------------------ | | 100| 3|#define OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE 68 ------------------ | Branch (2992:5): [True: 3, False: 319] ------------------ 2993| 3| rv = ogs_tlv_parse_msg(>p2_message->bearer_resource_command, 2994| 3| &ogs_gtp2_tlv_desc_bearer_resource_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2995| 3| break; 2996| 7| case OGS_GTP2_BEARER_RESOURCE_FAILURE_INDICATION_TYPE: ------------------ | | 101| 7|#define OGS_GTP2_BEARER_RESOURCE_FAILURE_INDICATION_TYPE 69 ------------------ | Branch (2996:5): [True: 7, False: 315] ------------------ 2997| 7| rv = ogs_tlv_parse_msg(>p2_message->bearer_resource_failure_indication, 2998| 7| &ogs_gtp2_tlv_desc_bearer_resource_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 7|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2999| 7| break; 3000| 1| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_FAILURE_INDICATION_TYPE: ------------------ | | 102| 1|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_FAILURE_INDICATION_TYPE 70 ------------------ | Branch (3000:5): [True: 1, False: 321] ------------------ 3001| 1| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification_failure_indication, 3002| 1| &ogs_gtp2_tlv_desc_downlink_data_notification_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3003| 1| break; 3004| 1| case OGS_GTP2_CREATE_BEARER_REQUEST_TYPE: ------------------ | | 106| 1|#define OGS_GTP2_CREATE_BEARER_REQUEST_TYPE 95 ------------------ | Branch (3004:5): [True: 1, False: 321] ------------------ 3005| 1| rv = ogs_tlv_parse_msg(>p2_message->create_bearer_request, 3006| 1| &ogs_gtp2_tlv_desc_create_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3007| 1| break; 3008| 19| case OGS_GTP2_CREATE_BEARER_RESPONSE_TYPE: ------------------ | | 107| 19|#define OGS_GTP2_CREATE_BEARER_RESPONSE_TYPE 96 ------------------ | Branch (3008:5): [True: 19, False: 303] ------------------ 3009| 19| rv = ogs_tlv_parse_msg(>p2_message->create_bearer_response, 3010| 19| &ogs_gtp2_tlv_desc_create_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 19|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3011| 19| break; 3012| 3| case OGS_GTP2_UPDATE_BEARER_REQUEST_TYPE: ------------------ | | 108| 3|#define OGS_GTP2_UPDATE_BEARER_REQUEST_TYPE 97 ------------------ | Branch (3012:5): [True: 3, False: 319] ------------------ 3013| 3| rv = ogs_tlv_parse_msg(>p2_message->update_bearer_request, 3014| 3| &ogs_gtp2_tlv_desc_update_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3015| 3| break; 3016| 2| case OGS_GTP2_UPDATE_BEARER_RESPONSE_TYPE: ------------------ | | 109| 2|#define OGS_GTP2_UPDATE_BEARER_RESPONSE_TYPE 98 ------------------ | Branch (3016:5): [True: 2, False: 320] ------------------ 3017| 2| rv = ogs_tlv_parse_msg(>p2_message->update_bearer_response, 3018| 2| &ogs_gtp2_tlv_desc_update_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3019| 2| break; 3020| 2| case OGS_GTP2_DELETE_BEARER_REQUEST_TYPE: ------------------ | | 110| 2|#define OGS_GTP2_DELETE_BEARER_REQUEST_TYPE 99 ------------------ | Branch (3020:5): [True: 2, False: 320] ------------------ 3021| 2| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_request, 3022| 2| &ogs_gtp2_tlv_desc_delete_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3023| 2| break; 3024| 1| case OGS_GTP2_DELETE_BEARER_RESPONSE_TYPE: ------------------ | | 111| 1|#define OGS_GTP2_DELETE_BEARER_RESPONSE_TYPE 100 ------------------ | Branch (3024:5): [True: 1, False: 321] ------------------ 3025| 1| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_response, 3026| 1| &ogs_gtp2_tlv_desc_delete_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3027| 1| break; 3028| 1| case OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE: ------------------ | | 122| 1|#define OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE 166 ------------------ | Branch (3028:5): [True: 1, False: 321] ------------------ 3029| 1| rv = ogs_tlv_parse_msg(>p2_message->create_indirect_data_forwarding_tunnel_request, 3030| 1| &ogs_gtp2_tlv_desc_create_indirect_data_forwarding_tunnel_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3031| 1| break; 3032| 2| case OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE: ------------------ | | 123| 2|#define OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE 167 ------------------ | Branch (3032:5): [True: 2, False: 320] ------------------ 3033| 2| rv = ogs_tlv_parse_msg(>p2_message->create_indirect_data_forwarding_tunnel_response, 3034| 2| &ogs_gtp2_tlv_desc_create_indirect_data_forwarding_tunnel_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3035| 2| break; 3036| 1| case OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE: ------------------ | | 124| 1|#define OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_REQUEST_TYPE 168 ------------------ | Branch (3036:5): [True: 1, False: 321] ------------------ 3037| 1| break; 3038| 1| case OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE: ------------------ | | 125| 1|#define OGS_GTP2_DELETE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE 169 ------------------ | Branch (3038:5): [True: 1, False: 321] ------------------ 3039| 1| rv = ogs_tlv_parse_msg(>p2_message->delete_indirect_data_forwarding_tunnel_response, 3040| 1| &ogs_gtp2_tlv_desc_delete_indirect_data_forwarding_tunnel_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3041| 1| break; 3042| 1| case OGS_GTP2_RELEASE_ACCESS_BEARERS_REQUEST_TYPE: ------------------ | | 126| 1|#define OGS_GTP2_RELEASE_ACCESS_BEARERS_REQUEST_TYPE 170 ------------------ | Branch (3042:5): [True: 1, False: 321] ------------------ 3043| 1| rv = ogs_tlv_parse_msg(>p2_message->release_access_bearers_request, 3044| 1| &ogs_gtp2_tlv_desc_release_access_bearers_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3045| 1| break; 3046| 3| case OGS_GTP2_RELEASE_ACCESS_BEARERS_RESPONSE_TYPE: ------------------ | | 127| 3|#define OGS_GTP2_RELEASE_ACCESS_BEARERS_RESPONSE_TYPE 171 ------------------ | Branch (3046:5): [True: 3, False: 319] ------------------ 3047| 3| rv = ogs_tlv_parse_msg(>p2_message->release_access_bearers_response, 3048| 3| &ogs_gtp2_tlv_desc_release_access_bearers_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3049| 3| break; 3050| 2| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_TYPE: ------------------ | | 128| 2|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_TYPE 176 ------------------ | Branch (3050:5): [True: 2, False: 320] ------------------ 3051| 2| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification, 3052| 2| &ogs_gtp2_tlv_desc_downlink_data_notification, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3053| 2| break; 3054| 1| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_ACKNOWLEDGE_TYPE: ------------------ | | 129| 1|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_ACKNOWLEDGE_TYPE 177 ------------------ | Branch (3054:5): [True: 1, False: 321] ------------------ 3055| 1| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification_acknowledge, 3056| 1| &ogs_gtp2_tlv_desc_downlink_data_notification_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3057| 1| break; 3058| 9| case OGS_GTP2_MODIFY_ACCESS_BEARERS_REQUEST_TYPE: ------------------ | | 134| 9|#define OGS_GTP2_MODIFY_ACCESS_BEARERS_REQUEST_TYPE 211 ------------------ | Branch (3058:5): [True: 9, False: 313] ------------------ 3059| 9| rv = ogs_tlv_parse_msg(>p2_message->modify_access_bearers_request, 3060| 9| &ogs_gtp2_tlv_desc_modify_access_bearers_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 9|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3061| 9| break; 3062| 4| case OGS_GTP2_MODIFY_ACCESS_BEARERS_RESPONSE_TYPE: ------------------ | | 135| 4|#define OGS_GTP2_MODIFY_ACCESS_BEARERS_RESPONSE_TYPE 212 ------------------ | Branch (3062:5): [True: 4, False: 318] ------------------ 3063| 4| rv = ogs_tlv_parse_msg(>p2_message->modify_access_bearers_response, 3064| 4| &ogs_gtp2_tlv_desc_modify_access_bearers_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3065| 4| break; 3066| 8| default: ------------------ | Branch (3066:5): [True: 8, False: 314] ------------------ 3067| 8| ogs_warn("Not implemented(type:%d)", gtp2_message->h.type); ------------------ | | 37| 8|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 8|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 3068| 8| break; 3069| 322| } 3070| | 3071| 322| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 322| do { \ | | 114| 322| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 322|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 322, False: 0] | | | | ------------------ | | ------------------ | | 115| 322| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 56| 0|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 322| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 322] | | ------------------ ------------------ 3072| | 3073| 322| return rv; 3074| 322|} 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: 31| 708|{ /* open5gs/tests/non3gpp/gtp-path.c */ 32| | 33| 708| if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 26| 1.41k|#define kMinInputLength 5 ------------------ if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 27| 704|#define kMaxInputLength 1024 ------------------ | Branch (33:9): [True: 4, False: 704] | Branch (33:35): [True: 22, False: 682] ------------------ 34| 26| return 1; 35| 26| } 36| | 37| 682| if (!initialized) { ------------------ | Branch (37:9): [True: 1, False: 681] ------------------ 38| 1| initialize(); 39| 1| ogs_log_install_domain(&__ogs_gtp_domain, "gtp", OGS_LOG_NONE); 40| 1| ogs_log_install_domain(&__ogs_tlv_domain, "tlv", OGS_LOG_NONE); 41| 1| } 42| | 43| 682| ogs_pkbuf_t *pkbuf; 44| 682| pkbuf = ogs_pkbuf_alloc(NULL, OGS_MAX_SDU_LEN); ------------------ | | 87| 682| ogs_pkbuf_alloc_debug(pool, size, OGS_FILE_LINE) | | ------------------ | | | | 213| 682|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 167| 682|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 168| 682|#define OGS_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 45| | 46| 682| if (pkbuf == NULL) { ------------------ | Branch (46:9): [True: 0, False: 682] ------------------ 47| 0| return 1; 48| 0| } 49| 682| ogs_pkbuf_put_data(pkbuf, Data, Size); 50| | 51| 682| if (GTP_VERSION(Data[0]) == OGS_GTP1_VERSION_1) { ------------------ | | 28| 682|#define GTP_VERSION(byte) (((byte) >> 5) & 0x07) ------------------ if (GTP_VERSION(Data[0]) == OGS_GTP1_VERSION_1) { ------------------ | | 48| 682|#define OGS_GTP1_VERSION_1 1 ------------------ | Branch (51:9): [True: 350, False: 332] ------------------ 52| | /* GTPv1 */ 53| 350| ogs_gtp1_message_t gtp1_message; 54| 350| ogs_gtp1_parse_msg(>p1_message, pkbuf); 55| 350| } else { 56| | /* GTPv2 */ 57| 332| ogs_gtp2_message_t gtp2_message; 58| 332| ogs_gtp2_parse_msg(>p2_message, pkbuf); 59| 332| } 60| | 61| 682| ogs_pkbuf_free(pkbuf); 62| | 63| 682| return 0; 64| 682|}