ogs_buffer_to_uint64: 128| 76|{ 129| 76| uint64_t num = 0; 130| 76| uint8_t *buffer_p = buffer; 131| 76| int i; 132| | 133| 456| for (i = 0; i < size; i++) { ------------------ | Branch (133:17): [True: 380, False: 76] ------------------ 134| 380| num |= (((uint64_t)buffer_p[i]) << ((size-1-i) * 8)); 135| 380| } 136| | 137| 76| return num; 138| 76|} 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: 366| 3|{ 367| 3| ogs_hash_t *ht; 368| | 369| |#ifdef _WIN32 370| | BOOL initialized = InitOnceExecuteOnce( 371| | &hash_once, init_hash_secret, NULL, NULL); 372| | ogs_assert(initialized); 373| |#else 374| 3| int rv = pthread_once(&hash_once, init_hash_secret); 375| 3| ogs_assert(rv == 0); ------------------ | | 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] | | ------------------ ------------------ 376| 3|#endif 377| | 378| 3| ht = ogs_calloc(1, sizeof(*ht)); ------------------ | | 70| 3| ogs_talloc_zero_size(__ogs_talloc_core, (nmemb) * (size), __location__) ------------------ 379| 3| if (!ht) ------------------ | Branch (379:9): [True: 0, False: 3] ------------------ 380| 3| ogs_error("ogs_calloc() 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__) | | ------------------ ------------------ 381| 3| return ht; 382| 3|} ogs-hash.c:init_hash_secret: 128| 1|{ 129| 1| ogs_random(hash_secret, sizeof(hash_secret)); 130| 1|} ogs-log.c:ogs_list_first: 51| 12.0k|{ 52| 12.0k| return list->next; 53| 12.0k|} ogs-log.c:ogs_list_next: 61| 7.58k|{ 62| 7.58k| ogs_list_t *node = (ogs_list_t *)lnode; 63| 7.58k| return node->next; 64| 7.58k|} 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| 12.0k|{ 405| 12.0k| ogs_log_t *log = NULL; 406| 12.0k| ogs_log_domain_t *domain = NULL; 407| | 408| 12.0k| char logstr[OGS_HUGE_LEN]; 409| 12.0k| char *p, *last; 410| | 411| 12.0k| int wrote_stderr = 0; 412| | 413| 12.0k| ogs_list_for_each(&log_list, log) { ------------------ | | 76| 19.6k| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 12.0k, False: 7.56k] | | ------------------ | | 77| 12.0k| node = ogs_list_next(node)) ------------------ 414| 12.0k| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 12.0k| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 12.0k, False: 0] | | | Branch (154:20): [True: 12.0k, False: 0] | | ------------------ ------------------ 415| 12.0k| if (!domain) { ------------------ | Branch (415:13): [True: 0, False: 12.0k] ------------------ 416| 0| fprintf(stderr, "No LogDomain[id:%d] in %s:%d", id, file, line); 417| 0| ogs_assert_if_reached(); ------------------ | | 122| 0| do { \ | | 123| 0| ogs_fatal("%s: should not be reached.", OGS_FUNC); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 124| 0| ogs_abort(); \ | | 125| 0| } while(0) | | ------------------ | | | Branch (125:13): [Folded, False: 0] | | ------------------ ------------------ 418| 0| } 419| 12.0k| if (domain->level < level) ------------------ | Branch (419:13): [True: 4.52k, False: 7.56k] ------------------ 420| 4.52k| return; 421| | 422| 7.56k| p = logstr; 423| 7.56k| last = logstr + OGS_HUGE_LEN; ------------------ | | 210| 7.56k|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 424| | 425| 7.56k| if (!content_only) { ------------------ | Branch (425:13): [True: 7.19k, False: 362] ------------------ 426| 7.19k| if (log->print.timestamp) ------------------ | Branch (426:17): [True: 7.19k, False: 0] ------------------ 427| 7.19k| p = log_timestamp(p, last, log->print.color); 428| 7.19k| if (log->print.domain) ------------------ | Branch (428:17): [True: 7.19k, False: 0] ------------------ 429| 7.19k| p = log_domain(p, last, domain->name, log->print.color); 430| 7.19k| if (log->print.level) ------------------ | Branch (430:17): [True: 7.19k, False: 0] ------------------ 431| 7.19k| p = log_level(p, last, level, log->print.color); 432| 7.19k| } 433| | 434| 7.56k| p = log_content(p, last, format, ap); 435| | 436| 7.56k| if (err) { ------------------ | Branch (436:13): [True: 0, False: 7.56k] ------------------ 437| 0| char errbuf[OGS_HUGE_LEN]; 438| 0| p = ogs_slprintf(p, last, " (%d:%s)", 439| 0| (int)err, ogs_strerror(err, errbuf, OGS_HUGE_LEN)); ------------------ | | 210| 0|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 440| 0| } 441| | 442| 7.56k| if (!content_only) { ------------------ | Branch (442:13): [True: 7.19k, False: 362] ------------------ 443| 7.19k| if (log->print.fileline) ------------------ | Branch (443:17): [True: 7.19k, False: 0] ------------------ 444| 7.19k| p = ogs_slprintf(p, last, " (%s:%d)", file, line); 445| 7.19k| if (log->print.function) ------------------ | Branch (445:17): [True: 0, False: 7.19k] ------------------ 446| 0| p = ogs_slprintf(p, last, " %s()", func); 447| 7.19k| if (log->print.linefeed) ------------------ | Branch (447:17): [True: 7.19k, False: 0] ------------------ 448| 7.19k| p = log_linefeed(p, last); 449| 7.19k| } 450| | 451| 7.56k| log->writer(log, level, logstr); 452| | 453| 7.56k| if (log->type == OGS_LOG_STDERR_TYPE) ------------------ | Branch (453:13): [True: 7.56k, False: 0] ------------------ 454| 7.56k| wrote_stderr = 1; 455| 7.56k| } 456| | 457| 7.56k| if (!wrote_stderr) ------------------ | Branch (457:9): [True: 0, False: 7.56k] ------------------ 458| 0| { 459| 0| int use_color = 0; 460| 0|#if !defined(_WIN32) 461| 0| use_color = 1; 462| 0|#endif 463| | 464| 0| p = logstr; 465| 0| last = logstr + OGS_HUGE_LEN; ------------------ | | 210| 0|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 466| | 467| 0| if (!content_only) { ------------------ | Branch (467:13): [True: 0, False: 0] ------------------ 468| 0| p = log_timestamp(p, last, use_color); 469| 0| p = log_level(p, last, level, use_color); 470| 0| } 471| 0| p = log_content(p, last, format, ap); 472| 0| if (!content_only) { ------------------ | Branch (472:13): [True: 0, False: 0] ------------------ 473| 0| p = ogs_slprintf(p, last, " (%s:%d)", file, line); 474| 0| p = ogs_slprintf(p, last, " %s()", func); 475| 0| p = log_linefeed(p, last); 476| 0| } 477| | 478| 0| fprintf(stderr, "%s", logstr); 479| | fflush(stderr); 480| 0| } 481| 7.56k|} ogs_log_printf: 486| 12.0k|{ 487| 12.0k| va_list args; 488| | 489| 12.0k| va_start(args, format); 490| 12.0k| ogs_log_vprintf(level, id, 491| 12.0k| err, file, line, func, content_only, format, args); 492| | va_end(args); 493| 12.0k|} ogs_log_hexdump_func: 497| 376|{ 498| 376| size_t n, m; 499| 376| char dumpstr[OGS_HUGE_LEN]; 500| 376| 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| 376| if (!len) ------------------ | Branch (506:9): [True: 14, False: 362] ------------------ 507| 14| return; 508| | 509| 362| last = dumpstr + OGS_HUGE_LEN; ------------------ | | 210| 362|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 510| 362| p = dumpstr; 511| | 512| 2.95k| for (n = 0; n < len; n += 16) { ------------------ | Branch (512:17): [True: 2.59k, False: 362] ------------------ 513| 2.59k| p = ogs_slprintf(p, last, "%04x: ", (int)n); 514| | 515| 44.0k| for (m = n; m < n + 16; m++) { ------------------ | Branch (515:21): [True: 41.4k, False: 2.59k] ------------------ 516| 41.4k| if (m > n && (m % 4) == 0) ------------------ | Branch (516:17): [True: 38.8k, False: 2.59k] | Branch (516:26): [True: 7.77k, False: 31.0k] ------------------ 517| 7.77k| p = ogs_slprintf(p, last, " "); 518| 41.4k| if (m < len) ------------------ | Branch (518:17): [True: 38.0k, False: 3.44k] ------------------ 519| 38.0k| p = ogs_slprintf(p, last, "%02x", data[m]); 520| 3.44k| else 521| 3.44k| p = ogs_slprintf(p, last, " "); 522| 41.4k| } 523| | 524| 2.59k| p = ogs_slprintf(p, last, " "); 525| | 526| 40.6k| for (m = n; m < len && m < n + 16; m++) ------------------ | Branch (526:21): [True: 40.2k, False: 362] | Branch (526:32): [True: 38.0k, False: 2.22k] ------------------ 527| 38.0k| p = ogs_slprintf(p, last, "%c", isprint(data[m]) ? data[m] : '.'); ------------------ | Branch (527:45): [True: 6.68k, False: 31.3k] ------------------ 528| | 529| 2.59k| p = ogs_slprintf(p, last, "\n"); 530| 2.59k| } 531| | 532| | ogs_log_print(level, "%s", dumpstr); ------------------ | | 48| 362| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | ------------------ | | | | 32| 362|#define OGS_LOG_DOMAIN 1 | | ------------------ | | 49| 362| 0, NULL, 0, NULL, \ | | 50| 362| 1, __VA_ARGS__) ------------------ 533| 362|} 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.19k|{ 572| 7.19k| struct timeval tv; 573| 7.19k| struct tm tm; 574| 7.19k| char nowstr[32]; 575| | 576| 7.19k| ogs_gettimeofday(&tv); 577| 7.19k| ogs_localtime(tv.tv_sec, &tm); 578| 7.19k| strftime(nowstr, sizeof nowstr, "%m/%d %H:%M:%S", &tm); 579| | 580| 7.19k| buf = ogs_slprintf(buf, last, "%s%s.%03d%s: ", 581| 7.19k| use_color ? TA_FGC_GREEN : "", ------------------ | | 37| 7.19k|#define TA_FGC_GREEN "\033[32m" /* Green */ ------------------ | Branch (581:13): [True: 7.19k, False: 0] ------------------ 582| 7.19k| nowstr, (int)(tv.tv_usec/1000), 583| 7.19k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.19k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (583:13): [True: 7.19k, False: 0] ------------------ 584| | 585| 7.19k| return buf; 586| 7.19k|} ogs-log.c:log_domain: 590| 7.19k|{ 591| 7.19k| buf = ogs_slprintf(buf, last, "[%s%s%s] ", 592| 7.19k| use_color ? TA_FGC_YELLOW : "", ------------------ | | 39| 7.19k|#define TA_FGC_YELLOW "\033[33m" /* Yellow */ ------------------ | Branch (592:13): [True: 7.19k, False: 0] ------------------ 593| 7.19k| name, 594| 7.19k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.19k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (594:13): [True: 7.19k, False: 0] ------------------ 595| | 596| 7.19k| return buf; 597| 7.19k|} ogs-log.c:log_level: 601| 7.19k|{ 602| 7.19k| const char *colors[] = { 603| 7.19k| TA_NOR, ------------------ | | 32| 7.19k|#define TA_NOR "\033[0m" /* all off */ ------------------ 604| 7.19k| TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 36| 7.19k|#define TA_FGC_BOLD_RED "\033[1;31m" /* Bold Red */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 40| 7.19k|#define TA_FGC_BOLD_YELLOW "\033[1;33m" /* Bold Yellow */ ------------------ TA_FGC_BOLD_RED, TA_FGC_BOLD_YELLOW, TA_FGC_BOLD_CYAN, ------------------ | | 43| 7.19k|#define TA_FGC_BOLD_CYAN "\033[1;36m" /* Bold Cyan */ ------------------ 605| 7.19k| TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 38| 7.19k|#define TA_FGC_BOLD_GREEN "\033[1;32m" /* Bold Green */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 45| 7.19k|#define TA_FGC_BOLD_WHITE "\033[1;37m" /* Bold White */ ------------------ TA_FGC_BOLD_GREEN, TA_FGC_BOLD_WHITE, TA_FGC_WHITE, ------------------ | | 44| 7.19k|#define TA_FGC_WHITE "\033[37m" /* White */ ------------------ 606| 7.19k| }; 607| | 608| 7.19k| buf = ogs_slprintf(buf, last, "%s%s%s: ", 609| 7.19k| use_color ? colors[level] : "", ------------------ | Branch (609:13): [True: 7.19k, False: 0] ------------------ 610| 7.19k| level_strings[level], 611| 7.19k| use_color ? TA_NOR : ""); ------------------ | | 32| 7.19k|#define TA_NOR "\033[0m" /* all off */ ------------------ | Branch (611:13): [True: 7.19k, False: 0] ------------------ 612| | 613| 7.19k| return buf; 614| 7.19k|} ogs-log.c:log_content: 618| 7.56k|{ 619| 7.56k| va_list bp; 620| | 621| 7.56k| va_copy(bp, ap); 622| 7.56k|#pragma GCC diagnostic push 623| 7.56k|#pragma GCC diagnostic ignored "-Wformat-nonliteral" 624| 7.56k| buf = ogs_vslprintf(buf, last, format, bp); 625| 7.56k|#pragma GCC diagnostic pop 626| 7.56k| va_end(bp); 627| | 628| 7.56k| return buf; 629| 7.56k|} ogs-log.c:log_linefeed: 632| 7.19k|{ 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.19k| if (buf > last - 2) ------------------ | Branch (639:9): [True: 0, False: 7.19k] ------------------ 640| 0| buf = last - 2; 641| | 642| 7.19k| buf = ogs_slprintf(buf, last, "\n"); 643| 7.19k|#endif 644| | 645| 7.19k| return buf; 646| 7.19k|} ogs-log.c:file_writer: 650| 7.56k|{ 651| 7.56k| fprintf(log->file.out, "%s", string); 652| 7.56k| fflush(log->file.out); 653| 7.56k|} 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_zero_size: 78| 2.09k|{ 79| 2.09k| void *ptr = NULL; 80| | 81| 2.09k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 2.09k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 82| | 83| 2.09k| ptr = _talloc_zero(ctx, size, name); 84| 2.09k| ogs_expect(ptr); ------------------ | | 128| 2.09k| do { \ | | 129| 2.09k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.09k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.09k, False: 0] | | | | ------------------ | | ------------------ | | 130| 2.09k| 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| 2.09k| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 2.09k] | | ------------------ ------------------ 85| | 86| 2.09k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 2.09k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 87| | 88| 2.09k| return ptr; 89| 2.09k|} ogs_talloc_free: 107| 2.09k|{ 108| 2.09k| int ret; 109| | 110| 2.09k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 2.09k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 111| | 112| 2.09k| ret = _talloc_free(ptr, location); 113| | 114| 2.09k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 2.09k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 115| | 116| 2.09k| return ret; 117| 2.09k|} ogs_pkbuf_put_data: 91| 2.09k|{ 92| 2.09k| void *tmp = ogs_pkbuf_put(pkbuf, len); 93| | 94| 2.09k| memcpy(tmp, data, len); 95| 2.09k| return tmp; 96| 2.09k|} 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| 2.09k|{ 223| 2.09k|#if OGS_USE_TALLOC == 1 224| 2.09k| ogs_pkbuf_t *pkbuf = NULL; 225| | 226| 2.09k| pkbuf = ogs_talloc_zero_size(pool, sizeof(*pkbuf) + size, file_line); 227| 2.09k| if (!pkbuf) { ------------------ | Branch (227:9): [True: 0, False: 2.09k] ------------------ 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| 2.09k| pkbuf->head = pkbuf->_data; 233| 2.09k| pkbuf->end = pkbuf->_data + size; 234| | 235| 2.09k| pkbuf->len = 0; 236| | 237| 2.09k| pkbuf->data = pkbuf->_data; 238| 2.09k| pkbuf->tail = pkbuf->_data; 239| | 240| 2.09k| pkbuf->file_line = file_line; /* For debug */ 241| | 242| 2.09k| 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| 2.09k|} ogs_pkbuf_free: 290| 2.09k|{ 291| 2.09k|#if OGS_USE_TALLOC == 1 292| 2.09k| ogs_talloc_free(pkbuf, OGS_FILE_LINE); ------------------ | | 213| 2.09k|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | ------------------ | | | | 167| 2.09k|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | ------------------ | | | | | | 168| 2.09k|#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| 2.09k|} message.c:ogs_pkbuf_pull: 165| 2.09k|{ 166| 2.09k| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 2.09k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 15, False: 2.07k] | | ------------------ ------------------ 167| 2.09k| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 2.09k|} message.c:ogs_pkbuf_pull_inline: 159| 2.07k|{ 160| 2.07k| pkbuf->len -= len; 161| 2.07k| return pkbuf->data += len; 162| 2.07k|} message.c:ogs_pkbuf_push: 147| 2.07k|{ 148| 2.07k| if (ogs_unlikely(ogs_pkbuf_headroom(pkbuf) < (int)len)) ------------------ | | 55| 2.07k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 2.07k] | | ------------------ ------------------ 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| 2.07k| pkbuf->data -= len; 152| 2.07k| pkbuf->len += len; 153| | 154| 2.07k| return pkbuf->data; 155| 2.07k|} message.c:ogs_pkbuf_headroom: 104| 2.07k|{ 105| 2.07k| return pkbuf->data - pkbuf->head; 106| 2.07k|} ogs-pkbuf.c:ogs_pkbuf_put: 115| 2.09k|{ 116| 2.09k| void *tmp = pkbuf->tail; 117| | 118| 2.09k| if (ogs_unlikely(ogs_pkbuf_tailroom(pkbuf) < (int)len)) ------------------ | | 55| 2.09k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 2.09k] | | ------------------ ------------------ 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| 2.09k| pkbuf->tail += len; 122| 2.09k| pkbuf->len += len; 123| | 124| 2.09k| return tmp; 125| 2.09k|} ogs-pkbuf.c:ogs_pkbuf_tailroom: 99| 2.09k|{ 100| 2.09k| return pkbuf->end - pkbuf->tail; 101| 2.09k|} ogs_random: 41| 1|{ 42| |#ifdef _WIN32 43| | void arc4random_buf(void *buf, size_t n); 44| | arc4random_buf(buf, buflen); 45| |#elif defined(HAVE_GETRANDOM) 46| 1| int rc = getrandom(buf, buflen, GRND_NONBLOCK); 47| 1| if (rc < 0) { ------------------ | Branch (47:9): [True: 0, False: 1] ------------------ 48| 0| ogs_log_message(OGS_LOG_FATAL, ogs_errno, "getrandom() failed"); ------------------ | | 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__) ------------------ 49| 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] | | ------------------ ------------------ 50| 0| } 51| |#elif defined(HAVE_ARC4RANDOM_BUF) 52| | arc4random_buf(buf, buflen); 53| |#elif defined(OGS_DEV_RANDOM) 54| | int fd = -1; 55| | 56| | /* On BSD/OS 4.1, /dev/random gives out 8 bytes at a time, then 57| | * gives EOF, so reading 'buflen' bytes may require opening the 58| | * device several times. */ 59| | do { 60| | int rc; 61| | 62| | if (fd == -1) 63| | if ((fd = open(OGS_DEV_RANDOM, O_RDONLY)) == -1) { 64| | ogs_log_message(OGS_LOG_FATAL, ogs_errno, "open() failed"); 65| | ogs_assert_if_reached(); 66| | } 67| | 68| | do { 69| | rc = read(fd, buf, buflen); 70| | } while (rc == -1 && errno == EINTR); 71| | 72| | if (rc < 0) { 73| | ogs_log_message(OGS_LOG_ERROR, ogs_errno, "read() failed"); 74| | close(fd); 75| | return; 76| | } 77| | else if (rc == 0) { 78| | close(fd); 79| | fd = -1; /* force open() again */ 80| | } 81| | else { 82| | buf = (unsigned char *)buf + rc; 83| | buflen -= rc; 84| | } 85| | } while (buflen > 0); 86| | 87| | close(fd); 88| |#else 89| |#error cannot find a method which finds a pseudo-random number 90| |#endif 91| 1|} ogs_rbtree_insert_color: 93| 7.51k|{ 94| 7.51k| ogs_rbnode_t *node = rb_node; 95| 7.51k| ogs_rbnode_t *parent; 96| 7.51k| ogs_assert(tree); ------------------ | | 113| 7.51k| do { \ | | 114| 7.51k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.51k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.51k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.51k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7.51k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.51k] | | ------------------ ------------------ 97| 7.51k| ogs_assert(node); ------------------ | | 113| 7.51k| do { \ | | 114| 7.51k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.51k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.51k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.51k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7.51k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.51k] | | ------------------ ------------------ 98| | 99| 13.4k| while ((parent = node->parent) && parent->color == OGS_RBTREE_RED) { ------------------ | Branch (99:12): [True: 10.4k, False: 2.97k] | Branch (99:39): [True: 5.89k, False: 4.54k] ------------------ 100| 5.89k| ogs_rbnode_t *gparent = parent->parent; 101| 5.89k| ogs_assert(gparent); ------------------ | | 113| 5.89k| do { \ | | 114| 5.89k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 5.89k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 5.89k, False: 0] | | | | ------------------ | | ------------------ | | 115| 5.89k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 5.89k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 5.89k] | | ------------------ ------------------ 102| | 103| | /* parent == grandparent's left child */ 104| 5.89k| if (parent == gparent->left) { ------------------ | Branch (104:13): [True: 2.33k, False: 3.55k] ------------------ 105| 2.33k| ogs_rbnode_t *uncle = gparent->right; 106| | 107| 2.33k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (107:17): [True: 1.31k, False: 1.01k] | Branch (107:26): [True: 939, False: 377] ------------------ 108| | /* 109| | * node's uncle == red (color flips) 110| | * 111| | * G g 112| | * / \ / \ 113| | * p u --> P U 114| | * / / 115| | * n n 116| | */ 117| 939| uncle->color = OGS_RBTREE_BLACK; 118| 939| parent->color = OGS_RBTREE_BLACK; 119| | 120| 939| gparent->color = OGS_RBTREE_RED; 121| | 122| 939| node = gparent; 123| 1.39k| } else { 124| | /* node's uncle == black */ 125| 1.39k| if (node == parent->right) { ------------------ | Branch (125:21): [True: 820, False: 575] ------------------ 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| 820| node = node->parent; 137| 820| rb_rotate_left(tree, node); 138| 820| } 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.39k| node->parent->color = OGS_RBTREE_BLACK; 151| 1.39k| gparent->color = OGS_RBTREE_RED; 152| 1.39k| rb_rotate_right(tree, gparent); 153| 1.39k| } 154| | /* parent == grandparent's right child */ 155| 3.55k| } else { 156| 3.55k| ogs_rbnode_t *uncle = gparent->left; 157| | 158| 3.55k| if (uncle && uncle->color == OGS_RBTREE_RED) { ------------------ | Branch (158:17): [True: 2.49k, False: 1.06k] | Branch (158:26): [True: 1.86k, False: 624] ------------------ 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.86k| uncle->color = OGS_RBTREE_BLACK; 169| 1.86k| parent->color = OGS_RBTREE_BLACK; 170| | 171| 1.86k| gparent->color = OGS_RBTREE_RED; 172| | 173| 1.86k| node = gparent; 174| 1.86k| } else { 175| | /* node's uncle == black */ 176| 1.69k| if (node == parent->left) { ------------------ | Branch (176:21): [True: 629, False: 1.06k] ------------------ 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| 629| node = node->parent; 188| 629| rb_rotate_right(tree, node); 189| 629| } 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.69k| node->parent->color = OGS_RBTREE_BLACK; 202| 1.69k| gparent->color = OGS_RBTREE_RED; 203| 1.69k| rb_rotate_left(tree, gparent); 204| 1.69k| } 205| 3.55k| } 206| 5.89k| } 207| | 208| 7.51k| ogs_assert(tree->root); ------------------ | | 113| 7.51k| do { \ | | 114| 7.51k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.51k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.51k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.51k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 7.51k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.51k] | | ------------------ ------------------ 209| 7.51k| tree->root->color = OGS_RBTREE_BLACK; 210| 7.51k|} ogs-rbtree.c:rb_rotate_left: 56| 2.51k|{ 57| 2.51k| ogs_rbnode_t *right = node->right; 58| 2.51k| node->right = right->left; 59| 2.51k| if (right->left) ------------------ | Branch (59:9): [True: 871, False: 1.64k] ------------------ 60| 871| right->left->parent = node; 61| | 62| 2.51k| rb_replace_node(tree, node, right, node->parent); 63| | 64| 2.51k| right->left = node; 65| 2.51k| node->parent = right; 66| 2.51k|} ogs-rbtree.c:rb_rotate_right: 80| 2.02k|{ 81| 2.02k| ogs_rbnode_t *left = node->left; 82| 2.02k| node->left = left->right; 83| 2.02k| if (left->right) ------------------ | Branch (83:9): [True: 534, False: 1.49k] ------------------ 84| 534| left->right->parent = node; 85| | 86| 2.02k| rb_replace_node(tree, node, left, node->parent); 87| | 88| 2.02k| left->right = node; 89| 2.02k| node->parent = left; 90| 2.02k|} ogs-rbtree.c:rb_replace_node: 37| 4.53k|{ 38| 4.53k| rb_change_child(tree, old, new, parent); 39| | 40| 4.53k| if (new) ------------------ | Branch (40:9): [True: 4.53k, False: 0] ------------------ 41| 4.53k| new->parent = parent; 42| 4.53k|} ogs-rbtree.c:rb_change_child: 24| 4.53k|{ 25| 4.53k| if (parent) { ------------------ | Branch (25:9): [True: 4.00k, False: 531] ------------------ 26| 4.00k| if (old == parent->left) ------------------ | Branch (26:13): [True: 1.75k, False: 2.25k] ------------------ 27| 1.75k| parent->left = new; 28| 2.25k| else 29| 2.25k| parent->right = new; 30| 4.00k| } else { 31| 531| tree->root = new; 32| 531| } 33| 4.53k|} ogs-tlv-msg.c:ogs_rbtree_link_node: 54| 7.51k|{ 55| 7.51k| ogs_rbnode_t *node = (ogs_rbnode_t *)rb_node; 56| 7.51k| node->parent = parent; 57| 7.51k| node->left = node->right = NULL; 58| 7.51k| node->color = OGS_RBTREE_RED; 59| | 60| 7.51k| *rb_link = node; 61| 7.51k|} ogs_socket_init: 36| 1|{ 37| |#if _WIN32 38| | WORD wVersionRequested; 39| | WSADATA wsaData; 40| | int err; 41| | 42| | wVersionRequested = MAKEWORD(2, 2); 43| | 44| | err = WSAStartup(wVersionRequested, &wsaData); 45| | ogs_assert(err == 0); 46| |#endif 47| 1|} ogs_vsnprintf: 63| 138k|{ 64| 138k| 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| 138k| r = vsnprintf(str, size, format, ap); 78| 138k|#endif 79| 138k| str[size-1] = '\0'; 80| | 81| 138k| return r; 82| 138k|} ogs_vslprintf: 97| 138k|{ 98| 138k| int r = -1; 99| | 100| 138k| ogs_assert(last); ------------------ | | 113| 138k| do { \ | | 114| 138k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 138k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 138k, False: 0] | | | | ------------------ | | ------------------ | | 115| 138k| 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| 138k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 138k] | | ------------------ ------------------ 101| | 102| 138k| if (!str) ------------------ | Branch (102:9): [True: 0, False: 138k] ------------------ 103| 0| return NULL; 104| | 105| 138k| if (str < last) ------------------ | Branch (105:9): [True: 138k, False: 0] ------------------ 106| 138k| r = ogs_vsnprintf(str, last - str, format, ap); 107| | 108| 138k| return (str + r); 109| 138k|} ogs_slprintf: 112| 131k|{ 113| 131k| char *r; 114| 131k| va_list ap; 115| | 116| 131k| va_start(ap, format); 117| 131k| r = ogs_vslprintf(str, last, format, ap); 118| 131k| va_end(ap); 119| | 120| 131k| return r; 121| 131k|} ogs_gettimeofday: 74| 7.19k|{ 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.19k| int rc = gettimeofday(tv, NULL); 115| 7.19k| ogs_assert(rc == 0); ------------------ | | 113| 7.19k| do { \ | | 114| 7.19k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.19k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.19k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.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| 7.19k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.19k] | | ------------------ ------------------ 116| 7.19k| return 0; 117| 7.19k|#endif 118| 7.19k|} ogs_localtime: 276| 7.19k|{ 277| 7.19k| ogs_assert(tm); ------------------ | | 113| 7.19k| do { \ | | 114| 7.19k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 7.19k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 7.19k, False: 0] | | | | ------------------ | | ------------------ | | 115| 7.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| 7.19k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 7.19k] | | ------------------ ------------------ 278| 7.19k| memset(tm, 0, sizeof(*tm)); 279| | 280| 7.19k|#if (HAVE_LOCALTIME_R) 281| 7.19k| (void)localtime_r(&s, tm); 282| |#else 283| | struct tm *t; 284| | 285| | t = localtime(&s); 286| | *tm = *t; 287| |#endif 288| 7.19k|} ogs_tlv_parse_msg: 743| 830|{ 744| 830| int rv; 745| 830| ogs_tlv_t *root; 746| | 747| 830| ogs_assert(msg); ------------------ | | 113| 830| do { \ | | 114| 830| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 830|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 830, False: 0] | | | | ------------------ | | ------------------ | | 115| 830| 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| 830| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 830] | | ------------------ ------------------ 748| 830| ogs_assert(desc); ------------------ | | 113| 830| do { \ | | 114| 830| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 830|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 830, False: 0] | | | | ------------------ | | ------------------ | | 115| 830| 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| 830| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 830] | | ------------------ ------------------ 749| 830| ogs_assert(pkbuf); ------------------ | | 113| 830| do { \ | | 114| 830| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 830|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 830, False: 0] | | | | ------------------ | | ------------------ | | 115| 830| 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| 830| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 830] | | ------------------ ------------------ 750| | 751| 830| ogs_assert(desc->ctype == OGS_TLV_MESSAGE); ------------------ | | 113| 830| do { \ | | 114| 830| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 830|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 830, False: 0] | | | | ------------------ | | ------------------ | | 115| 830| 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| 830| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 830] | | ------------------ ------------------ 752| 830| if (!desc->child_descs[0]) { ------------------ | Branch (752:9): [True: 0, False: 830] ------------------ 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| 830| root = ogs_tlv_parse_block(pkbuf->len, pkbuf->data, mode); 758| 830| if (root == NULL) { ------------------ | Branch (758:9): [True: 100, False: 730] ------------------ 759| 100| ogs_error("Can't parse TLV message"); ------------------ | | 36| 100|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 100| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 100|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 100| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 100|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 100| 0, __VA_ARGS__) | | ------------------ ------------------ 760| 100| return OGS_ERROR; ------------------ | | 78| 100|#define OGS_ERROR -1 ------------------ 761| 100| } 762| | 763| 730| rv = tlv_parse_compound(msg, desc, root, 0, mode); 764| | 765| 730| ogs_tlv_free_all(root); 766| | 767| 730| return rv; 768| 830|} ogs_tlv_parse_msg_desc: 905| 1.22k|{ 906| 1.22k| int rv; 907| 1.22k| ogs_tlv_t *root; 908| | 909| 1.22k| ogs_assert(msg); ------------------ | | 113| 1.22k| do { \ | | 114| 1.22k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.22k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.22k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.22k| 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.22k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.22k] | | ------------------ ------------------ 910| 1.22k| ogs_assert(desc); ------------------ | | 113| 1.22k| do { \ | | 114| 1.22k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.22k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.22k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.22k| 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.22k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.22k] | | ------------------ ------------------ 911| 1.22k| ogs_assert(pkbuf); ------------------ | | 113| 1.22k| do { \ | | 114| 1.22k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.22k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.22k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.22k| 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.22k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.22k] | | ------------------ ------------------ 912| | 913| 1.22k| ogs_assert(desc->ctype == OGS_TLV_MESSAGE); ------------------ | | 113| 1.22k| do { \ | | 114| 1.22k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.22k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.22k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.22k| 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.22k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.22k] | | ------------------ ------------------ 914| 1.22k| ogs_assert(desc->child_descs[0]); ------------------ | | 113| 1.22k| do { \ | | 114| 1.22k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.22k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.22k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.22k| 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.22k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.22k] | | ------------------ ------------------ 915| | 916| 1.22k| root = ogs_tlv_parse_block_desc(pkbuf->len, pkbuf->data, msg_mode, desc); 917| 1.22k| if (root == NULL) { ------------------ | Branch (917:9): [True: 238, False: 984] ------------------ 918| 238| ogs_error("Can't parse TLV message"); ------------------ | | 36| 238|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 238| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 238|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 238| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 238|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 238| 0, __VA_ARGS__) | | ------------------ ------------------ 919| 238| return OGS_ERROR; ------------------ | | 78| 238|#define OGS_ERROR -1 ------------------ 920| 238| } 921| | 922| 984| rv = tlv_parse_compound(msg, desc, root, 0, msg_mode); 923| | 924| 984| ogs_tlv_free_all(root); 925| | 926| 984| return rv; 927| 1.22k|} ogs-tlv-msg.c:tlv_ctype2mode: 59| 4.79k|{ 60| 4.79k| switch(ctype) { 61| 237| case OGS_TLV_UINT8: ------------------ | Branch (61:5): [True: 237, False: 4.55k] ------------------ 62| 237| case OGS_TLV_UINT16: ------------------ | Branch (62:5): [True: 0, False: 4.79k] ------------------ 63| 237| case OGS_TLV_UINT24: ------------------ | Branch (63:5): [True: 0, False: 4.79k] ------------------ 64| 237| case OGS_TLV_UINT32: ------------------ | Branch (64:5): [True: 0, False: 4.79k] ------------------ 65| 237| case OGS_TLV_INT8: ------------------ | Branch (65:5): [True: 0, False: 4.79k] ------------------ 66| 237| case OGS_TLV_INT16: ------------------ | Branch (66:5): [True: 0, False: 4.79k] ------------------ 67| 237| case OGS_TLV_INT24: ------------------ | Branch (67:5): [True: 0, False: 4.79k] ------------------ 68| 237| case OGS_TLV_INT32: ------------------ | Branch (68:5): [True: 0, False: 4.79k] ------------------ 69| 648| case OGS_TLV_FIXED_STR: ------------------ | Branch (69:5): [True: 411, False: 4.37k] ------------------ 70| 1.79k| case OGS_TLV_VAR_STR: ------------------ | Branch (70:5): [True: 1.14k, False: 3.64k] ------------------ 71| 1.79k| case OGS_TLV_NULL: ------------------ | Branch (71:5): [True: 0, False: 4.79k] ------------------ 72| 1.79k| case OGS_TLV_MORE: ------------------ | Branch (72:5): [True: 0, False: 4.79k] ------------------ 73| 1.79k| case OGS_TLV_COMPOUND: ------------------ | Branch (73:5): [True: 0, False: 4.79k] ------------------ 74| 1.79k| case OGS_TLV_MESSAGE: ------------------ | Branch (74:5): [True: 0, False: 4.79k] ------------------ 75| 1.79k| return msg_mode; 76| 1.76k| case OGS_TV_UINT8: ------------------ | Branch (76:5): [True: 1.76k, False: 3.02k] ------------------ 77| 2.12k| case OGS_TV_UINT16: ------------------ | Branch (77:5): [True: 366, False: 4.42k] ------------------ 78| 2.37k| case OGS_TV_UINT24: ------------------ | Branch (78:5): [True: 243, False: 4.54k] ------------------ 79| 2.63k| case OGS_TV_UINT32: ------------------ | Branch (79:5): [True: 268, False: 4.52k] ------------------ 80| 2.63k| case OGS_TV_INT8: ------------------ | Branch (80:5): [True: 0, False: 4.79k] ------------------ 81| 2.63k| case OGS_TV_INT16: ------------------ | Branch (81:5): [True: 0, False: 4.79k] ------------------ 82| 2.63k| case OGS_TV_INT24: ------------------ | Branch (82:5): [True: 0, False: 4.79k] ------------------ 83| 2.63k| case OGS_TV_INT32: ------------------ | Branch (83:5): [True: 0, False: 4.79k] ------------------ 84| 2.99k| case OGS_TV_FIXED_STR: ------------------ | Branch (84:5): [True: 356, False: 4.43k] ------------------ 85| 2.99k| case OGS_TV_VAR_STR: ------------------ | Branch (85:5): [True: 0, False: 4.79k] ------------------ 86| 2.99k| case OGS_TV_NULL: ------------------ | Branch (86:5): [True: 0, False: 4.79k] ------------------ 87| 2.99k| case OGS_TV_MORE: ------------------ | Branch (87:5): [True: 0, False: 4.79k] ------------------ 88| 2.99k| if (msg_mode == OGS_TLV_MODE_T2_L2) ------------------ | | 35| 2.99k|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (88:13): [True: 0, False: 2.99k] ------------------ 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| 2.99k| else 91| 2.99k| return OGS_TLV_MODE_T1; ------------------ | | 36| 2.99k|#define OGS_TLV_MODE_T1 5 ------------------ 92| 0| default: ------------------ | Branch (92:5): [True: 0, False: 4.79k] ------------------ 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.79k| } 96| 4.79k|} ogs-tlv-msg.c:tlv_parse_compound: 643| 2.52k|{ 644| 2.52k| int rv; 645| 2.52k| ogs_tlv_presence_t *presence_p = (ogs_tlv_presence_t *)msg; 646| 2.52k| ogs_tlv_desc_t *desc = NULL, *next_desc = NULL; 647| 2.52k| ogs_tlv_t *tlv = NULL, *emb_tlv = NULL; 648| 2.52k| uint8_t *p = msg; 649| 2.52k| uint32_t offset = 0; 650| 2.52k| uint8_t index = 0; 651| 2.52k| int i = 0, j; 652| 2.52k| OGS_RBTREE(tree); ------------------ | | 48| 2.52k|#define OGS_RBTREE(name) ogs_rbtree_t name = { NULL } ------------------ 653| 2.52k| tlv_count_node_t count_node[OGS_TLV_MAX_CHILD_DESC]; 654| 2.52k| unsigned count_node_alloc_next = 0; 655| 2.52k| char indent[17] = " "; /* 16 spaces */ 656| | 657| 2.52k| ogs_assert(msg); ------------------ | | 113| 2.52k| do { \ | | 114| 2.52k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.52k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.52k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.52k| 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.52k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.52k] | | ------------------ ------------------ 658| 2.52k| ogs_assert(parent_desc); ------------------ | | 113| 2.52k| do { \ | | 114| 2.52k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.52k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.52k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.52k| 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.52k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.52k] | | ------------------ ------------------ 659| 2.52k| ogs_assert(parent_tlv); ------------------ | | 113| 2.52k| do { \ | | 114| 2.52k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.52k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.52k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.52k| 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.52k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.52k] | | ------------------ ------------------ 660| | 661| 2.52k| ogs_assert(depth <= 8); ------------------ | | 113| 2.52k| do { \ | | 114| 2.52k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.52k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.52k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.52k| 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.52k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.52k] | | ------------------ ------------------ 662| 2.52k| indent[depth*2] = 0; 663| | 664| 2.52k| tlv = parent_tlv; 665| 12.2k| while (tlv) { ------------------ | Branch (665:12): [True: 9.81k, False: 2.44k] ------------------ 666| 9.81k| tlv_count_node_t *curr_count = tlv_count_node_find(&tree, &count_node[0], 667| 9.81k| OGS_ARRAY_SIZE(count_node), &count_node_alloc_next, tlv->type, tlv->instance); ------------------ | | 165| 9.81k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ 668| 9.81k| if (!curr_count) ------------------ | Branch (668:13): [True: 1, False: 9.81k] ------------------ 669| 1| return OGS_ERROR; ------------------ | | 78| 1|#define OGS_ERROR -1 ------------------ 670| 9.81k| desc = tlv_find_desc_by_type_inst(&index, &offset, parent_desc, tlv->type, tlv->instance, curr_count->count); 671| 9.81k| if (desc == NULL) { ------------------ | Branch (671:13): [True: 5.94k, False: 3.87k] ------------------ 672| 5.94k| ogs_warn("Unknown TLV type [%d]", tlv->type); ------------------ | | 37| 5.94k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5.94k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 5.94k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 5.94k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5.94k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5.94k| 0, __VA_ARGS__) | | ------------------ ------------------ 673| 5.94k| tlv = tlv->next; 674| 5.94k| continue; 675| 5.94k| } 676| | 677| 3.87k| presence_p = (ogs_tlv_presence_t *)(p + offset); 678| | 679| | /* Multiple of the same type TLV may be included */ 680| 3.87k| next_desc = parent_desc->child_descs[index+1]; 681| 3.87k| if (next_desc != NULL && next_desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (681:13): [True: 3.74k, False: 129] | Branch (681:34): [True: 1.20k, False: 2.54k] ------------------ 682| 6.37k| for (j = 0; j < next_desc->length; j++) { ------------------ | Branch (682:25): [True: 5.94k, False: 427] ------------------ 683| 5.94k| presence_p = 684| 5.94k| (ogs_tlv_presence_t *)(p + offset + desc->vsize * j); 685| 5.94k| if (*presence_p == 0) { ------------------ | Branch (685:21): [True: 776, False: 5.16k] ------------------ 686| 776| offset += desc->vsize * j; 687| 776| break; 688| 776| } 689| 5.94k| } 690| 1.20k| if (j == next_desc->length) { ------------------ | Branch (690:17): [True: 427, False: 776] ------------------ 691| 427| ogs_fatal("Multiple of the same type TLV need more room"); ------------------ | | 35| 427|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | ------------------ | | | | 43| 427| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 427|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 427| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 427|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 427| 0, __VA_ARGS__) | | ------------------ ------------------ 692| 427| tlv = tlv->next; 693| 427| continue; 694| 427| } 695| 2.67k| } else { 696| 2.67k| curr_count->count++; 697| 2.67k| } 698| | 699| 3.44k| if (desc->ctype == OGS_TLV_COMPOUND) { ------------------ | Branch (699:13): [True: 827, False: 2.61k] ------------------ 700| 827| emb_tlv = ogs_tlv_parse_embedded_block(tlv, mode); 701| 827| if (emb_tlv == NULL) { ------------------ | Branch (701:17): [True: 15, False: 812] ------------------ 702| 15| ogs_error("Error while parse TLV"); ------------------ | | 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__) | | ------------------ ------------------ 703| 15| return OGS_ERROR; ------------------ | | 78| 15|#define OGS_ERROR -1 ------------------ 704| 15| } 705| | 706| 812| ogs_trace("PARSE %sC#%d [%s] T:%d I:%d (vsz=%d) off:%p ", ------------------ | | 40| 812|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 812| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 812|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 812| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 812|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 812| 0, __VA_ARGS__) | | ------------------ ------------------ 707| 812| indent, i++, desc->name, desc->type, desc->instance, 708| 812| desc->vsize, p + offset); 709| | 710| 812| offset += sizeof(ogs_tlv_presence_t); 711| | 712| 812| rv = tlv_parse_compound( 713| 812| p + offset, desc, emb_tlv, depth + 1, mode); 714| 812| if (rv != OGS_OK) { ------------------ | | 77| 812|#define OGS_OK 0 ------------------ | Branch (714:17): [True: 2, False: 810] ------------------ 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| 810| *presence_p = 1; 720| 2.61k| } else { 721| 2.61k| ogs_trace("PARSE %sL#%d [%s] T:%d L:%d I:%d " ------------------ | | 40| 2.61k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.61k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 2.61k|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 2.61k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.61k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.61k| 0, __VA_ARGS__) | | ------------------ ------------------ 722| 2.61k| "(cls:%d vsz:%d) off:%p ", 723| 2.61k| indent, i++, desc->name, desc->type, desc->length, 724| 2.61k| desc->instance, desc->ctype, desc->vsize, p + offset); 725| | 726| 2.61k| rv = tlv_parse_leaf(p + offset, desc, tlv); 727| 2.61k| if (rv != OGS_OK) { ------------------ | | 77| 2.61k|#define OGS_OK 0 ------------------ | Branch (727:17): [True: 60, False: 2.55k] ------------------ 728| 60| ogs_error("Can't parse leaf TLV"); ------------------ | | 36| 60|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 60| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 60|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 60| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 60|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 60| 0, __VA_ARGS__) | | ------------------ ------------------ 729| 60| return OGS_ERROR; ------------------ | | 78| 60|#define OGS_ERROR -1 ------------------ 730| 60| } 731| | 732| 2.55k| *presence_p = 1; 733| 2.55k| } 734| | 735| 3.36k| tlv = tlv->next; 736| 3.36k| } 737| | 738| 2.44k| return OGS_OK; ------------------ | | 77| 2.44k|#define OGS_OK 0 ------------------ 739| 2.52k|} ogs-tlv-msg.c:tlv_count_node_find: 608| 9.81k|{ 609| 9.81k| ogs_rbnode_t **new = NULL; 610| 9.81k| ogs_rbnode_t *parent = NULL; 611| 9.81k| tlv_count_node_t *this; 612| | 613| 9.81k| uint64_t key = (((uint32_t)type)<<8) | instance; 614| | 615| 9.81k| new = &tree->root; 616| 35.3k| while (*new) { ------------------ | Branch (616:12): [True: 27.8k, False: 7.51k] ------------------ 617| 27.8k| this = ogs_rb_entry(*new, tlv_count_node_t, node); ------------------ | | 50| 27.8k|#define ogs_rb_entry(ptr, type, member) ogs_container_of(ptr, type, member) | | ------------------ | | | | 188| 27.8k| (type *)((unsigned char *)ptr - offsetof(type, member)) | | ------------------ ------------------ 618| 27.8k| parent = *new; 619| 27.8k| if (key < this->key) { ------------------ | Branch (619:13): [True: 10.3k, False: 17.4k] ------------------ 620| 10.3k| new = &(*new)->left; 621| 17.4k| } else if (key > this->key) { ------------------ | Branch (621:20): [True: 15.1k, False: 2.30k] ------------------ 622| 15.1k| new = &(*new)->right; 623| 15.1k| } else { /* found entry: */ 624| 2.30k| return this; 625| 2.30k| } 626| 27.8k| } 627| | 628| | /* No entry, need to add one: */ 629| 7.51k| if (*count_alloc_next == count_node_arr_len) { ------------------ | Branch (629:9): [True: 1, False: 7.51k] ------------------ 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| 7.51k| this = &count_node_arr[(*count_alloc_next)++]; 634| 7.51k| this->key = key; 635| 7.51k| this->count = 0; 636| 7.51k| ogs_rbtree_link_node(&this->node, parent, new); 637| 7.51k| ogs_rbtree_insert_color(tree, &this->node); 638| 7.51k| return this; 639| 7.51k|} ogs-tlv-msg.c:tlv_find_desc_by_type_inst: 456| 14.9k|{ 457| 14.9k| ogs_tlv_desc_t *prev_desc = NULL, *desc = NULL; 458| 14.9k| int i, offset = 0; 459| 14.9k| unsigned match_i = 0; 460| | 461| 14.9k| ogs_assert(parent_desc); ------------------ | | 113| 14.9k| do { \ | | 114| 14.9k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 14.9k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 14.9k, False: 0] | | | | ------------------ | | ------------------ | | 115| 14.9k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 14.9k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 14.9k] | | ------------------ ------------------ 462| | 463| 263k| for (i = 0, desc = parent_desc->child_descs[i]; desc != NULL; ------------------ | Branch (463:53): [True: 257k, False: 6.33k] ------------------ 464| 257k| i++, desc = parent_desc->child_descs[i]) { 465| 257k| if (desc->type == match_type && desc->instance == match_instance) { ------------------ | Branch (465:13): [True: 10.8k, False: 246k] | Branch (465:41): [True: 9.71k, False: 1.12k] ------------------ 466| 9.71k| if (match_i == match_type_pos) { ------------------ | Branch (466:17): [True: 8.66k, False: 1.05k] ------------------ 467| 8.66k| *desc_index = i; 468| 8.66k| *tlv_offset = offset; 469| 8.66k| break; 470| 8.66k| } 471| 1.05k| match_i++; 472| 1.05k| } 473| | 474| 248k| if (desc->ctype == OGS_TLV_MORE) { ------------------ | Branch (474:13): [True: 2.03k, False: 246k] ------------------ 475| 2.03k| ogs_assert(prev_desc && prev_desc->ctype != OGS_TLV_MORE); ------------------ | | 113| 2.03k| do { \ | | 114| 2.03k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4.06k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.03k, False: 0] | | | | | Branch (54:44): [True: 2.03k, False: 0] | | | | | Branch (54:44): [True: 2.03k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.03k| 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.03k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.03k] | | ------------------ ------------------ 476| 2.03k| offset += prev_desc->vsize * (desc->length - 1); 477| 246k| } else { 478| 246k| offset += desc->vsize; 479| 246k| } 480| | 481| 248k| prev_desc = desc; 482| 248k| } 483| | 484| 14.9k| return desc; 485| 14.9k|} ogs-tlv-msg.c:tlv_parse_leaf: 488| 2.61k|{ 489| 2.61k| ogs_assert(msg); ------------------ | | 113| 2.61k| do { \ | | 114| 2.61k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.61k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.61k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.61k| 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.61k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.61k] | | ------------------ ------------------ 490| 2.61k| ogs_assert(desc); ------------------ | | 113| 2.61k| do { \ | | 114| 2.61k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.61k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.61k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.61k| 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.61k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.61k] | | ------------------ ------------------ 491| 2.61k| ogs_assert(tlv); ------------------ | | 113| 2.61k| do { \ | | 114| 2.61k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.61k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.61k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.61k| 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.61k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.61k] | | ------------------ ------------------ 492| | 493| 2.61k| switch (desc->ctype) { 494| 203| case OGS_TV_UINT8: ------------------ | Branch (494:5): [True: 203, False: 2.41k] ------------------ 495| 203| case OGS_TV_INT8: ------------------ | Branch (495:5): [True: 0, False: 2.61k] ------------------ 496| 255| case OGS_TLV_UINT8: ------------------ | Branch (496:5): [True: 52, False: 2.56k] ------------------ 497| 255| case OGS_TLV_INT8: ------------------ | Branch (497:5): [True: 0, False: 2.61k] ------------------ 498| 255| { 499| 255| ogs_tlv_uint8_t *v = (ogs_tlv_uint8_t *)msg; 500| | 501| 255| if (tlv->length != 1) { ------------------ | Branch (501:13): [True: 12, False: 243] ------------------ 502| 12| ogs_error("Invalid TLV length %d. It should be 1", tlv->length); ------------------ | | 36| 12|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 12|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 503| 12| return OGS_ERROR; ------------------ | | 78| 12|#define OGS_ERROR -1 ------------------ 504| 12| } 505| 243| v->u8 = *(uint8_t*)(tlv->value); 506| 243| break; 507| 255| } 508| 54| case OGS_TV_UINT16: ------------------ | Branch (508:5): [True: 54, False: 2.56k] ------------------ 509| 54| case OGS_TV_INT16: ------------------ | Branch (509:5): [True: 0, False: 2.61k] ------------------ 510| 64| case OGS_TLV_UINT16: ------------------ | Branch (510:5): [True: 10, False: 2.60k] ------------------ 511| 64| case OGS_TLV_INT16: ------------------ | Branch (511:5): [True: 0, False: 2.61k] ------------------ 512| 64| { 513| 64| ogs_tlv_uint16_t *v = (ogs_tlv_uint16_t *)msg; 514| | 515| 64| if (tlv->length != 2) { ------------------ | Branch (515:13): [True: 4, False: 60] ------------------ 516| 4| ogs_error("Invalid TLV length %d. It should be 2", tlv->length); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 4|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 517| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 518| 4| } 519| 60| v->u16 = ((((uint8_t*)tlv->value)[0]<< 8)&0xff00) | 520| 60| ((((uint8_t*)tlv->value)[1] )&0x00ff); 521| 60| break; 522| 64| } 523| 1| case OGS_TV_UINT24: ------------------ | Branch (523:5): [True: 1, False: 2.61k] ------------------ 524| 1| case OGS_TV_INT24: ------------------ | Branch (524:5): [True: 0, False: 2.61k] ------------------ 525| 1| case OGS_TLV_UINT24: ------------------ | Branch (525:5): [True: 0, False: 2.61k] ------------------ 526| 1| case OGS_TLV_INT24: ------------------ | Branch (526:5): [True: 0, False: 2.61k] ------------------ 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| 27| case OGS_TV_UINT32: ------------------ | Branch (539:5): [True: 27, False: 2.59k] ------------------ 540| 27| case OGS_TV_INT32: ------------------ | Branch (540:5): [True: 0, False: 2.61k] ------------------ 541| 68| case OGS_TLV_UINT32: ------------------ | Branch (541:5): [True: 41, False: 2.57k] ------------------ 542| 68| case OGS_TLV_INT32: ------------------ | Branch (542:5): [True: 0, False: 2.61k] ------------------ 543| 68| { 544| 68| ogs_tlv_uint32_t *v = (ogs_tlv_uint32_t *)msg; 545| | 546| 68| if (tlv->length != 4) { ------------------ | Branch (546:13): [True: 15, False: 53] ------------------ 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| 53| v->u32 = (((uint32_t)((uint8_t*)tlv->value)[0]<<24)&0xff000000) | 551| 53| ((((uint8_t*)tlv->value)[1]<<16)&0x00ff0000) | 552| 53| ((((uint8_t*)tlv->value)[2]<< 8)&0x0000ff00) | 553| 53| ((((uint8_t*)tlv->value)[3] )&0x000000ff); 554| 53| break; 555| 68| } 556| 35| case OGS_TV_FIXED_STR: ------------------ | Branch (556:5): [True: 35, False: 2.58k] ------------------ 557| 72| case OGS_TLV_FIXED_STR: ------------------ | Branch (557:5): [True: 37, False: 2.58k] ------------------ 558| 72| { 559| 72| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 560| | 561| 72| if (tlv->length != desc->length) ------------------ | Branch (561:13): [True: 25, False: 47] ------------------ 562| 25| { 563| 25| ogs_error("Invalid TLV length %d. It should be %d", ------------------ | | 36| 25|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 25| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 25|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 25| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 25|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 25| 0, __VA_ARGS__) | | ------------------ ------------------ 564| 25| tlv->length, desc->length); 565| 25| return OGS_ERROR; ------------------ | | 78| 25|#define OGS_ERROR -1 ------------------ 566| 25| } 567| | 568| 47| v->data = tlv->value; 569| 47| v->len = tlv->length; 570| 47| break; 571| 72| } 572| 2.15k| case OGS_TLV_VAR_STR: ------------------ | Branch (572:5): [True: 2.15k, False: 464] ------------------ 573| 2.15k| { 574| 2.15k| ogs_tlv_octet_t *v = (ogs_tlv_octet_t *)msg; 575| | 576| 2.15k| v->data = tlv->value; 577| 2.15k| v->len = tlv->length; 578| 2.15k| break; 579| 72| } 580| 0| case OGS_TV_NULL: ------------------ | Branch (580:5): [True: 0, False: 2.61k] ------------------ 581| 0| case OGS_TLV_NULL: ------------------ | Branch (581:5): [True: 0, False: 2.61k] ------------------ 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| 4| default: ------------------ | Branch (589:5): [True: 4, False: 2.61k] ------------------ 590| 4| ogs_error("Unknown type[%d]", desc->ctype); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 4|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 591| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 592| 2.61k| } 593| | 594| 2.55k| return OGS_OK; ------------------ | | 77| 2.55k|#define OGS_OK 0 ------------------ 595| 2.61k|} ogs-tlv-msg.c:ogs_tlv_parse_block_desc: 835| 1.22k|{ 836| 1.22k| uint8_t *pos = data; 837| 1.22k| uint8_t *blk = data; 838| | 839| 1.22k| ogs_tlv_t *root = NULL; 840| 1.22k| ogs_tlv_t *prev = NULL; 841| 1.22k| ogs_tlv_t *curr = NULL; 842| | 843| 1.22k| root = curr = ogs_tlv_get(); 844| 1.22k| if (!curr) { ------------------ | Branch (844:9): [True: 0, False: 1.22k] ------------------ 845| 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__) | | ------------------ ------------------ 846| 0| length, msg_mode); 847| 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] | | ------------------ ------------------ 848| 0| return NULL; 849| 0| } 850| | 851| 1.22k| pos = tlv_get_element_desc( 852| 1.22k| curr, pos, length - (uint32_t)(pos - blk), msg_mode, desc); 853| 1.22k| if (!pos) { ------------------ | Branch (853:9): [True: 123, False: 1.09k] ------------------ 854| 123| ogs_error("ogs_tlv_parse_block() failed[LEN:%u,MODE:%u] - parse error", ------------------ | | 36| 123|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 123| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 123|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 123| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 123|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 123| 0, __VA_ARGS__) | | ------------------ ------------------ 855| 123| length, msg_mode); 856| 123| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 246| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 123|#define OGS_LOG_DOMAIN 1 | | ------------------ | | | Branch (53:53): [True: 119, False: 4] | | ------------------ ------------------ 857| 123| ogs_tlv_free_all(root); 858| 123| return NULL; 859| 123| } 860| | 861| 4.94k| while(pos - blk < length) { ------------------ | Branch (861:11): [True: 3.95k, False: 984] ------------------ 862| 3.95k| prev = curr; 863| | 864| 3.95k| curr = ogs_tlv_get(); 865| 3.95k| if (!curr) { ------------------ | Branch (865:13): [True: 0, False: 3.95k] ------------------ 866| 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__) | | ------------------ ------------------ 867| 0| length, msg_mode); 868| 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] | | ------------------ ------------------ 869| | 870| 0| ogs_tlv_free_all(root); 871| 0| return NULL; 872| 0| } 873| 3.95k| prev->next = curr; 874| | 875| 3.95k| pos = tlv_get_element_desc( 876| 3.95k| curr, pos, length - (uint32_t)(pos - blk), msg_mode, desc); 877| 3.95k| if (!pos) { ------------------ | Branch (877:13): [True: 115, False: 3.84k] ------------------ 878| 115| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 115|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 115| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 115|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 115| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 115|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 115| 0, __VA_ARGS__) | | ------------------ ------------------ 879| 115| length, msg_mode); 880| 115| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 230| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 115|#define OGS_LOG_DOMAIN 1 | | ------------------ | | | Branch (53:53): [True: 109, False: 6] | | ------------------ ------------------ 881| | 882| 115| ogs_tlv_free_all(root); 883| 115| return NULL; 884| 115| } 885| 3.95k| } 886| | 887| 984| if (length != (pos - blk)) { ------------------ | Branch (887:9): [True: 0, False: 984] ------------------ 888| 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__) | | ------------------ ------------------ 889| 0| length, msg_mode); 890| 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__) | | ------------------ ------------------ 891| 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] | | ------------------ ------------------ 892| | 893| 0| ogs_tlv_free_all(root); 894| 0| return NULL; 895| 0| } 896| | 897| 984| return root; 898| 984|} ogs-tlv-msg.c:tlv_get_element_desc: 798| 5.18k|{ 799| 5.18k| uint8_t instance; 800| 5.18k| unsigned tlv_tag_pos; 801| 5.18k| uint8_t desc_index = 0; 802| 5.18k| uint32_t tlv_offset = 0; 803| 5.18k| uint16_t tlv_tag; 804| 5.18k| uint8_t tlv_mode; 805| 5.18k| static ogs_tlv_desc_t* tlv_desc; 806| | 807| 5.18k| if ((msg_mode == OGS_TLV_MODE_T2_L2 && size < 2) || size < 1) ------------------ | | 35| 10.3k|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (807:10): [True: 0, False: 5.18k] | Branch (807:44): [True: 0, False: 0] | Branch (807:57): [True: 0, False: 5.18k] ------------------ 808| 0| return NULL; 809| | 810| 5.18k| tlv_tag = parse_get_element_type(blk, msg_mode); 811| 5.18k| instance = 0; /* TODO: support instance != 0 if ever really needed by looking it up in pos */ 812| 5.18k| tlv_tag_pos = 0; /* All tags with same instance should use the same tlv_desc, so take the first one */ 813| 5.18k| tlv_desc = tlv_find_desc_by_type_inst(&desc_index, &tlv_offset, desc, tlv_tag, instance, tlv_tag_pos); 814| 5.18k| if (!tlv_desc) { ------------------ | Branch (814:9): [True: 390, False: 4.79k] ------------------ 815| | /* 816| | * TS 29.060 11.1.9: An unknown TLV IE (type >= 128) is skipped 817| | * using its length. An unknown TV IE has no length to skip. 818| | */ 819| 390| if (tlv_tag >= 128) ------------------ | Branch (819:13): [True: 301, False: 89] ------------------ 820| 301| return tlv_get_element(tlv, blk, size, msg_mode); 821| | 822| 89| ogs_error("Can't parse find TLV description for type %u", tlv_tag); ------------------ | | 36| 89|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 89| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 89|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 89| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 89|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 89| 0, __VA_ARGS__) | | ------------------ ------------------ 823| 89| return NULL; 824| 390| } 825| 4.79k| tlv_mode = tlv_ctype2mode(tlv_desc->ctype, msg_mode); 826| | 827| 4.79k| if (tlv_mode == OGS_TLV_MODE_T1) ------------------ | | 36| 4.79k|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (827:9): [True: 2.99k, False: 1.79k] ------------------ 828| 2.99k| return tlv_get_element_fixed( 829| 2.99k| tlv, blk, size, tlv_mode, tlv_desc->length); 830| 1.79k| return tlv_get_element(tlv, blk, size, tlv_mode); 831| 4.79k|} ogs-tlv-msg.c:parse_get_element_type: 771| 5.18k|{ 772| 5.18k| uint16_t type; 773| | 774| 5.18k| 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: 5.18k] ------------------ 776| 5.18k| case OGS_TLV_MODE_T1_L2: ------------------ | | 33| 5.18k|#define OGS_TLV_MODE_T1_L2 2 ------------------ | Branch (776:5): [True: 5.18k, False: 0] ------------------ 777| 5.18k| case OGS_TLV_MODE_T1_L2_I1: ------------------ | | 34| 5.18k|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ | Branch (777:5): [True: 0, False: 5.18k] ------------------ 778| 5.18k| case OGS_TLV_MODE_T1: ------------------ | | 36| 5.18k|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (778:5): [True: 0, False: 5.18k] ------------------ 779| 5.18k| type = *pos; 780| 5.18k| break; 781| 0| case OGS_TLV_MODE_T2_L2: ------------------ | | 35| 0|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (781:5): [True: 0, False: 5.18k] ------------------ 782| 0| type = *(pos++) << 8; 783| 0| type += *(pos++); 784| 0| break; 785| 0| default: ------------------ | Branch (785:5): [True: 0, False: 5.18k] ------------------ 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| 5.18k| } 789| | 790| 5.18k| return type; 791| 5.18k|} ogs_tlv_get: 30| 13.5k|{ 31| 13.5k| ogs_tlv_t *tlv = NULL; 32| | 33| | /* get tlv node from node pool */ 34| 13.5k| ogs_pool_alloc(&pool, &tlv); ------------------ | | 132| 13.5k|#define ogs_pool_alloc(pool, node) do { \ | | 133| 13.5k| *(node) = NULL; \ | | 134| 13.5k| if ((pool)->avail > 0) { \ | | ------------------ | | | Branch (134:9): [True: 13.5k, False: 0] | | ------------------ | | 135| 13.5k| (pool)->avail--; \ | | 136| 13.5k| *(node) = (void*)(pool)->free[(pool)->head]; \ | | 137| 13.5k| (pool)->free[(pool)->head] = NULL; \ | | 138| 13.5k| (pool)->head = ((pool)->head + 1) % ((pool)->size); \ | | 139| 13.5k| (pool)->index[ogs_pool_index(pool, *(node))-1] = *(node); \ | | ------------------ | | | | 152| 13.5k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 140| 13.5k| } \ | | 141| 13.5k|} while (0) | | ------------------ | | | Branch (141:10): [Folded, False: 13.5k] | | ------------------ ------------------ 35| | 36| | /* check for error */ 37| 13.5k| if (!tlv) { ------------------ | Branch (37:9): [True: 0, False: 13.5k] ------------------ 38| 0| ogs_error("ogs_tlv_get() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 39| 0| return NULL; 40| 0| } 41| | 42| | /* initialize tlv node */ 43| 13.5k| memset(tlv, 0, sizeof(ogs_tlv_t)); 44| 13.5k| return tlv; 45| 13.5k|} ogs_tlv_free: 48| 13.5k|{ 49| | /* free tlv node to the node pool */ 50| | ogs_pool_free(&pool, tlv); ------------------ | | 143| 13.5k|#define ogs_pool_free(pool, node) do { \ | | 144| 13.5k| if ((pool)->avail < (pool)->size) { \ | | ------------------ | | | Branch (144:9): [True: 13.5k, False: 0] | | ------------------ | | 145| 13.5k| (pool)->avail++; \ | | 146| 13.5k| (pool)->free[(pool)->tail] = (void*)(node); \ | | 147| 13.5k| (pool)->tail = ((pool)->tail + 1) % ((pool)->size); \ | | 148| 13.5k| (pool)->index[ogs_pool_index(pool, node)-1] = NULL; \ | | ------------------ | | | | 152| 13.5k|#define ogs_pool_index(pool, node) (((node) - (pool)->array)+1) | | ------------------ | | 149| 13.5k| } \ | | 150| 13.5k|} while (0) | | ------------------ | | | Branch (150:10): [Folded, False: 13.5k] | | ------------------ ------------------ 51| 13.5k|} ogs_tlv_init: 54| 1|{ 55| | ogs_pool_init(&pool, ogs_core()->tlv.pool); ------------------ | | 52| 1|#define ogs_pool_init(pool, _size) do { \ | | 53| 1| int i; \ | | 54| 1| (pool)->name = #pool; \ | | 55| 1| (pool)->free = malloc(sizeof(*(pool)->free) * _size); \ | | 56| 1| ogs_assert((pool)->free); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 57| 1| (pool)->array = malloc(sizeof(*(pool)->array) * _size); \ | | 58| 1| ogs_assert((pool)->array); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 59| 1| (pool)->index = malloc(sizeof(*(pool)->index) * _size); \ | | 60| 1| ogs_assert((pool)->index); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 61| 1| (pool)->size = (pool)->avail = _size; \ | | 62| 1| (pool)->head = (pool)->tail = 0; \ | | 63| 513| for (i = 0; i < _size; i++) { \ | | ------------------ | | | Branch (63:17): [True: 512, False: 1] | | ------------------ | | 64| 512| (pool)->free[i] = &((pool)->array[i]); \ | | 65| 512| (pool)->index[i] = NULL; \ | | 66| 512| } \ | | 67| 1| \ | | 68| 1| (pool)->id_hash = ogs_hash_make(); \ | | 69| 1| ogs_assert((pool)->id_hash); \ | | ------------------ | | | | 113| 1| do { \ | | | | 114| 1| if (ogs_likely(expr)) ; \ | | | | ------------------ | | | | | | 54| 1|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | | | ------------------ | | | | | | | Branch (54:23): [True: 1, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 115| 1| else { \ | | | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | | | ------------------ | | | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | | | ------------------ | | | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | | | ------------------ | | | | | | | | | | 24| 0|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | | | | | ------------------ | | | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | | | ------------------ | | | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | | | ------------------ | | | | | | | | 45| 0| 0, __VA_ARGS__) | | | | | | ------------------ | | | | ------------------ | | | | 117| 0| ogs_abort(); \ | | | | 118| 0| } \ | | | | 119| 1| } while(0) | | | | ------------------ | | | | | Branch (119:13): [Folded, False: 1] | | | | ------------------ | | ------------------ | | 70| 1|} while (0) | | ------------------ | | | Branch (70:10): [Folded, False: 1] | | ------------------ ------------------ 56| 1|} ogs_tlv_free_all: 69| 2.87k|{ 70| | /* free all tlv node to the node pool */ 71| 2.87k| ogs_tlv_t *iter = root; 72| 2.87k| ogs_tlv_t *next = NULL; 73| 16.4k| while (iter) { ------------------ | Branch (73:12): [True: 13.5k, False: 2.87k] ------------------ 74| 13.5k| if(iter->embedded != NULL) { ------------------ | Branch (74:12): [True: 812, False: 12.7k] ------------------ 75| 812| ogs_tlv_free_all(iter->embedded); 76| 812| } 77| 13.5k| next = iter->next; 78| 13.5k| ogs_tlv_free(iter); 79| 13.5k| iter = next; 80| 13.5k| } 81| 2.87k|} tlv_get_element: 224| 10.4k|{ 225| 10.4k| uint8_t *pos = blk; 226| 10.4k| uint32_t header_length; 227| | 228| 10.4k| tlv->mode = mode; 229| | 230| 10.4k| 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: 10.4k] ------------------ 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| 2.09k| case OGS_TLV_MODE_T1_L2: ------------------ | | 33| 2.09k|#define OGS_TLV_MODE_T1_L2 2 ------------------ | Branch (238:5): [True: 2.09k, False: 8.40k] ------------------ 239| 2.09k| header_length = 3; 240| 2.09k| if (size < header_length) ------------------ | Branch (240:13): [True: 49, False: 2.04k] ------------------ 241| 49| return NULL; 242| 2.04k| tlv->type = *(pos++); 243| 2.04k| tlv->length = *(pos++) << 8; 244| 2.04k| tlv->length += *(pos++); 245| 2.04k| break; 246| 8.40k| case OGS_TLV_MODE_T1_L2_I1: ------------------ | | 34| 8.40k|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ | Branch (246:5): [True: 8.40k, False: 2.09k] ------------------ 247| 8.40k| header_length = 4; 248| 8.40k| if (size < header_length) ------------------ | Branch (248:13): [True: 67, False: 8.33k] ------------------ 249| 67| return NULL; 250| 8.33k| tlv->type = *(pos++); 251| 8.33k| tlv->length = *(pos++) << 8; 252| 8.33k| tlv->length += *(pos++); 253| 8.33k| tlv->instance = *(pos++) & 0b00001111; 254| 8.33k| break; 255| 0| case OGS_TLV_MODE_T2_L2: ------------------ | | 35| 0|#define OGS_TLV_MODE_T2_L2 4 ------------------ | Branch (255:5): [True: 0, False: 10.4k] ------------------ 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: 10.4k] ------------------ 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: 10.4k] ------------------ 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| 10.4k| } 275| | 276| 10.3k| if (tlv->length > size - header_length) ------------------ | Branch (276:9): [True: 94, False: 10.2k] ------------------ 277| 94| return NULL; 278| | 279| 10.2k| tlv->value = pos; 280| | 281| 10.2k| return (pos + ogs_tlv_length(tlv)); ------------------ | | 67| 10.2k|#define ogs_tlv_length(pTlv) pTlv->length ------------------ 282| 10.3k|} tlv_get_element_fixed: 286| 2.99k|{ 287| 2.99k| uint8_t *pos = blk; 288| | 289| 2.99k| switch(mode) { 290| 2.99k| case OGS_TLV_MODE_T1: ------------------ | | 36| 2.99k|#define OGS_TLV_MODE_T1 5 ------------------ | Branch (290:5): [True: 2.99k, False: 0] ------------------ 291| 2.99k| if (size < 1 || fixed_length > size - 1) ------------------ | Branch (291:13): [True: 0, False: 2.99k] | Branch (291:25): [True: 54, False: 2.94k] ------------------ 292| 54| return NULL; 293| 2.94k| tlv->type = *(pos++); 294| 2.94k| tlv->length = fixed_length; 295| 2.94k| break; 296| 0| default: ------------------ | Branch (296:5): [True: 0, False: 2.99k] ------------------ 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| 2.99k| } 300| | 301| 2.94k| tlv->value = pos; 302| | 303| 2.94k| return (pos + ogs_tlv_length(tlv)); ------------------ | | 67| 2.94k|#define ogs_tlv_length(pTlv) pTlv->length ------------------ 304| 2.99k|} ogs_tlv_parse_block: 465| 1.65k|{ 466| 1.65k| uint8_t *pos = data; 467| 1.65k| uint8_t *blk = data; 468| | 469| 1.65k| ogs_tlv_t *root = NULL; 470| 1.65k| ogs_tlv_t *prev = NULL; 471| 1.65k| ogs_tlv_t *curr = NULL; 472| | 473| 1.65k| root = curr = ogs_tlv_get(); 474| 1.65k| if (!curr) { ------------------ | Branch (474:9): [True: 0, False: 1.65k] ------------------ 475| 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__) | | ------------------ ------------------ 476| 0| length, mode); 477| |/* 478| | * Limit hexdump size to avoid excessive logging when handling malformed 479| | * or intentionally crafted messages. This prevents log flooding and 480| | * secondary DoS effects while still providing enough data for debugging. 481| | */ 482| 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] | | ------------------ ------------------ 483| 0| return NULL; 484| 0| } 485| | 486| 1.65k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 487| 1.65k| if (!pos) { ------------------ | Branch (487:9): [True: 73, False: 1.58k] ------------------ 488| 73| ogs_error("ogs_tlv_parse_block() failed[LEN:%u,MODE:%u] - parse error", ------------------ | | 36| 73|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 73| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 73|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 73| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 73|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 73| 0, __VA_ARGS__) | | ------------------ ------------------ 489| 73| length, mode); 490| |/* 491| | * Limit hexdump size to avoid excessive logging when handling malformed 492| | * or intentionally crafted messages. This prevents log flooding and 493| | * secondary DoS effects while still providing enough data for debugging. 494| | */ 495| 73| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 146| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 73|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 71, False: 2] | | ------------------ ------------------ 496| 73| ogs_tlv_free_all(root); 497| 73| return NULL; 498| 73| } 499| | 500| 8.28k| while(pos - blk < length) { ------------------ | Branch (500:11): [True: 6.74k, False: 1.54k] ------------------ 501| 6.74k| prev = curr; 502| | 503| 6.74k| curr = ogs_tlv_get(); 504| 6.74k| if (!curr) { ------------------ | Branch (504:13): [True: 0, False: 6.74k] ------------------ 505| 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__) | | ------------------ ------------------ 506| 0| length, mode); 507| |/* 508| | * Limit hexdump size to avoid excessive logging when handling malformed 509| | * or intentionally crafted messages. This prevents log flooding and 510| | * secondary DoS effects while still providing enough data for debugging. 511| | */ 512| 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] | | ------------------ ------------------ 513| | 514| 0| ogs_tlv_free_all(root); 515| 0| return NULL; 516| 0| } 517| 6.74k| prev->next = curr; 518| | 519| 6.74k| pos = tlv_get_element(curr, pos, length - (uint32_t)(pos - blk), mode); 520| 6.74k| if (!pos) { ------------------ | Branch (520:13): [True: 42, False: 6.70k] ------------------ 521| 42| ogs_error("ogs_tlv_parse_block() failed[LEN:%d,MODE:%d]", ------------------ | | 36| 42|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 42| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 24| 42|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | | | ------------------ | | | | 44| 42| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 42|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 42| 0, __VA_ARGS__) | | ------------------ ------------------ 522| 42| length, mode); 523| |/* 524| | * Limit hexdump size to avoid excessive logging when handling malformed 525| | * or intentionally crafted messages. This prevents log flooding and 526| | * secondary DoS effects while still providing enough data for debugging. 527| | */ 528| 42| ogs_log_hexdump(OGS_LOG_ERROR, data, ogs_min(length, 512)); ------------------ | | 53| 84| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 24| 42|#define OGS_LOG_DOMAIN __ogs_tlv_domain | | ------------------ | | | Branch (53:53): [True: 36, False: 6] | | ------------------ ------------------ 529| | 530| 42| ogs_tlv_free_all(root); 531| 42| return NULL; 532| 42| } 533| 6.74k| } 534| | 535| 1.54k| if (length != (pos - blk)) { ------------------ | Branch (535:9): [True: 0, False: 1.54k] ------------------ 536| 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__) | | ------------------ ------------------ 537| 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__) | | ------------------ ------------------ 538| 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] | | ------------------ ------------------ 539| | 540| 0| ogs_tlv_free_all(root); 541| 0| return NULL; 542| 0| } 543| | 544| 1.54k| return root; 545| 1.54k|} ogs_tlv_parse_embedded_block: 548| 827|{ 549| 827| tlv->embedded = ogs_tlv_parse_block(tlv->length, tlv->value, mode); 550| | 551| 827| return tlv->embedded; 552| 827|} ogs_gtp1_eua_ietf_type_to_pdu_session_type: 122| 265|{ 123| 265| switch (eua_ietf_type) { 124| 74| case OGS_PDP_EUA_IETF_IPV4: ------------------ | | 412| 74|#define OGS_PDP_EUA_IETF_IPV4 0x21 ------------------ | Branch (124:5): [True: 74, False: 191] ------------------ 125| 74| return OGS_PDU_SESSION_TYPE_IPV4; ------------------ | | 662| 74|#define OGS_PDU_SESSION_TYPE_IPV4 1 ------------------ 126| 40| case OGS_PDP_EUA_IETF_IPV6: ------------------ | | 413| 40|#define OGS_PDP_EUA_IETF_IPV6 0x57 ------------------ | Branch (126:5): [True: 40, False: 225] ------------------ 127| 40| return OGS_PDU_SESSION_TYPE_IPV6; ------------------ | | 663| 40|#define OGS_PDU_SESSION_TYPE_IPV6 2 ------------------ 128| 98| case OGS_PDP_EUA_IETF_IPV4V6: ------------------ | | 414| 98|#define OGS_PDP_EUA_IETF_IPV4V6 0x8D ------------------ | Branch (128:5): [True: 98, False: 167] ------------------ 129| 98| return OGS_PDU_SESSION_TYPE_IPV4V6; ------------------ | | 664| 98|#define OGS_PDU_SESSION_TYPE_IPV4V6 3 ------------------ 130| 53| default: ------------------ | Branch (130:5): [True: 53, False: 212] ------------------ 131| 53| return OGS_ERROR; ------------------ | | 78| 53|#define OGS_ERROR -1 ------------------ 132| 265| } 133| 265|} ogs_gtp1_parse_msg: 2283| 1.24k|{ 2284| 1.24k| int rv = OGS_ERROR; ------------------ | | 78| 1.24k|#define OGS_ERROR -1 ------------------ 2285| 1.24k| ogs_gtp1_header_t *h = NULL; 2286| 1.24k| uint16_t size = 0; 2287| | 2288| 1.24k| ogs_assert(gtp1_message); ------------------ | | 113| 1.24k| do { \ | | 114| 1.24k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.24k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.24k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.24k| 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.24k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.24k] | | ------------------ ------------------ 2289| 1.24k| ogs_assert(pkbuf); ------------------ | | 113| 1.24k| do { \ | | 114| 1.24k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.24k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.24k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.24k| 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.24k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.24k] | | ------------------ ------------------ 2290| 1.24k| ogs_assert(pkbuf->len); ------------------ | | 113| 1.24k| do { \ | | 114| 1.24k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.24k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.24k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.24k| 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.24k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.24k] | | ------------------ ------------------ 2291| | 2292| 1.24k| h = (ogs_gtp1_header_t *)pkbuf->data; 2293| 1.24k| ogs_assert(h); ------------------ | | 113| 1.24k| do { \ | | 114| 1.24k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.24k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.24k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.24k| 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.24k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.24k] | | ------------------ ------------------ 2294| | 2295| 1.24k| memset(gtp1_message, 0, sizeof(ogs_gtp1_message_t)); 2296| | 2297| 1.24k| if (h->e || h->s || h->pn) ------------------ | Branch (2297:9): [True: 7, False: 1.23k] | Branch (2297:17): [True: 3, False: 1.23k] | Branch (2297:25): [True: 5, False: 1.22k] ------------------ 2298| 15| size = OGS_GTPV1C_HEADER_LEN; ------------------ | | 42| 15|#define OGS_GTPV1C_HEADER_LEN 12 ------------------ 2299| 1.22k| else 2300| 1.22k| size = OGS_GTPV1C_HEADER_LEN - 4; ------------------ | | 42| 1.22k|#define OGS_GTPV1C_HEADER_LEN 12 ------------------ 2301| | 2302| 1.24k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2302:9): [True: 8, False: 1.23k] ------------------ 2303| 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__) | | ------------------ ------------------ 2304| 8| return OGS_ERROR; ------------------ | | 78| 8|#define OGS_ERROR -1 ------------------ 2305| 8| } 2306| 1.23k| memcpy(>p1_message->h, pkbuf->data - size, size); 2307| | 2308| 1.23k| gtp1_message->h.teid = be32toh(gtp1_message->h.teid); 2309| | 2310| 1.23k| if (pkbuf->len == 0) { ------------------ | Branch (2310:9): [True: 4, False: 1.22k] ------------------ 2311| 4| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 4| do { \ | | 114| 4| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4, False: 0] | | | | ------------------ | | ------------------ | | 115| 4| 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| 4| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 4] | | ------------------ ------------------ 2312| 4| return OGS_OK; ------------------ | | 77| 4|#define OGS_OK 0 ------------------ 2313| 4| } 2314| | 2315| 1.22k| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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| 274| case OGS_GTP1_CREATE_PDP_CONTEXT_REQUEST_TYPE: ------------------ | | 90| 274|#define OGS_GTP1_CREATE_PDP_CONTEXT_REQUEST_TYPE 16 ------------------ | Branch (2322:5): [True: 274, False: 954] ------------------ 2323| 274| rv = ogs_tlv_parse_msg_desc(>p1_message->create_pdp_context_request, 2324| 274| &ogs_gtp1_tlv_desc_create_pdp_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 274|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2325| 274| break; 2326| 30| case OGS_GTP1_CREATE_PDP_CONTEXT_RESPONSE_TYPE: ------------------ | | 91| 30|#define OGS_GTP1_CREATE_PDP_CONTEXT_RESPONSE_TYPE 17 ------------------ | Branch (2326:5): [True: 30, False: 1.19k] ------------------ 2327| 30| rv = ogs_tlv_parse_msg_desc(>p1_message->create_pdp_context_response, 2328| 30| &ogs_gtp1_tlv_desc_create_pdp_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 30|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2329| 30| break; 2330| 35| case OGS_GTP1_UPDATE_PDP_CONTEXT_REQUEST_TYPE: ------------------ | | 92| 35|#define OGS_GTP1_UPDATE_PDP_CONTEXT_REQUEST_TYPE 18 ------------------ | Branch (2330:5): [True: 35, False: 1.19k] ------------------ 2331| 35| rv = ogs_tlv_parse_msg_desc(>p1_message->update_pdp_context_request, 2332| 35| &ogs_gtp1_tlv_desc_update_pdp_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 35|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2333| 35| break; 2334| 10| case OGS_GTP1_UPDATE_PDP_CONTEXT_RESPONSE_TYPE: ------------------ | | 93| 10|#define OGS_GTP1_UPDATE_PDP_CONTEXT_RESPONSE_TYPE 19 ------------------ | Branch (2334:5): [True: 10, False: 1.21k] ------------------ 2335| 10| rv = ogs_tlv_parse_msg_desc(>p1_message->update_pdp_context_response, 2336| 10| &ogs_gtp1_tlv_desc_update_pdp_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 10|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2337| 10| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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| 1| case OGS_GTP1_PDU_NOTIFICATION_REQUEST_TYPE: ------------------ | | 99| 1|#define OGS_GTP1_PDU_NOTIFICATION_REQUEST_TYPE 27 ------------------ | Branch (2354:5): [True: 1, False: 1.22k] ------------------ 2355| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_request, 2356| 1| &ogs_gtp1_tlv_desc_pdu_notification_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2357| 1| break; 2358| 2| case OGS_GTP1_PDU_NOTIFICATION_RESPONSE_TYPE: ------------------ | | 100| 2|#define OGS_GTP1_PDU_NOTIFICATION_RESPONSE_TYPE 28 ------------------ | Branch (2358:5): [True: 2, False: 1.22k] ------------------ 2359| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_response, 2360| 2| &ogs_gtp1_tlv_desc_pdu_notification_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2361| 2| break; 2362| 3| case OGS_GTP1_PDU_NOTIFICATION_REJECT_REQUEST_TYPE: ------------------ | | 101| 3|#define OGS_GTP1_PDU_NOTIFICATION_REJECT_REQUEST_TYPE 29 ------------------ | Branch (2362:5): [True: 3, False: 1.22k] ------------------ 2363| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_reject_request, 2364| 3| &ogs_gtp1_tlv_desc_pdu_notification_reject_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2365| 3| break; 2366| 2| case OGS_GTP1_PDU_NOTIFICATION_REJECT_RESPONSE_TYPE: ------------------ | | 102| 2|#define OGS_GTP1_PDU_NOTIFICATION_REJECT_RESPONSE_TYPE 30 ------------------ | Branch (2366:5): [True: 2, False: 1.22k] ------------------ 2367| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->pdu_notification_reject_response, 2368| 2| &ogs_gtp1_tlv_desc_pdu_notification_reject_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2369| 2| break; 2370| 2| case OGS_GTP1_SUPPORTED_EXTENSION_HEADERS_NOTIFICATION_TYPE: ------------------ | | 103| 2|#define OGS_GTP1_SUPPORTED_EXTENSION_HEADERS_NOTIFICATION_TYPE 31 ------------------ | Branch (2370:5): [True: 2, False: 1.22k] ------------------ 2371| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->supported_extension_headers_notification, 2372| 2| &ogs_gtp1_tlv_desc_supported_extension_headers_notification, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2373| 2| break; 2374| 4| case OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_REQUEST_TYPE: ------------------ | | 104| 4|#define OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_REQUEST_TYPE 32 ------------------ | Branch (2374:5): [True: 4, False: 1.22k] ------------------ 2375| 4| rv = ogs_tlv_parse_msg_desc(>p1_message->send_routeing_information_for_gprs_request, 2376| 4| &ogs_gtp1_tlv_desc_send_routeing_information_for_gprs_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 4|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2377| 4| break; 2378| 18| case OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_RESPONSE_TYPE: ------------------ | | 105| 18|#define OGS_GTP1_SEND_ROUTEING_INFORMATION_FOR_GPRS_RESPONSE_TYPE 33 ------------------ | Branch (2378:5): [True: 18, False: 1.21k] ------------------ 2379| 18| rv = ogs_tlv_parse_msg_desc(>p1_message->send_routeing_information_for_gprs_response, 2380| 18| &ogs_gtp1_tlv_desc_send_routeing_information_for_gprs_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 18|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2381| 18| 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: 1.22k] ------------------ 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| 4| case OGS_GTP1_FAILURE_REPORT_RESPONSE_TYPE: ------------------ | | 107| 4|#define OGS_GTP1_FAILURE_REPORT_RESPONSE_TYPE 35 ------------------ | Branch (2386:5): [True: 4, False: 1.22k] ------------------ 2387| 4| rv = ogs_tlv_parse_msg_desc(>p1_message->failure_report_response, 2388| 4| &ogs_gtp1_tlv_desc_failure_report_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 4|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2389| 4| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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| 5| case OGS_GTP1_IDENTIFICATION_REQUEST_TYPE: ------------------ | | 110| 5|#define OGS_GTP1_IDENTIFICATION_REQUEST_TYPE 48 ------------------ | Branch (2398:5): [True: 5, False: 1.22k] ------------------ 2399| 5| rv = ogs_tlv_parse_msg_desc(>p1_message->identification_request, 2400| 5| &ogs_gtp1_tlv_desc_identification_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 5|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2401| 5| break; 2402| 12| case OGS_GTP1_IDENTIFICATION_RESPONSE_TYPE: ------------------ | | 111| 12|#define OGS_GTP1_IDENTIFICATION_RESPONSE_TYPE 49 ------------------ | Branch (2402:5): [True: 12, False: 1.21k] ------------------ 2403| 12| rv = ogs_tlv_parse_msg_desc(>p1_message->identification_response, 2404| 12| &ogs_gtp1_tlv_desc_identification_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 12|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2405| 12| break; 2406| 14| case OGS_GTP1_SGSN_CONTEXT_REQUEST_TYPE: ------------------ | | 112| 14|#define OGS_GTP1_SGSN_CONTEXT_REQUEST_TYPE 50 ------------------ | Branch (2406:5): [True: 14, False: 1.21k] ------------------ 2407| 14| rv = ogs_tlv_parse_msg_desc(>p1_message->sgsn_context_request, 2408| 14| &ogs_gtp1_tlv_desc_sgsn_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 14|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2409| 14| break; 2410| 731| case OGS_GTP1_SGSN_CONTEXT_RESPONSE_TYPE: ------------------ | | 113| 731|#define OGS_GTP1_SGSN_CONTEXT_RESPONSE_TYPE 51 ------------------ | Branch (2410:5): [True: 731, False: 497] ------------------ 2411| 731| rv = ogs_tlv_parse_msg_desc(>p1_message->sgsn_context_response, 2412| 731| &ogs_gtp1_tlv_desc_sgsn_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 731|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2413| 731| break; 2414| 3| case OGS_GTP1_SGSN_CONTEXT_ACKNOWLEDGE_TYPE: ------------------ | | 114| 3|#define OGS_GTP1_SGSN_CONTEXT_ACKNOWLEDGE_TYPE 52 ------------------ | Branch (2414:5): [True: 3, False: 1.22k] ------------------ 2415| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->sgsn_context_acknowledge, 2416| 3| &ogs_gtp1_tlv_desc_sgsn_context_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2417| 3| break; 2418| 4| case OGS_GTP1_FORWARD_RELOCATION_REQUEST_TYPE: ------------------ | | 115| 4|#define OGS_GTP1_FORWARD_RELOCATION_REQUEST_TYPE 53 ------------------ | Branch (2418:5): [True: 4, False: 1.22k] ------------------ 2419| 4| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_relocation_request, 2420| 4| &ogs_gtp1_tlv_desc_forward_relocation_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 4|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2421| 4| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 2427| 1| break; 2428| 2| case OGS_GTP1_RELOCATION_CANCEL_REQUEST_TYPE: ------------------ | | 118| 2|#define OGS_GTP1_RELOCATION_CANCEL_REQUEST_TYPE 56 ------------------ | Branch (2428:5): [True: 2, False: 1.22k] ------------------ 2429| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->relocation_cancel_request, 2430| 2| &ogs_gtp1_tlv_desc_relocation_cancel_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2431| 2| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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| 3| case OGS_GTP1_FORWARD_RELOCATION_COMPLETE_ACKNOWLEDGE_TYPE: ------------------ | | 121| 3|#define OGS_GTP1_FORWARD_RELOCATION_COMPLETE_ACKNOWLEDGE_TYPE 59 ------------------ | Branch (2440:5): [True: 3, False: 1.22k] ------------------ 2441| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_relocation_complete_acknowledge, 2442| 3| &ogs_gtp1_tlv_desc_forward_relocation_complete_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2443| 3| break; 2444| 3| case OGS_GTP1_FORWARD_SRNS_CONTEXT_ACKNOWLEDGE_TYPE: ------------------ | | 122| 3|#define OGS_GTP1_FORWARD_SRNS_CONTEXT_ACKNOWLEDGE_TYPE 60 ------------------ | Branch (2444:5): [True: 3, False: 1.22k] ------------------ 2445| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->forward_srns_context_acknowledge, 2446| 3| &ogs_gtp1_tlv_desc_forward_srns_context_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2447| 3| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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| 3| case OGS_GTP1_MBMS_NOTIFICATION_REQUEST_TYPE: ------------------ | | 126| 3|#define OGS_GTP1_MBMS_NOTIFICATION_REQUEST_TYPE 96 ------------------ | Branch (2460:5): [True: 3, False: 1.22k] ------------------ 2461| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_notification_request, 2462| 3| &ogs_gtp1_tlv_desc_mbms_notification_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2463| 3| 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: 1.22k] ------------------ 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| 2| case OGS_GTP1_MBMS_NOTIFICATION_REJECT_REQUEST_TYPE: ------------------ | | 128| 2|#define OGS_GTP1_MBMS_NOTIFICATION_REJECT_REQUEST_TYPE 98 ------------------ | Branch (2468:5): [True: 2, False: 1.22k] ------------------ 2469| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_notification_reject_request, 2470| 2| &ogs_gtp1_tlv_desc_mbms_notification_reject_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2471| 2| break; 2472| 1| case OGS_GTP1_MBMS_NOTIFICATION_REJECT_RESPONSE_TYPE: ------------------ | | 129| 1|#define OGS_GTP1_MBMS_NOTIFICATION_REJECT_RESPONSE_TYPE 99 ------------------ | Branch (2472:5): [True: 1, False: 1.22k] ------------------ 2473| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_notification_reject_response, 2474| 1| &ogs_gtp1_tlv_desc_mbms_notification_reject_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2475| 1| break; 2476| 3| case OGS_GTP1_CREATE_MBMS_CONTEXT_REQUEST_TYPE: ------------------ | | 130| 3|#define OGS_GTP1_CREATE_MBMS_CONTEXT_REQUEST_TYPE 100 ------------------ | Branch (2476:5): [True: 3, False: 1.22k] ------------------ 2477| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->create_mbms_context_request, 2478| 3| &ogs_gtp1_tlv_desc_create_mbms_context_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2479| 3| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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| 2| case OGS_GTP1_UPDATE_MBMS_CONTEXT_RESPONSE_TYPE: ------------------ | | 133| 2|#define OGS_GTP1_UPDATE_MBMS_CONTEXT_RESPONSE_TYPE 103 ------------------ | Branch (2488:5): [True: 2, False: 1.22k] ------------------ 2489| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->update_mbms_context_response, 2490| 2| &ogs_gtp1_tlv_desc_update_mbms_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2491| 2| 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: 1.22k] ------------------ 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| 1| case OGS_GTP1_DELETE_MBMS_CONTEXT_RESPONSE_TYPE: ------------------ | | 135| 1|#define OGS_GTP1_DELETE_MBMS_CONTEXT_RESPONSE_TYPE 105 ------------------ | Branch (2496:5): [True: 1, False: 1.22k] ------------------ 2497| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->delete_mbms_context_response, 2498| 1| &ogs_gtp1_tlv_desc_delete_mbms_context_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2499| 1| 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: 1.22k] ------------------ 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: 1.22k] ------------------ 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| 3| case OGS_GTP1_MBMS_DE_REGISTRATION_REQUEST_TYPE: ------------------ | | 138| 3|#define OGS_GTP1_MBMS_DE_REGISTRATION_REQUEST_TYPE 114 ------------------ | Branch (2508:5): [True: 3, False: 1.22k] ------------------ 2509| 3| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_de_registration_request, 2510| 3| &ogs_gtp1_tlv_desc_mbms_de_registration_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 3|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2511| 3| break; 2512| 2| case OGS_GTP1_MBMS_DE_REGISTRATION_RESPONSE_TYPE: ------------------ | | 139| 2|#define OGS_GTP1_MBMS_DE_REGISTRATION_RESPONSE_TYPE 115 ------------------ | Branch (2512:5): [True: 2, False: 1.22k] ------------------ 2513| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_de_registration_response, 2514| 2| &ogs_gtp1_tlv_desc_mbms_de_registration_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2515| 2| break; 2516| 4| case OGS_GTP1_MBMS_SESSION_START_REQUEST_TYPE: ------------------ | | 140| 4|#define OGS_GTP1_MBMS_SESSION_START_REQUEST_TYPE 116 ------------------ | Branch (2516:5): [True: 4, False: 1.22k] ------------------ 2517| 4| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_start_request, 2518| 4| &ogs_gtp1_tlv_desc_mbms_session_start_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 4|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2519| 4| break; 2520| 2| case OGS_GTP1_MBMS_SESSION_START_RESPONSE_TYPE: ------------------ | | 141| 2|#define OGS_GTP1_MBMS_SESSION_START_RESPONSE_TYPE 117 ------------------ | Branch (2520:5): [True: 2, False: 1.22k] ------------------ 2521| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_start_response, 2522| 2| &ogs_gtp1_tlv_desc_mbms_session_start_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2523| 2| break; 2524| 1| case OGS_GTP1_MBMS_SESSION_STOP_REQUEST_TYPE: ------------------ | | 142| 1|#define OGS_GTP1_MBMS_SESSION_STOP_REQUEST_TYPE 118 ------------------ | Branch (2524:5): [True: 1, False: 1.22k] ------------------ 2525| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_stop_request, 2526| 1| &ogs_gtp1_tlv_desc_mbms_session_stop_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2527| 1| break; 2528| 2| case OGS_GTP1_MBMS_SESSION_STOP_RESPONSE_TYPE: ------------------ | | 143| 2|#define OGS_GTP1_MBMS_SESSION_STOP_RESPONSE_TYPE 119 ------------------ | Branch (2528:5): [True: 2, False: 1.22k] ------------------ 2529| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_stop_response, 2530| 2| &ogs_gtp1_tlv_desc_mbms_session_stop_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2531| 2| break; 2532| 2| case OGS_GTP1_MBMS_SESSION_UPDATE_REQUEST_TYPE: ------------------ | | 144| 2|#define OGS_GTP1_MBMS_SESSION_UPDATE_REQUEST_TYPE 120 ------------------ | Branch (2532:5): [True: 2, False: 1.22k] ------------------ 2533| 2| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_update_request, 2534| 2| &ogs_gtp1_tlv_desc_mbms_session_update_request, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 2|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2535| 2| break; 2536| 1| case OGS_GTP1_MBMS_SESSION_UPDATE_RESPONSE_TYPE: ------------------ | | 145| 1|#define OGS_GTP1_MBMS_SESSION_UPDATE_RESPONSE_TYPE 121 ------------------ | Branch (2536:5): [True: 1, False: 1.22k] ------------------ 2537| 1| rv = ogs_tlv_parse_msg_desc(>p1_message->mbms_session_update_response, 2538| 1| &ogs_gtp1_tlv_desc_mbms_session_update_response, pkbuf, OGS_TLV_MODE_T1_L2); ------------------ | | 33| 1|#define OGS_TLV_MODE_T1_L2 2 ------------------ 2539| 1| break; 2540| 4| default: ------------------ | Branch (2540:5): [True: 4, False: 1.22k] ------------------ 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| 1.22k| } 2544| | 2545| 1.22k| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 1.22k| do { \ | | 114| 1.22k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.22k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.22k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.22k| 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.22k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.22k] | | ------------------ ------------------ 2546| | 2547| 1.22k| return rv; 2548| 1.22k|} ogs_gtp1_parse_uli: 25| 39|{ 26| 39| ogs_gtp1_uli_t *source = (ogs_gtp1_uli_t *)octet->data; 27| 39| int16_t size = 0; 28| | 29| 39| ogs_assert(uli); ------------------ | | 113| 39| do { \ | | 114| 39| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 39|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 39, False: 0] | | | | ------------------ | | ------------------ | | 115| 39| 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| 39| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 39] | | ------------------ ------------------ 30| 39| ogs_assert(octet); ------------------ | | 113| 39| do { \ | | 114| 39| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 39|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 39, False: 0] | | | | ------------------ | | ------------------ | | 115| 39| 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| 39| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 39] | | ------------------ ------------------ 31| | 32| 39| memset(uli, 0, sizeof(ogs_gtp1_uli_t)); 33| | 34| 39| if (octet->len < 1) { ------------------ | Branch (34:9): [True: 0, False: 39] ------------------ 35| 0| ogs_error("ULI IE too short [%u]", octet->len); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 36| 0| return 0; 37| 0| } 38| | 39| 39| uli->geo_loc_type = source->geo_loc_type; 40| 39| size++; 41| | 42| 39| switch (uli->geo_loc_type) { 43| 13| case OGS_GTP1_GEO_LOC_TYPE_CGI: ------------------ | | 167| 13|#define OGS_GTP1_GEO_LOC_TYPE_CGI 0 ------------------ | Branch (43:5): [True: 13, False: 26] ------------------ 44| 13| if (size + (int)sizeof(uli->cgi) > octet->len) { ------------------ | Branch (44:13): [True: 4, False: 9] ------------------ 45| 4| ogs_error("ULI CGI too short [%d+%zu > %u]", ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 46| 4| size, sizeof(uli->cgi), octet->len); 47| 4| return 0; 48| 4| } 49| 9| memcpy(&uli->cgi, 50| 9| (unsigned char *)octet->data + size, sizeof(uli->cgi)); 51| 9| uli->cgi.lac = be16toh(uli->cgi.lac); 52| 9| uli->cgi.ci = be16toh(uli->cgi.ci); 53| 9| size += sizeof(uli->cgi); 54| 9| break; 55| 11| case OGS_GTP1_GEO_LOC_TYPE_SAI: ------------------ | | 168| 11|#define OGS_GTP1_GEO_LOC_TYPE_SAI 1 ------------------ | Branch (55:5): [True: 11, False: 28] ------------------ 56| 11| if (size + (int)sizeof(uli->sai) > octet->len) { ------------------ | Branch (56:13): [True: 4, False: 7] ------------------ 57| 4| ogs_error("ULI SAI too short [%d+%zu > %u]", ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 58| 4| size, sizeof(uli->sai), octet->len); 59| 4| return 0; 60| 4| } 61| 7| memcpy(&uli->sai, 62| 7| (unsigned char *)octet->data + size, sizeof(uli->sai)); 63| 7| uli->sai.lac = be16toh(uli->sai.lac); 64| 7| uli->sai.sac = be16toh(uli->sai.sac); 65| 7| size += sizeof(uli->sai); 66| 7| break; 67| 11| case OGS_GTP1_GEO_LOC_TYPE_RAI: ------------------ | | 169| 11|#define OGS_GTP1_GEO_LOC_TYPE_RAI 2 ------------------ | Branch (67:5): [True: 11, False: 28] ------------------ 68| 11| if (size + (int)sizeof(uli->rai) > octet->len) { ------------------ | Branch (68:13): [True: 4, False: 7] ------------------ 69| 4| ogs_error("ULI RAI too short [%d+%zu > %u]", ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 70| 4| size, sizeof(uli->rai), octet->len); 71| 4| return 0; 72| 4| } 73| 7| memcpy(&uli->rai, 74| 7| (unsigned char *)octet->data + size, sizeof(uli->rai)); 75| 7| uli->rai.lac = be16toh(uli->rai.lac); 76| 7| uli->rai.rac = be16toh(uli->rai.rac); //FIXME: Only the first octet (10) contains the RAC and the second octet (11) is coded as "11111111" 77| 7| size += sizeof(uli->rai); 78| 7| break; 79| 4| default: ------------------ | Branch (79:5): [True: 4, False: 35] ------------------ 80| 4| ogs_warn("Unknown Geographic Location Type 0x%x in User Location Information IE", ------------------ | | 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__) | | ------------------ ------------------ 81| 4| uli->geo_loc_type); 82| 4| return 0; 83| 39| } 84| | 85| 23| if (size != octet->len) { ------------------ | Branch (85:9): [True: 20, False: 3] ------------------ 86| 20| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", octet->len, size); ------------------ | | 36| 20|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 20|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 87| 20| return 0; 88| 20| } 89| | 90| 3| return size; 91| 23|} ogs_gtp1_parse_qos_profile: 197| 1.11k|{ 198| 1.11k| ogs_gtp1_qos_profile_t *source = (ogs_gtp1_qos_profile_t *)octet->data; 199| | 200| 1.11k| ogs_assert(decoded); ------------------ | | 113| 1.11k| do { \ | | 114| 1.11k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.11k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.11k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.11k| 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.11k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.11k] | | ------------------ ------------------ 201| 1.11k| ogs_assert(octet); ------------------ | | 113| 1.11k| do { \ | | 114| 1.11k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.11k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.11k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.11k| 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.11k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.11k] | | ------------------ ------------------ 202| | 203| 1.11k| memset(decoded, 0, sizeof(ogs_gtp1_qos_profile_decoded_t)); 204| 1.11k| switch (octet->len) { 205| 79| case 21: /* ARP + octet 3 + octet 3-22 */ ------------------ | Branch (205:5): [True: 79, False: 1.03k] ------------------ 206| 79| decoded->bit_rate_uplink_extended2_present = true; 207| 79| OGS_GNUC_FALLTHROUGH; 208| 159| case 19: /* ARP + octet 3 + octet 3-20 */ ------------------ | Branch (208:5): [True: 80, False: 1.03k] ------------------ 209| 159| decoded->bit_rate_downlink_extended2_present = true; 210| 159| OGS_GNUC_FALLTHROUGH; 211| 236| case 17: /* ARP + octet 3 + octet 3-18 */ ------------------ | Branch (211:5): [True: 77, False: 1.04k] ------------------ 212| 236| decoded->bit_rate_uplink_extended_present = true; 213| 236| OGS_GNUC_FALLTHROUGH; 214| 285| case 15: /* ARP + octet 3 + octet 3-16 */ ------------------ | Branch (214:5): [True: 49, False: 1.06k] ------------------ 215| 285| decoded->bit_rate_downlink_extended_present = true; 216| 285| OGS_GNUC_FALLTHROUGH; 217| 306| case 13: /* ARP + octet 3-14 */ ------------------ | Branch (217:5): [True: 21, False: 1.09k] ------------------ 218| 306| decoded->data_octet14_present = true; 219| 306| OGS_GNUC_FALLTHROUGH; 220| 404| case 12: /* ARP + octet 3-13 */ ------------------ | Branch (220:5): [True: 98, False: 1.01k] ------------------ 221| 404| decoded->data_octet6_to_13_present = true; 222| 404| OGS_GNUC_FALLTHROUGH; 223| 1.09k| case 4: /* ARP + octet 3 + octet 4 + octet 5 */ ------------------ | Branch (223:5): [True: 687, False: 430] ------------------ 224| 1.09k| break; 225| 26| default: ------------------ | Branch (225:5): [True: 26, False: 1.09k] ------------------ 226| 26| ogs_warn("Qos Profile wrong length %u", octet->len); ------------------ | | 37| 26|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 26| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 26|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 26| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 26|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 26| 0, __VA_ARGS__) | | ------------------ ------------------ 227| 26| return -1; 228| 1.11k| } 229| 1.09k| memcpy(&decoded->qos_profile, source, octet->len); 230| | 231| | /* Calculate resulting MBRs in kbps: */ 232| 1.09k| if (decoded->data_octet6_to_13_present) { ------------------ | Branch (232:9): [True: 404, False: 687] ------------------ 233| 404| decoded->dec_transfer_delay = dec_transfer_delay_ms(source->data.transfer_delay); 234| 404| decoded->dec_mbr_kbps_dl = dec_mbr_kbps( 235| 404| source->data.max_bit_rate_downlink, 236| 404| decoded->bit_rate_downlink_extended_present ? ------------------ | Branch (236:41): [True: 285, False: 119] ------------------ 237| 404| &source->data.extended.max_bit_rate_downlink : NULL, 238| 404| decoded->bit_rate_downlink_extended2_present ? ------------------ | Branch (238:41): [True: 159, False: 245] ------------------ 239| 404| &source->data.extended2.max_bit_rate_downlink : NULL); 240| 404| decoded->dec_mbr_kbps_ul = dec_mbr_kbps( 241| 404| source->data.max_bit_rate_uplink, 242| 404| decoded->bit_rate_uplink_extended_present ? ------------------ | Branch (242:41): [True: 236, False: 168] ------------------ 243| 404| &source->data.extended.max_bit_rate_uplink : NULL, 244| 404| decoded->bit_rate_uplink_extended2_present ? ------------------ | Branch (244:41): [True: 79, False: 325] ------------------ 245| 404| &source->data.extended2.max_bit_rate_uplink : NULL); 246| | /* GBR is encoded the same way as MBR: */ 247| 404| decoded->dec_gbr_kbps_dl = dec_mbr_kbps( 248| 404| source->data.guaranteed_bit_rate_downlink, 249| 404| decoded->bit_rate_downlink_extended_present ? ------------------ | Branch (249:39): [True: 285, False: 119] ------------------ 250| 404| &source->data.extended.guaranteed_bit_rate_downlink : NULL, 251| 404| decoded->bit_rate_downlink_extended2_present ? ------------------ | Branch (251:39): [True: 159, False: 245] ------------------ 252| 404| &source->data.extended2.guaranteed_bit_rate_downlink : NULL); 253| 404| decoded->dec_gbr_kbps_ul = dec_mbr_kbps( 254| 404| source->data.guaranteed_bit_rate_uplink, 255| 404| decoded->bit_rate_uplink_extended_present ? ------------------ | Branch (255:39): [True: 236, False: 168] ------------------ 256| 404| &source->data.extended.guaranteed_bit_rate_uplink : NULL, 257| 404| decoded->bit_rate_uplink_extended2_present ? ------------------ | Branch (257:39): [True: 79, False: 325] ------------------ 258| 404| &source->data.extended2.guaranteed_bit_rate_uplink : NULL); 259| 404| } 260| | 261| 1.09k| return octet->len; 262| 1.11k|} ogs_gtp1_parse_mm_context: 467| 284|{ 468| 284| uint8_t *ptr = octet->data; 469| 284| unsigned int i; 470| 284| uint16_t val16; 471| | 472| 284| ogs_assert(decoded); ------------------ | | 113| 284| do { \ | | 114| 284| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 284|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 284, False: 0] | | | | ------------------ | | ------------------ | | 115| 284| 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| 284| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 284] | | ------------------ ------------------ 473| 284| ogs_assert(octet); ------------------ | | 113| 284| do { \ | | 114| 284| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 284|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 284, False: 0] | | | | ------------------ | | ------------------ | | 115| 284| 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| 284| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 284] | | ------------------ ------------------ 474| | 475| 284| memset(decoded, 0, sizeof(ogs_gtp1_mm_context_decoded_t)); 476| | 477| 284|#define CHECK_SPACE_ERR(bytes) \ 478| 284| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ 479| 284| return OGS_ERROR 480| | 481| 284| CHECK_SPACE_ERR(2); ------------------ | | 478| 284| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 1, False: 283] | | ------------------ | | 479| 284| return OGS_ERROR | | ------------------ | | | | 78| 1|#define OGS_ERROR -1 | | ------------------ ------------------ 482| 283| decoded->sec_mode = ptr[1] >> 6; 483| 283| switch (decoded->sec_mode) { ------------------ | Branch (483:13): [True: 283, False: 0] ------------------ 484| 38| case OGS_GTP1_SEC_MODE_UMTS_KEY_AND_QUINTUPLETS: ------------------ | | 356| 38|#define OGS_GTP1_SEC_MODE_UMTS_KEY_AND_QUINTUPLETS 2 ------------------ | Branch (484:5): [True: 38, False: 245] ------------------ 485| 280| case OGS_GTP1_SEC_MODE_USED_CIPHER_VALUE_UMTS_KEY_AND_QUINTUPLETS: ------------------ | | 357| 280|#define OGS_GTP1_SEC_MODE_USED_CIPHER_VALUE_UMTS_KEY_AND_QUINTUPLETS 0 ------------------ | Branch (485:5): [True: 242, False: 41] ------------------ 486| 280| break; /* Handle below */ 487| 1| case OGS_GTP1_SEC_MODE_GSM_KEY_AND_TRIPLETS: ------------------ | | 354| 1|#define OGS_GTP1_SEC_MODE_GSM_KEY_AND_TRIPLETS 1 ------------------ | Branch (487:5): [True: 1, False: 282] ------------------ 488| 3| case OGS_GTP1_SEC_MODE_GSM_KEY_AND_QUINTUPLETS: ------------------ | | 355| 3|#define OGS_GTP1_SEC_MODE_GSM_KEY_AND_QUINTUPLETS 3 ------------------ | Branch (488:5): [True: 2, False: 281] ------------------ 489| 3| ogs_error("[Gn] MM Context IE: Security Mode %u not supported!", decoded->sec_mode); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 3|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 490| 3| return OGS_ERROR; /* Not supported/expected here */ ------------------ | | 78| 3|#define OGS_ERROR -1 ------------------ 491| 283| } 492| | /* Structure for both sec modes is the same here, only difference is that 493| | OGS_GTP1_SEC_MODE_UMTS_KEY_AND_QUINTUPLETS has "Used Cipher" field encoded 494| | as spare all 1s. */ 495| 280| decoded->gupii = *ptr >> 7; 496| 280| decoded->ugipai = (*ptr >> 6) & 0x01; 497| 280| decoded->used_gprs_protection_algo = (*ptr >> 3) & 0x07; 498| 280| decoded->ksi = *ptr & 0x07; 499| 280| ptr++; 500| 280| decoded->num_vectors = (*ptr >> 3) & 0x07; 501| 280| if (decoded->num_vectors > OGS_ARRAY_SIZE(decoded->auth_quintuplets)) ------------------ | | 165| 280|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ | Branch (501:9): [True: 1, False: 279] ------------------ 502| 1| return OGS_ERROR; ------------------ | | 78| 1|#define OGS_ERROR -1 ------------------ 503| 279| decoded->used_cipher = *ptr & 0x07; 504| 279| ptr++; 505| | 506| 279| CHECK_SPACE_ERR(sizeof(decoded->ck)); ------------------ | | 478| 279| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 12, False: 267] | | ------------------ | | 479| 279| return OGS_ERROR | | ------------------ | | | | 78| 12|#define OGS_ERROR -1 | | ------------------ ------------------ 507| 267| memcpy(&decoded->ck[0], ptr, sizeof(decoded->ck)); 508| 267| ptr += sizeof(decoded->ck); 509| 267| CHECK_SPACE_ERR(sizeof(decoded->ik)); ------------------ | | 478| 267| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 7, False: 260] | | ------------------ | | 479| 267| return OGS_ERROR | | ------------------ | | | | 78| 7|#define OGS_ERROR -1 | | ------------------ ------------------ 510| 260| memcpy(&decoded->ik[0], ptr, sizeof(decoded->ik)); 511| 260| ptr += sizeof(decoded->ik); 512| | 513| | /* Quintuple length (in bytes) */ 514| 260| CHECK_SPACE_ERR(2); ------------------ | | 478| 260| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 2, False: 258] | | ------------------ | | 479| 260| return OGS_ERROR | | ------------------ | | | | 78| 2|#define OGS_ERROR -1 | | ------------------ ------------------ 515| 258| memcpy(&val16, &ptr[0], 2); 516| 258| val16 = be16toh(val16); 517| 258| ptr += 2; 518| | 519| 258| CHECK_SPACE_ERR(val16); ------------------ | | 478| 258| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 33, False: 225] | | ------------------ | | 479| 258| return OGS_ERROR | | ------------------ | | | | 78| 33|#define OGS_ERROR -1 | | ------------------ ------------------ 520| 225| int remain = val16; 521| 271| for (i = 0; i < decoded->num_vectors; i++) { ------------------ | Branch (521:17): [True: 121, False: 150] ------------------ 522| 121| int rv = decode_quintuple(&decoded->auth_quintuplets[i], ptr + (val16 - remain), remain); 523| 121| if (rv < 0) ------------------ | Branch (523:13): [True: 75, False: 46] ------------------ 524| 75| return OGS_ERROR; ------------------ | | 78| 75|#define OGS_ERROR -1 ------------------ 525| 46| remain -= rv; 526| 46| } 527| 150| ptr += val16; 528| | 529| 150| CHECK_SPACE_ERR(sizeof(decoded->drx_param)); ------------------ | | 478| 150| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 4, False: 146] | | ------------------ | | 479| 150| return OGS_ERROR | | ------------------ | | | | 78| 4|#define OGS_ERROR -1 | | ------------------ ------------------ 530| 146| memcpy(&decoded->drx_param, ptr, sizeof(decoded->drx_param)); 531| 146| ptr += sizeof(decoded->drx_param); 532| | 533| 146| CHECK_SPACE_ERR(1); ------------------ | | 478| 146| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 1, False: 145] | | ------------------ | | 479| 146| return OGS_ERROR | | ------------------ | | | | 78| 1|#define OGS_ERROR -1 | | ------------------ ------------------ 534| 145| decoded->ms_network_capability_len = *ptr++; 535| 145| CHECK_SPACE_ERR(decoded->ms_network_capability_len); ------------------ | | 478| 145| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 13, False: 132] | | ------------------ | | 479| 145| return OGS_ERROR | | ------------------ | | | | 78| 13|#define OGS_ERROR -1 | | ------------------ ------------------ 536| 132| if (decoded->ms_network_capability_len > ------------------ | Branch (536:9): [True: 7, False: 125] ------------------ 537| 132| sizeof(decoded->ms_network_capability)) { 538| 7| ogs_error("[Gn] MM Context IE: MS Network Capability too long " ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 7|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 539| 7| "[%u > %zu]", decoded->ms_network_capability_len, 540| 7| sizeof(decoded->ms_network_capability)); 541| 7| return OGS_ERROR; ------------------ | | 78| 7|#define OGS_ERROR -1 ------------------ 542| 7| } 543| 125| if (decoded->ms_network_capability_len > 0) { ------------------ | Branch (543:9): [True: 18, False: 107] ------------------ 544| 18| memcpy(&decoded->ms_network_capability[0], ptr, 545| 18| decoded->ms_network_capability_len); 546| 18| } 547| 125| ptr += decoded->ms_network_capability_len; 548| | 549| | /* Container length (in bytes) */ 550| 125| CHECK_SPACE_ERR(2); ------------------ | | 478| 125| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 9, False: 116] | | ------------------ | | 479| 125| return OGS_ERROR | | ------------------ | | | | 78| 9|#define OGS_ERROR -1 | | ------------------ ------------------ 551| 116| memcpy(&val16, &ptr[0], 2); 552| 116| val16 = be16toh(val16); 553| 116| ptr += 2; 554| | 555| | /* Extract IMEISV from Container: */ 556| 116| CHECK_SPACE_ERR(val16); ------------------ | | 478| 116| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 24, False: 92] | | ------------------ | | 479| 116| return OGS_ERROR | | ------------------ | | | | 78| 24|#define OGS_ERROR -1 | | ------------------ ------------------ 557| 92| if (val16 > 0) { ------------------ | Branch (557:9): [True: 62, False: 30] ------------------ 558| 62| CHECK_SPACE_ERR(2); ------------------ | | 478| 62| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 4, False: 58] | | ------------------ | | 479| 62| return OGS_ERROR | | ------------------ | | | | 78| 4|#define OGS_ERROR -1 | | ------------------ ------------------ 559| | /* Validate Container (Mobile Identity IMEISV) IE, TS 29.060 Table 47A */ 560| 58| if (ptr[0] != 0x23) ------------------ | Branch (560:13): [True: 25, False: 33] ------------------ 561| 25| return OGS_ERROR; ------------------ | | 78| 25|#define OGS_ERROR -1 ------------------ 562| 33| decoded->imeisv_len = ptr[1]; 563| 33| CHECK_SPACE_ERR(2 + decoded->imeisv_len); ------------------ | | 478| 33| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 16, False: 17] | | ------------------ | | 479| 33| return OGS_ERROR | | ------------------ | | | | 78| 16|#define OGS_ERROR -1 | | ------------------ ------------------ 564| 17| if (decoded->imeisv_len > sizeof(decoded->imeisv)) { ------------------ | Branch (564:13): [True: 6, False: 11] ------------------ 565| 6| ogs_error("[Gn] MM Context IE: IMEISV too long [%u > %zu]", ------------------ | | 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__) | | ------------------ ------------------ 566| 6| decoded->imeisv_len, sizeof(decoded->imeisv)); 567| 6| return OGS_ERROR; ------------------ | | 78| 6|#define OGS_ERROR -1 ------------------ 568| 6| } 569| 11| memcpy(&decoded->imeisv[0], &ptr[2], decoded->imeisv_len); 570| 11| } 571| 41| ptr += val16; 572| | 573| 41| if ((ptr - (uint8_t *)octet->data) + 1 <= octet->len) { ------------------ | Branch (573:9): [True: 38, False: 3] ------------------ 574| 38| CHECK_SPACE_ERR(1 + *ptr); ------------------ | | 478| 38| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (478:9): [True: 17, False: 21] | | ------------------ | | 479| 38| return OGS_ERROR | | ------------------ | | | | 78| 17|#define OGS_ERROR -1 | | ------------------ ------------------ 575| 21| if (*ptr > 0) { ------------------ | Branch (575:13): [True: 13, False: 8] ------------------ 576| | /* ptr[0] = Length of Access Restriction Data */ 577| 13| decoded->nrsrna = ptr[1] & 0x01; 578| 13| } 579| 21| ptr += 1 + *ptr; 580| 21| } 581| | /* else: Be tolerant and accept missing Length of Access Restriction Data field 582| | * assuming the whole Access Restriction Data field is missing. */ 583| | 584| 24| return OGS_OK; ------------------ | | 77| 24|#define OGS_OK 0 ------------------ 585| 41|#undef CHECK_SPACE_ERR 586| 41|} ogs_gtp1_parse_pdp_context: 828| 371|{ 829| 371| uint8_t *ptr = octet->data; 830| 371| uint16_t val16; 831| 371| uint32_t val32; 832| 371| ogs_tlv_octet_t qos; 833| 371| int rv; 834| | 835| 371| ogs_assert(decoded); ------------------ | | 113| 371| do { \ | | 114| 371| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 371|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 371, False: 0] | | | | ------------------ | | ------------------ | | 115| 371| 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| 371| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 371] | | ------------------ ------------------ 836| 371| ogs_assert(octet); ------------------ | | 113| 371| do { \ | | 114| 371| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 371|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 371, False: 0] | | | | ------------------ | | ------------------ | | 115| 371| 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| 371| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 371] | | ------------------ ------------------ 837| | 838| 371| memset(decoded, 0, sizeof(ogs_gtp1_pdp_context_decoded_t)); 839| | 840| 371|#define CHECK_SPACE_ERR(bytes) \ 841| 371| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ 842| 371| return OGS_ERROR 843| | 844| 371| CHECK_SPACE_ERR(1); ------------------ | | 841| 371| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 0, False: 371] | | ------------------ | | 842| 371| return OGS_ERROR | | ------------------ | | | | 78| 0|#define OGS_ERROR -1 | | ------------------ ------------------ 845| 371| decoded->ea = *ptr >> 7; 846| 371| decoded->vaa = (*ptr >> 6) & 0x01; 847| 371| decoded->asi = (*ptr >> 5) & 0x01; 848| 371| decoded->order = (*ptr >> 4) & 0x01; 849| 371| decoded->nsapi = *ptr & 0x0f; 850| 371| ptr++; 851| | 852| 371| CHECK_SPACE_ERR(1); ------------------ | | 841| 371| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 1, False: 370] | | ------------------ | | 842| 371| return OGS_ERROR | | ------------------ | | | | 78| 1|#define OGS_ERROR -1 | | ------------------ ------------------ 853| 370| decoded->sapi = *ptr++; 854| | 855| | /* QoS Sub */ 856| 370| CHECK_SPACE_ERR(1); ------------------ | | 841| 370| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 1, False: 369] | | ------------------ | | 842| 370| return OGS_ERROR | | ------------------ | | | | 78| 1|#define OGS_ERROR -1 | | ------------------ ------------------ 857| 369| qos.len = *ptr++; 858| 369| CHECK_SPACE_ERR(qos.len); ------------------ | | 841| 369| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 12, False: 357] | | ------------------ | | 842| 369| return OGS_ERROR | | ------------------ | | | | 78| 12|#define OGS_ERROR -1 | | ------------------ ------------------ 859| 357| qos.data = ptr; 860| 357| rv = ogs_gtp1_parse_qos_profile(&decoded->qos_sub, &qos); 861| 357| if (rv < 0) ------------------ | Branch (861:9): [True: 8, False: 349] ------------------ 862| 8| return OGS_ERROR; ------------------ | | 78| 8|#define OGS_ERROR -1 ------------------ 863| 349| ptr += qos.len; 864| | 865| | /* QoS Req */ 866| 349| CHECK_SPACE_ERR(1); ------------------ | | 841| 349| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 4, False: 345] | | ------------------ | | 842| 349| return OGS_ERROR | | ------------------ | | | | 78| 4|#define OGS_ERROR -1 | | ------------------ ------------------ 867| 345| qos.len = *ptr++; 868| 345| CHECK_SPACE_ERR(qos.len); ------------------ | | 841| 345| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 15, False: 330] | | ------------------ | | 842| 345| return OGS_ERROR | | ------------------ | | | | 78| 15|#define OGS_ERROR -1 | | ------------------ ------------------ 869| 330| qos.data = ptr; 870| 330| rv = ogs_gtp1_parse_qos_profile(&decoded->qos_req, &qos); 871| 330| if (rv < 0) ------------------ | Branch (871:9): [True: 5, False: 325] ------------------ 872| 5| return OGS_ERROR; ------------------ | | 78| 5|#define OGS_ERROR -1 ------------------ 873| 325| ptr += qos.len; 874| | 875| | /* QoS Neg */ 876| 325| CHECK_SPACE_ERR(1); ------------------ | | 841| 325| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 24, False: 301] | | ------------------ | | 842| 325| return OGS_ERROR | | ------------------ | | | | 78| 24|#define OGS_ERROR -1 | | ------------------ ------------------ 877| 301| qos.len = *ptr++; 878| 301| CHECK_SPACE_ERR(qos.len); ------------------ | | 841| 301| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 19, False: 282] | | ------------------ | | 842| 301| return OGS_ERROR | | ------------------ | | | | 78| 19|#define OGS_ERROR -1 | | ------------------ ------------------ 879| 282| qos.data = ptr; 880| 282| rv = ogs_gtp1_parse_qos_profile(&decoded->qos_neg, &qos); 881| 282| if (rv < 0) ------------------ | Branch (881:9): [True: 4, False: 278] ------------------ 882| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 883| 278| ptr += qos.len; 884| | 885| 278| CHECK_SPACE_ERR(2); ------------------ | | 841| 278| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 12, False: 266] | | ------------------ | | 842| 278| return OGS_ERROR | | ------------------ | | | | 78| 12|#define OGS_ERROR -1 | | ------------------ ------------------ 886| 266| memcpy(&val16, &ptr[0], 2); 887| 266| decoded->snd = be16toh(val16); 888| 266| ptr += 2; 889| | 890| 266| CHECK_SPACE_ERR(2); ------------------ | | 841| 266| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 7, False: 259] | | ------------------ | | 842| 266| return OGS_ERROR | | ------------------ | | | | 78| 7|#define OGS_ERROR -1 | | ------------------ ------------------ 891| 259| memcpy(&val16, &ptr[0], 2); 892| 259| decoded->snu = be16toh(val16); 893| 259| ptr += 2; 894| | 895| 259| CHECK_SPACE_ERR(1); ------------------ | | 841| 259| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 1, False: 258] | | ------------------ | | 842| 259| return OGS_ERROR | | ------------------ | | | | 78| 1|#define OGS_ERROR -1 | | ------------------ ------------------ 896| 258| decoded->send_npdu_nr = *ptr++; 897| 258| CHECK_SPACE_ERR(1); ------------------ | | 841| 258| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 2, False: 256] | | ------------------ | | 842| 258| return OGS_ERROR | | ------------------ | | | | 78| 2|#define OGS_ERROR -1 | | ------------------ ------------------ 898| 256| decoded->receive_npdu_nr = *ptr++; 899| | 900| 256| CHECK_SPACE_ERR(4); ------------------ | | 841| 256| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 7, False: 249] | | ------------------ | | 842| 256| return OGS_ERROR | | ------------------ | | | | 78| 7|#define OGS_ERROR -1 | | ------------------ ------------------ 901| 249| memcpy(&val32, &ptr[0], 4); 902| 249| decoded->ul_teic = be32toh(val32); 903| 249| ptr += 4; 904| | 905| 249| CHECK_SPACE_ERR(4); ------------------ | | 841| 249| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 4, False: 245] | | ------------------ | | 842| 249| return OGS_ERROR | | ------------------ | | | | 78| 4|#define OGS_ERROR -1 | | ------------------ ------------------ 906| 245| memcpy(&val32, &ptr[0], 4); 907| 245| decoded->ul_teid = be32toh(val32); 908| 245| ptr += 4; 909| | 910| 245| CHECK_SPACE_ERR(1); ------------------ | | 841| 245| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 1, False: 244] | | ------------------ | | 842| 245| return OGS_ERROR | | ------------------ | | | | 78| 1|#define OGS_ERROR -1 | | ------------------ ------------------ 911| 244| decoded->pdp_ctx_id = *ptr++; 912| | 913| | /* 'PDP Address' related fields */ 914| 244| CHECK_SPACE_ERR(1); ------------------ | | 841| 244| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 2, False: 242] | | ------------------ | | 842| 244| return OGS_ERROR | | ------------------ | | | | 78| 2|#define OGS_ERROR -1 | | ------------------ ------------------ 915| 242| decoded->pdp_type_org = *ptr & 0x0f; 916| 242| ptr++; 917| 242| CHECK_SPACE_ERR(2); /* PDP Address Type Number + PDP Address Length */ ------------------ | | 841| 242| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 8, False: 234] | | ------------------ | | 842| 242| return OGS_ERROR | | ------------------ | | | | 78| 8|#define OGS_ERROR -1 | | ------------------ ------------------ 918| 234| decoded->pdp_type_num[0] = ogs_gtp1_eua_ietf_type_to_pdu_session_type(ptr[0]); 919| 234| CHECK_SPACE_ERR(2 + ptr[1]); /* + PDP Address Length value */ ------------------ | | 841| 234| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 14, False: 220] | | ------------------ | | 842| 234| return OGS_ERROR | | ------------------ | | | | 78| 14|#define OGS_ERROR -1 | | ------------------ ------------------ 920| 220| rv = dec_eua_for_pdp_ctx(decoded->pdp_type_org, ptr[0], &ptr[2], 921| 220| ptr[1], &decoded->pdp_address[0]); 922| 220| if (rv < 0) ------------------ | Branch (922:9): [True: 73, False: 147] ------------------ 923| 73| return rv; 924| 147| ptr += 2 + ptr[1]; 925| | 926| | /* GGSN Address for control plane Length */ 927| 147| CHECK_SPACE_ERR(1); ------------------ | | 841| 147| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 8, False: 139] | | ------------------ | | 842| 147| return OGS_ERROR | | ------------------ | | | | 78| 8|#define OGS_ERROR -1 | | ------------------ ------------------ 928| 139| CHECK_SPACE_ERR(1 + *ptr); ------------------ | | 841| 139| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 15, False: 124] | | ------------------ | | 842| 139| return OGS_ERROR | | ------------------ | | | | 78| 15|#define OGS_ERROR -1 | | ------------------ ------------------ 929| 124| switch (*ptr) { 930| 112| case OGS_GTP_GSN_ADDRESS_IPV4_LEN: ------------------ | | 198| 112|#define OGS_GTP_GSN_ADDRESS_IPV4_LEN OGS_IPV4_LEN | | ------------------ | | | | 381| 112|#define OGS_IPV4_LEN 4 | | ------------------ ------------------ | Branch (930:5): [True: 112, False: 12] ------------------ 931| 112| decoded->ggsn_address_c.ipv4 = 1; 932| 112| memcpy((uint8_t *)&decoded->ggsn_address_c.addr, ptr + 1, *ptr); 933| 112| break; 934| 7| case OGS_GTP_GSN_ADDRESS_IPV6_LEN: ------------------ | | 199| 7|#define OGS_GTP_GSN_ADDRESS_IPV6_LEN OGS_IPV6_LEN | | ------------------ | | | | 382| 7|#define OGS_IPV6_LEN 16 | | ------------------ ------------------ | Branch (934:5): [True: 7, False: 117] ------------------ 935| 7| decoded->ggsn_address_c.ipv6 = 1; 936| 7| memcpy((uint8_t *)&decoded->ggsn_address_c.addr6, ptr + 1, *ptr); 937| 7| break; 938| 5| default: ------------------ | Branch (938:5): [True: 5, False: 119] ------------------ 939| 5| return OGS_ERROR; ------------------ | | 78| 5|#define OGS_ERROR -1 ------------------ 940| 124| } 941| 119| decoded->ggsn_address_c.len = *ptr; 942| 119| ptr += 1 + *ptr; 943| | 944| | /* GGSN Address for User Traffic Length */ 945| 119| CHECK_SPACE_ERR(1); ------------------ | | 841| 119| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 2, False: 117] | | ------------------ | | 842| 119| return OGS_ERROR | | ------------------ | | | | 78| 2|#define OGS_ERROR -1 | | ------------------ ------------------ 946| 117| CHECK_SPACE_ERR(1 + *ptr); ------------------ | | 841| 117| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 12, False: 105] | | ------------------ | | 842| 117| return OGS_ERROR | | ------------------ | | | | 78| 12|#define OGS_ERROR -1 | | ------------------ ------------------ 947| 105| switch (*ptr) { 948| 89| case OGS_GTP_GSN_ADDRESS_IPV4_LEN: ------------------ | | 198| 89|#define OGS_GTP_GSN_ADDRESS_IPV4_LEN OGS_IPV4_LEN | | ------------------ | | | | 381| 89|#define OGS_IPV4_LEN 4 | | ------------------ ------------------ | Branch (948:5): [True: 89, False: 16] ------------------ 949| 89| decoded->ggsn_address_u.ipv4 = 1; 950| 89| memcpy((uint8_t *)&decoded->ggsn_address_u.addr, ptr + 1, *ptr); 951| 89| break; 952| 12| case OGS_GTP_GSN_ADDRESS_IPV6_LEN: ------------------ | | 199| 12|#define OGS_GTP_GSN_ADDRESS_IPV6_LEN OGS_IPV6_LEN | | ------------------ | | | | 382| 12|#define OGS_IPV6_LEN 16 | | ------------------ ------------------ | Branch (952:5): [True: 12, False: 93] ------------------ 953| 12| decoded->ggsn_address_u.ipv6 = 1; 954| 12| memcpy((uint8_t *)&decoded->ggsn_address_u.addr6, ptr + 1, *ptr); 955| 12| break; 956| 4| default: ------------------ | Branch (956:5): [True: 4, False: 101] ------------------ 957| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 958| 105| } 959| 101| decoded->ggsn_address_u.len = *ptr; 960| 101| ptr += 1 + *ptr; 961| | 962| | /* APN length */ 963| 101| CHECK_SPACE_ERR(1); ------------------ | | 841| 101| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 2, False: 99] | | ------------------ | | 842| 101| return OGS_ERROR | | ------------------ | | | | 78| 2|#define OGS_ERROR -1 | | ------------------ ------------------ 964| 99| CHECK_SPACE_ERR(1 + *ptr); ------------------ | | 841| 99| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 16, False: 83] | | ------------------ | | 842| 99| return OGS_ERROR | | ------------------ | | | | 78| 16|#define OGS_ERROR -1 | | ------------------ ------------------ 965| 83| rv = ogs_fqdn_parse(decoded->apn, (const char *)ptr + 1, 966| 83| ogs_min(*ptr, sizeof(decoded->apn))); ------------------ | | 179| 83|#define ogs_min(x , y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (179:26): [True: 73, False: 10] | | ------------------ ------------------ 967| | /* Clang scan-build SA: Value stored is not used: add check for rv error. */ 968| 83| if (rv < 0) { ------------------ | Branch (968:9): [True: 23, False: 60] ------------------ 969| 23| ogs_error("ogs_fqdn_parse() failed"); ------------------ | | 36| 23|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 23| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 23|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 23| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 23|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 23| 0, __VA_ARGS__) | | ------------------ ------------------ 970| 23| return OGS_ERROR; ------------------ | | 78| 23|#define OGS_ERROR -1 ------------------ 971| 23| } 972| | 973| 60| ptr += 1 + *ptr; 974| | 975| 60| CHECK_SPACE_ERR(2); ------------------ | | 841| 60| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 20, False: 40] | | ------------------ | | 842| 60| return OGS_ERROR | | ------------------ | | | | 78| 20|#define OGS_ERROR -1 | | ------------------ ------------------ 976| 40| decoded->trans_id = (((uint16_t)ptr[1]) << 4) | (ptr[0] & 0x0f); 977| 40| ptr += 2; 978| | 979| 40| if (decoded->ea == OGS_GTP1_PDPCTX_EXT_EUA_YES) { ------------------ | | 390| 40|#define OGS_GTP1_PDPCTX_EXT_EUA_YES 1 ------------------ | Branch (979:9): [True: 37, False: 3] ------------------ 980| 37| CHECK_SPACE_ERR(2); /* PDP Address Type Number + PDP Address Length */ ------------------ | | 841| 37| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 6, False: 31] | | ------------------ | | 842| 37| return OGS_ERROR | | ------------------ | | | | 78| 6|#define OGS_ERROR -1 | | ------------------ ------------------ 981| 31| decoded->pdp_type_num[1] = ogs_gtp1_eua_ietf_type_to_pdu_session_type(ptr[0]); 982| 31| CHECK_SPACE_ERR(2 + ptr[1]); /* + PDP Address Length value */ ------------------ | | 841| 31| if ((ptr - (uint8_t *)octet->data) + (bytes) > octet->len) \ | | ------------------ | | | Branch (841:9): [True: 15, False: 16] | | ------------------ | | 842| 31| return OGS_ERROR | | ------------------ | | | | 78| 15|#define OGS_ERROR -1 | | ------------------ ------------------ 983| 16| rv = dec_eua_for_pdp_ctx(decoded->pdp_type_org, ptr[0], &ptr[2], 984| 16| ptr[1], &decoded->pdp_address[1]); 985| 16| if (rv < 0) ------------------ | Branch (985:13): [True: 7, False: 9] ------------------ 986| 7| return rv; 987| 9| ptr += 2 + ptr[1]; 988| 9| } 989| | 990| 12| return OGS_OK; ------------------ | | 77| 12|#define OGS_OK 0 ------------------ 991| 40|#undef CHECK_SPACE_ERR 992| 40|} types.c:dec_transfer_delay_ms: 184| 404|{ 185| 404| transfer_delay_byte &= 0x3f; /* 6 bits */ 186| 404| if (transfer_delay_byte <= 0x0f) ------------------ | Branch (186:9): [True: 195, False: 209] ------------------ 187| 195| return transfer_delay_byte; 188| 209| if (transfer_delay_byte <= 0x1f) ------------------ | Branch (188:9): [True: 63, False: 146] ------------------ 189| 63| return 200 + (transfer_delay_byte - 0x10) * 50; 190| 146| return 1000 + (transfer_delay_byte - 0x20) * 100; 191| 209|} types.c:dec_mbr_kbps: 142| 1.61k|{ 143| 1.61k| uint8_t mbr, embr1, embr2; 144| 1.61k| mbr = mbr_byte; 145| 1.61k| embr1 = extended_mbr_byte ? *extended_mbr_byte : 0; ------------------ | Branch (145:13): [True: 1.04k, False: 574] ------------------ 146| 1.61k| embr2 = extended2_mbr_byte ? *extended2_mbr_byte : 0; ------------------ | Branch (146:13): [True: 476, False: 1.14k] ------------------ 147| | 148| 1.61k| if (mbr == 0) ------------------ | Branch (148:9): [True: 265, False: 1.35k] ------------------ 149| 265| return 0; 150| 1.35k| if (mbr == 0xff) ------------------ | Branch (150:9): [True: 97, False: 1.25k] ------------------ 151| 97| return UINT32_MAX; 152| 1.25k| if (mbr == 0xfe) { /* Check extended field */ ------------------ | Branch (152:9): [True: 450, False: 804] ------------------ 153| 450| if (extended_mbr_byte == NULL || embr1 == 0) ------------------ | Branch (153:13): [True: 64, False: 386] | Branch (153:42): [True: 30, False: 356] ------------------ 154| 94| return 8640; 155| 356| if (embr1 == 0xfa) { /* Check extended2 field */ ------------------ | Branch (155:13): [True: 182, False: 174] ------------------ 156| 182| if (extended2_mbr_byte == NULL || embr2 == 0) ------------------ | Branch (156:17): [True: 26, False: 156] | Branch (156:47): [True: 19, False: 137] ------------------ 157| 45| return 256 * 1000; 158| 137| if (embr2 == 0xf6) ------------------ | Branch (158:17): [True: 12, False: 125] ------------------ 159| 12| return 10 * 1000 * 1000; /* TODO: check "extended quality of service" IE */ 160| 125| if (embr2 >= 0xa2 && embr2 <= 0xf6) ------------------ | Branch (160:17): [True: 51, False: 74] | Branch (160:34): [True: 30, False: 21] ------------------ 161| 30| return (1500 + (embr2 - (0xa2 - 1)) * 100) * 1000; 162| 95| if (embr2 >= 0x3e && embr2 <= 0xa1) ------------------ | Branch (162:17): [True: 64, False: 31] | Branch (162:34): [True: 43, False: 21] ------------------ 163| 43| return (500 + (embr2 - (0x3e - 1)) * 10) * 1000; 164| 52| return (256 + embr2 * 4) * 1000; 165| 95| } 166| 174| if (embr1 >= 0xbb && embr1 <= 0xfa) ------------------ | Branch (166:13): [True: 71, False: 103] | Branch (166:30): [True: 39, False: 32] ------------------ 167| 39| return (128 + (embr1 - (0xbb - 1)) * 2) * 1000; 168| 135| if (embr1 >= 0x4b && embr1 <= 0xba) ------------------ | Branch (168:13): [True: 81, False: 54] | Branch (168:30): [True: 49, False: 32] ------------------ 169| 49| return (16 + (embr1 - (0x4b - 1)) * 1) * 1000; 170| 86| return 8600 + embr1 * 100; 171| 135| } 172| 804| if (mbr & 0x80) { ------------------ | Branch (172:9): [True: 220, False: 584] ------------------ 173| 220| mbr &= ~0x80; 174| 220| return 576 + mbr_byte * 64; 175| 220| } 176| 584| if (mbr & 0x40) { ------------------ | Branch (176:9): [True: 159, False: 425] ------------------ 177| 159| mbr &= ~0x40; 178| 159| return 64 + mbr * 8; 179| 159| } 180| 425| return mbr; 181| 584|} types.c:decode_quintuple: 425| 121|{ 426| 121| uint8_t *ptr = data; 427| | 428| 121|#define CHECK_SPACE_ERR(bytes) \ 429| 121| if ((ptr - data) + (bytes) > len) \ 430| 121| return OGS_ERROR 431| | 432| 121| CHECK_SPACE_ERR(sizeof(decoded->rand)); ------------------ | | 429| 121| if ((ptr - data) + (bytes) > len) \ | | ------------------ | | | Branch (429:9): [True: 17, False: 104] | | ------------------ | | 430| 121| return OGS_ERROR | | ------------------ | | | | 78| 17|#define OGS_ERROR -1 | | ------------------ ------------------ 433| 104| memcpy(&decoded->rand, ptr, sizeof(decoded->rand)); 434| 104| ptr += sizeof(decoded->rand); 435| | 436| 104| CHECK_SPACE_ERR(1); ------------------ | | 429| 104| if ((ptr - data) + (bytes) > len) \ | | ------------------ | | | Branch (429:9): [True: 2, False: 102] | | ------------------ | | 430| 104| return OGS_ERROR | | ------------------ | | | | 78| 2|#define OGS_ERROR -1 | | ------------------ ------------------ 437| 102| decoded->xres_len = *ptr++; 438| 102| if (decoded->xres_len > OGS_MAX_RES_LEN) ------------------ | | 57| 102|#define OGS_MAX_RES_LEN 16 ------------------ | Branch (438:9): [True: 9, False: 93] ------------------ 439| 9| return OGS_ERROR; ------------------ | | 78| 9|#define OGS_ERROR -1 ------------------ 440| 93| CHECK_SPACE_ERR(decoded->xres_len); ------------------ | | 429| 93| if ((ptr - data) + (bytes) > len) \ | | ------------------ | | | Branch (429:9): [True: 3, False: 90] | | ------------------ | | 430| 93| return OGS_ERROR | | ------------------ | | | | 78| 3|#define OGS_ERROR -1 | | ------------------ ------------------ 441| 90| memcpy(&decoded->xres[0], ptr, decoded->xres_len); 442| 90| ptr += decoded->xres_len; 443| | 444| 90| CHECK_SPACE_ERR(sizeof(decoded->ck)); ------------------ | | 429| 90| if ((ptr - data) + (bytes) > len) \ | | ------------------ | | | Branch (429:9): [True: 10, False: 80] | | ------------------ | | 430| 90| return OGS_ERROR | | ------------------ | | | | 78| 10|#define OGS_ERROR -1 | | ------------------ ------------------ 445| 80| memcpy(&decoded->ck, ptr, sizeof(decoded->ck)); 446| 80| ptr += sizeof(decoded->ck); 447| | 448| 80| CHECK_SPACE_ERR(sizeof(decoded->ik)); ------------------ | | 429| 80| if ((ptr - data) + (bytes) > len) \ | | ------------------ | | | Branch (429:9): [True: 11, False: 69] | | ------------------ | | 430| 80| return OGS_ERROR | | ------------------ | | | | 78| 11|#define OGS_ERROR -1 | | ------------------ ------------------ 449| 69| memcpy(&decoded->ik, ptr, sizeof(decoded->ik)); 450| 69| ptr += sizeof(decoded->ik); 451| | 452| 69| CHECK_SPACE_ERR(1); ------------------ | | 429| 69| if ((ptr - data) + (bytes) > len) \ | | ------------------ | | | Branch (429:9): [True: 1, False: 68] | | ------------------ | | 430| 69| return OGS_ERROR | | ------------------ | | | | 78| 1|#define OGS_ERROR -1 | | ------------------ ------------------ 453| 68| decoded->autn_len = *ptr++; 454| 68| if (decoded->autn_len > OGS_AUTN_LEN) ------------------ | | 55| 68|#define OGS_AUTN_LEN 16 ------------------ | Branch (454:9): [True: 12, False: 56] ------------------ 455| 12| return OGS_ERROR; ------------------ | | 78| 12|#define OGS_ERROR -1 ------------------ 456| 56| CHECK_SPACE_ERR(decoded->autn_len); ------------------ | | 429| 56| if ((ptr - data) + (bytes) > len) \ | | ------------------ | | | Branch (429:9): [True: 10, False: 46] | | ------------------ | | 430| 56| return OGS_ERROR | | ------------------ | | | | 78| 10|#define OGS_ERROR -1 | | ------------------ ------------------ 457| 46| memcpy(&decoded->autn[0], ptr, decoded->autn_len); 458| 46| ptr += decoded->autn_len; 459| | 460| 46| return (ptr - data); 461| 56|#undef CHECK_SPACE_ERR 462| 56|} types.c:dec_eua_for_pdp_ctx: 711| 236|{ 712| 236| ogs_assert(data); ------------------ | | 113| 236| do { \ | | 114| 236| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 236|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 236, False: 0] | | | | ------------------ | | ------------------ | | 115| 236| 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| 236| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 236] | | ------------------ ------------------ 713| 236| ogs_assert(ip); ------------------ | | 113| 236| do { \ | | 114| 236| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 236|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 236, False: 0] | | | | ------------------ | | ------------------ | | 115| 236| 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| 236| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 236] | | ------------------ ------------------ 714| | 715| 236| memset(ip, 0, sizeof *ip); 716| | 717| 236| switch (pdp_type_org) { 718| 213| case OGS_PDP_EUA_ORG_IETF: ------------------ | | 410| 213|#define OGS_PDP_EUA_ORG_IETF 1 ------------------ | Branch (718:5): [True: 213, False: 23] ------------------ 719| 213| break; 720| 8| case OGS_PDP_EUA_ORG_ETSI: ------------------ | | 409| 8|#define OGS_PDP_EUA_ORG_ETSI 0 ------------------ | Branch (720:5): [True: 8, False: 228] ------------------ 721| 23| default: ------------------ | Branch (721:5): [True: 15, False: 221] ------------------ 722| 23| ogs_error("Unsupported EUA organization %u", pdp_type_org); ------------------ | | 36| 23|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 23| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 23|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 23| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 23|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 23| 0, __VA_ARGS__) | | ------------------ ------------------ 723| 23| return OGS_ERROR; ------------------ | | 78| 23|#define OGS_ERROR -1 ------------------ 724| 236| } 725| | 726| 213| switch (pdp_type_num) { 727| 71| case OGS_PDP_EUA_IETF_IPV4: ------------------ | | 412| 71|#define OGS_PDP_EUA_IETF_IPV4 0x21 ------------------ | Branch (727:5): [True: 71, False: 142] ------------------ 728| 71| if (data_len == OGS_IPV4_LEN) { ------------------ | | 381| 71|#define OGS_IPV4_LEN 4 ------------------ | Branch (728:13): [True: 17, False: 54] ------------------ 729| 17| memcpy(&ip->addr, data, OGS_IPV4_LEN); ------------------ | | 381| 17|#define OGS_IPV4_LEN 4 ------------------ 730| 54| } else if (data_len != 0) { ------------------ | Branch (730:20): [True: 8, False: 46] ------------------ 731| 8| ogs_error("Wrong IPv4 EUA length %u", data_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__) | | ------------------ ------------------ 732| 8| return OGS_ERROR; ------------------ | | 78| 8|#define OGS_ERROR -1 ------------------ 733| 8| } 734| 63| ip->ipv4 = 1; 735| 63| ip->ipv6 = 0; 736| 63| break; 737| 37| case OGS_PDP_EUA_IETF_IPV6: ------------------ | | 413| 37|#define OGS_PDP_EUA_IETF_IPV6 0x57 ------------------ | Branch (737:5): [True: 37, False: 176] ------------------ 738| 37| if (data_len == OGS_IPV6_LEN) { ------------------ | | 382| 37|#define OGS_IPV6_LEN 16 ------------------ | Branch (738:13): [True: 4, False: 33] ------------------ 739| 4| memcpy(ip->addr6, data, OGS_IPV6_LEN); ------------------ | | 382| 4|#define OGS_IPV6_LEN 16 ------------------ 740| 33| } else if (data_len != 0) { ------------------ | Branch (740:20): [True: 16, False: 17] ------------------ 741| 16| ogs_error("Wrong IPv6 EUA length %u", data_len); ------------------ | | 36| 16|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 16| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 16|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 16| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 16|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 16| 0, __VA_ARGS__) | | ------------------ ------------------ 742| 16| return OGS_ERROR; ------------------ | | 78| 16|#define OGS_ERROR -1 ------------------ 743| 16| } 744| 21| ip->ipv4 = 0; 745| 21| ip->ipv6 = 1; 746| 21| break; 747| 96| case OGS_PDP_EUA_IETF_IPV4V6: ------------------ | | 414| 96|#define OGS_PDP_EUA_IETF_IPV4V6 0x8D ------------------ | Branch (747:5): [True: 96, False: 117] ------------------ 748| 96| if (data_len == OGS_IPV4_LEN) { ------------------ | | 381| 96|#define OGS_IPV4_LEN 4 ------------------ | Branch (748:13): [True: 5, False: 91] ------------------ 749| 5| memcpy(&ip->addr, data, OGS_IPV4_LEN); ------------------ | | 381| 5|#define OGS_IPV4_LEN 4 ------------------ 750| 91| } else if (data_len == OGS_IPV6_LEN) { ------------------ | | 382| 91|#define OGS_IPV6_LEN 16 ------------------ | Branch (750:20): [True: 4, False: 87] ------------------ 751| 4| memcpy(ip->addr6, data, OGS_IPV6_LEN); ------------------ | | 382| 4|#define OGS_IPV6_LEN 16 ------------------ 752| 87| } else if (data_len == OGS_IPV4_LEN + OGS_IPV6_LEN) { ------------------ | | 381| 87|#define OGS_IPV4_LEN 4 ------------------ } else if (data_len == OGS_IPV4_LEN + OGS_IPV6_LEN) { ------------------ | | 382| 87|#define OGS_IPV6_LEN 16 ------------------ | Branch (752:20): [True: 5, False: 82] ------------------ 753| 5| memcpy(&ip->addr, data, OGS_IPV4_LEN); ------------------ | | 381| 5|#define OGS_IPV4_LEN 4 ------------------ 754| 5| memcpy(ip->addr6, data + OGS_IPV4_LEN, OGS_IPV6_LEN); ------------------ | | 381| 5|#define OGS_IPV4_LEN 4 ------------------ memcpy(ip->addr6, data + OGS_IPV4_LEN, OGS_IPV6_LEN); ------------------ | | 382| 5|#define OGS_IPV6_LEN 16 ------------------ 755| 82| } else if (data_len != 0) { ------------------ | Branch (755:20): [True: 24, False: 58] ------------------ 756| 24| ogs_error("Wrong IPv4v6 EUA length %u", data_len); ------------------ | | 36| 24|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 24| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 24|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 24| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 24|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 24| 0, __VA_ARGS__) | | ------------------ ------------------ 757| 24| return OGS_ERROR; ------------------ | | 78| 24|#define OGS_ERROR -1 ------------------ 758| 24| } 759| 72| ip->ipv4 = 1; 760| 72| ip->ipv6 = 1; 761| 72| break; 762| 9| default: ------------------ | Branch (762:5): [True: 9, False: 204] ------------------ 763| 9| ogs_error("No IPv4 or IPv6"); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 9|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 764| 9| return OGS_ERROR; ------------------ | | 78| 9|#define OGS_ERROR -1 ------------------ 765| 213| } 766| | 767| 156| return OGS_OK; ------------------ | | 77| 156|#define OGS_OK 0 ------------------ 768| 213|} ogs_gtp2_parse_msg: 2910| 850|{ 2911| 850| int rv = OGS_ERROR; ------------------ | | 78| 850|#define OGS_ERROR -1 ------------------ 2912| 850| ogs_gtp2_header_t *h = NULL; 2913| 850| uint16_t size = 0; 2914| | 2915| 850| ogs_assert(gtp2_message); ------------------ | | 113| 850| do { \ | | 114| 850| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 850|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 850, False: 0] | | | | ------------------ | | ------------------ | | 115| 850| 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| 850| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 850] | | ------------------ ------------------ 2916| 850| ogs_assert(pkbuf); ------------------ | | 113| 850| do { \ | | 114| 850| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 850|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 850, False: 0] | | | | ------------------ | | ------------------ | | 115| 850| 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| 850| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 850] | | ------------------ ------------------ 2917| 850| ogs_assert(pkbuf->len); ------------------ | | 113| 850| do { \ | | 114| 850| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 850|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 850, False: 0] | | | | ------------------ | | ------------------ | | 115| 850| 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| 850| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 850] | | ------------------ ------------------ 2918| | 2919| 850| h = (ogs_gtp2_header_t *)pkbuf->data; 2920| 850| ogs_assert(h); ------------------ | | 113| 850| do { \ | | 114| 850| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 850|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 850, False: 0] | | | | ------------------ | | ------------------ | | 115| 850| 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| 850| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 850] | | ------------------ ------------------ 2921| | 2922| 850| memset(gtp2_message, 0, sizeof(ogs_gtp2_message_t)); 2923| | 2924| 850| if (h->teid_presence) ------------------ | Branch (2924:9): [True: 42, False: 808] ------------------ 2925| 42| size = OGS_GTPV2C_HEADER_LEN; ------------------ | | 40| 42|#define OGS_GTPV2C_HEADER_LEN 12 ------------------ 2926| 808| else 2927| 808| size = OGS_GTPV2C_HEADER_LEN-OGS_GTP2_TEID_LEN; ------------------ | | 40| 808|#define OGS_GTPV2C_HEADER_LEN 12 ------------------ size = OGS_GTPV2C_HEADER_LEN-OGS_GTP2_TEID_LEN; ------------------ | | 41| 808|#define OGS_GTP2_TEID_LEN 4 ------------------ 2928| | 2929| 850| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2929:9): [True: 7, False: 843] ------------------ 2930| 7| ogs_error("ogs_pkbuf_pull() failed [len:%d]", pkbuf->len); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 7|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 2931| 7| return OGS_ERROR; ------------------ | | 78| 7|#define OGS_ERROR -1 ------------------ 2932| 7| } 2933| 843| memcpy(>p2_message->h, pkbuf->data - size, size); 2934| | 2935| 843| if (h->teid_presence) ------------------ | Branch (2935:9): [True: 37, False: 806] ------------------ 2936| 37| gtp2_message->h.teid = be32toh(gtp2_message->h.teid); 2937| | 2938| 843| if (pkbuf->len == 0) { ------------------ | Branch (2938:9): [True: 6, False: 837] ------------------ 2939| 6| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 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, \ | | | | | | ------------------ | | | | | | | | 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| 6| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 6] | | ------------------ ------------------ 2940| 6| return OGS_OK; ------------------ | | 77| 6|#define OGS_OK 0 ------------------ 2941| 6| } 2942| | 2943| 837| switch(gtp2_message->h.type) { 2944| 4| case OGS_GTP2_ECHO_REQUEST_TYPE: ------------------ | | 83| 4|#define OGS_GTP2_ECHO_REQUEST_TYPE 1 ------------------ | Branch (2944:5): [True: 4, False: 833] ------------------ 2945| 4| rv = ogs_tlv_parse_msg(>p2_message->echo_request, 2946| 4| &ogs_gtp2_tlv_desc_echo_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 4|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2947| 4| break; 2948| 14| case OGS_GTP2_ECHO_RESPONSE_TYPE: ------------------ | | 84| 14|#define OGS_GTP2_ECHO_RESPONSE_TYPE 2 ------------------ | Branch (2948:5): [True: 14, False: 823] ------------------ 2949| 14| rv = ogs_tlv_parse_msg(>p2_message->echo_response, 2950| 14| &ogs_gtp2_tlv_desc_echo_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 14|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2951| 14| break; 2952| 299| case OGS_GTP2_CREATE_SESSION_REQUEST_TYPE: ------------------ | | 86| 299|#define OGS_GTP2_CREATE_SESSION_REQUEST_TYPE 32 ------------------ | Branch (2952:5): [True: 299, False: 538] ------------------ 2953| 299| rv = ogs_tlv_parse_msg(>p2_message->create_session_request, 2954| 299| &ogs_gtp2_tlv_desc_create_session_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 299|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2955| 299| break; 2956| 5| case OGS_GTP2_CREATE_SESSION_RESPONSE_TYPE: ------------------ | | 87| 5|#define OGS_GTP2_CREATE_SESSION_RESPONSE_TYPE 33 ------------------ | Branch (2956:5): [True: 5, False: 832] ------------------ 2957| 5| rv = ogs_tlv_parse_msg(>p2_message->create_session_response, 2958| 5| &ogs_gtp2_tlv_desc_create_session_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 5|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2959| 5| break; 2960| 48| case OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE: ------------------ | | 88| 48|#define OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE 34 ------------------ | Branch (2960:5): [True: 48, False: 789] ------------------ 2961| 48| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_request, 2962| 48| &ogs_gtp2_tlv_desc_modify_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 48|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2963| 48| break; 2964| 60| case OGS_GTP2_MODIFY_BEARER_RESPONSE_TYPE: ------------------ | | 89| 60|#define OGS_GTP2_MODIFY_BEARER_RESPONSE_TYPE 35 ------------------ | Branch (2964:5): [True: 60, False: 777] ------------------ 2965| 60| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_response, 2966| 60| &ogs_gtp2_tlv_desc_modify_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 60|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2967| 60| 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: 836] ------------------ 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| 2| case OGS_GTP2_DELETE_SESSION_RESPONSE_TYPE: ------------------ | | 91| 2|#define OGS_GTP2_DELETE_SESSION_RESPONSE_TYPE 37 ------------------ | Branch (2972:5): [True: 2, False: 835] ------------------ 2973| 2| rv = ogs_tlv_parse_msg(>p2_message->delete_session_response, 2974| 2| &ogs_gtp2_tlv_desc_delete_session_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2975| 2| break; 2976| 1| case OGS_GTP2_MODIFY_BEARER_COMMAND_TYPE: ------------------ | | 96| 1|#define OGS_GTP2_MODIFY_BEARER_COMMAND_TYPE 64 ------------------ | Branch (2976:5): [True: 1, False: 836] ------------------ 2977| 1| rv = ogs_tlv_parse_msg(>p2_message->modify_bearer_command, 2978| 1| &ogs_gtp2_tlv_desc_modify_bearer_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2979| 1| 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: 836] ------------------ 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| 2| case OGS_GTP2_DELETE_BEARER_COMMAND_TYPE: ------------------ | | 98| 2|#define OGS_GTP2_DELETE_BEARER_COMMAND_TYPE 66 ------------------ | Branch (2984:5): [True: 2, False: 835] ------------------ 2985| 2| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_command, 2986| 2| &ogs_gtp2_tlv_desc_delete_bearer_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2987| 2| break; 2988| 2| case OGS_GTP2_DELETE_BEARER_FAILURE_INDICATION_TYPE: ------------------ | | 99| 2|#define OGS_GTP2_DELETE_BEARER_FAILURE_INDICATION_TYPE 67 ------------------ | Branch (2988:5): [True: 2, False: 835] ------------------ 2989| 2| rv = ogs_tlv_parse_msg(>p2_message->delete_bearer_failure_indication, 2990| 2| &ogs_gtp2_tlv_desc_delete_bearer_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2991| 2| break; 2992| 314| case OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE: ------------------ | | 100| 314|#define OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE 68 ------------------ | Branch (2992:5): [True: 314, False: 523] ------------------ 2993| 314| rv = ogs_tlv_parse_msg(>p2_message->bearer_resource_command, 2994| 314| &ogs_gtp2_tlv_desc_bearer_resource_command, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 314|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2995| 314| break; 2996| 1| case OGS_GTP2_BEARER_RESOURCE_FAILURE_INDICATION_TYPE: ------------------ | | 101| 1|#define OGS_GTP2_BEARER_RESOURCE_FAILURE_INDICATION_TYPE 69 ------------------ | Branch (2996:5): [True: 1, False: 836] ------------------ 2997| 1| rv = ogs_tlv_parse_msg(>p2_message->bearer_resource_failure_indication, 2998| 1| &ogs_gtp2_tlv_desc_bearer_resource_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 2999| 1| break; 3000| 2| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_FAILURE_INDICATION_TYPE: ------------------ | | 102| 2|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_FAILURE_INDICATION_TYPE 70 ------------------ | Branch (3000:5): [True: 2, False: 835] ------------------ 3001| 2| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification_failure_indication, 3002| 2| &ogs_gtp2_tlv_desc_downlink_data_notification_failure_indication, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3003| 2| break; 3004| 17| case OGS_GTP2_CREATE_BEARER_REQUEST_TYPE: ------------------ | | 106| 17|#define OGS_GTP2_CREATE_BEARER_REQUEST_TYPE 95 ------------------ | Branch (3004:5): [True: 17, False: 820] ------------------ 3005| 17| rv = ogs_tlv_parse_msg(>p2_message->create_bearer_request, 3006| 17| &ogs_gtp2_tlv_desc_create_bearer_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 17|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3007| 17| break; 3008| 28| case OGS_GTP2_CREATE_BEARER_RESPONSE_TYPE: ------------------ | | 107| 28|#define OGS_GTP2_CREATE_BEARER_RESPONSE_TYPE 96 ------------------ | Branch (3008:5): [True: 28, False: 809] ------------------ 3009| 28| rv = ogs_tlv_parse_msg(>p2_message->create_bearer_response, 3010| 28| &ogs_gtp2_tlv_desc_create_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 28|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3011| 28| 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: 834] ------------------ 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| 3| case OGS_GTP2_UPDATE_BEARER_RESPONSE_TYPE: ------------------ | | 109| 3|#define OGS_GTP2_UPDATE_BEARER_RESPONSE_TYPE 98 ------------------ | Branch (3016:5): [True: 3, False: 834] ------------------ 3017| 3| rv = ogs_tlv_parse_msg(>p2_message->update_bearer_response, 3018| 3| &ogs_gtp2_tlv_desc_update_bearer_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3019| 3| 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: 835] ------------------ 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: 836] ------------------ 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: 836] ------------------ 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| 5| case OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE: ------------------ | | 123| 5|#define OGS_GTP2_CREATE_INDIRECT_DATA_FORWARDING_TUNNEL_RESPONSE_TYPE 167 ------------------ | Branch (3032:5): [True: 5, False: 832] ------------------ 3033| 5| rv = ogs_tlv_parse_msg(>p2_message->create_indirect_data_forwarding_tunnel_response, 3034| 5| &ogs_gtp2_tlv_desc_create_indirect_data_forwarding_tunnel_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 5|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3035| 5| 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: 836] ------------------ 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: 836] ------------------ 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| 2| case OGS_GTP2_RELEASE_ACCESS_BEARERS_REQUEST_TYPE: ------------------ | | 126| 2|#define OGS_GTP2_RELEASE_ACCESS_BEARERS_REQUEST_TYPE 170 ------------------ | Branch (3042:5): [True: 2, False: 835] ------------------ 3043| 2| rv = ogs_tlv_parse_msg(>p2_message->release_access_bearers_request, 3044| 2| &ogs_gtp2_tlv_desc_release_access_bearers_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3045| 2| break; 3046| 1| case OGS_GTP2_RELEASE_ACCESS_BEARERS_RESPONSE_TYPE: ------------------ | | 127| 1|#define OGS_GTP2_RELEASE_ACCESS_BEARERS_RESPONSE_TYPE 171 ------------------ | Branch (3046:5): [True: 1, False: 836] ------------------ 3047| 1| rv = ogs_tlv_parse_msg(>p2_message->release_access_bearers_response, 3048| 1| &ogs_gtp2_tlv_desc_release_access_bearers_response, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3049| 1| break; 3050| 1| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_TYPE: ------------------ | | 128| 1|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_TYPE 176 ------------------ | Branch (3050:5): [True: 1, False: 836] ------------------ 3051| 1| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification, 3052| 1| &ogs_gtp2_tlv_desc_downlink_data_notification, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 1|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3053| 1| break; 3054| 3| case OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_ACKNOWLEDGE_TYPE: ------------------ | | 129| 3|#define OGS_GTP2_DOWNLINK_DATA_NOTIFICATION_ACKNOWLEDGE_TYPE 177 ------------------ | Branch (3054:5): [True: 3, False: 834] ------------------ 3055| 3| rv = ogs_tlv_parse_msg(>p2_message->downlink_data_notification_acknowledge, 3056| 3| &ogs_gtp2_tlv_desc_downlink_data_notification_acknowledge, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 3|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3057| 3| break; 3058| 2| case OGS_GTP2_MODIFY_ACCESS_BEARERS_REQUEST_TYPE: ------------------ | | 134| 2|#define OGS_GTP2_MODIFY_ACCESS_BEARERS_REQUEST_TYPE 211 ------------------ | Branch (3058:5): [True: 2, False: 835] ------------------ 3059| 2| rv = ogs_tlv_parse_msg(>p2_message->modify_access_bearers_request, 3060| 2| &ogs_gtp2_tlv_desc_modify_access_bearers_request, pkbuf, OGS_TLV_MODE_T1_L2_I1); ------------------ | | 34| 2|#define OGS_TLV_MODE_T1_L2_I1 3 ------------------ 3061| 2| 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: 833] ------------------ 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| 6| default: ------------------ | Branch (3066:5): [True: 6, False: 831] ------------------ 3067| 6| ogs_warn("Not implemented(type:%d)", gtp2_message->h.type); ------------------ | | 37| 6|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 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__) | | ------------------ ------------------ 3068| 6| break; 3069| 837| } 3070| | 3071| 837| ogs_assert(ogs_pkbuf_push(pkbuf, size)); ------------------ | | 113| 837| do { \ | | 114| 837| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 837|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 837, False: 0] | | | | ------------------ | | ------------------ | | 115| 837| 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| 837| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 837] | | ------------------ ------------------ 3072| | 3073| 837| return rv; 3074| 837|} ogs_gtp2_parse_bearer_qos: 28| 50|{ 29| 50| ogs_gtp2_bearer_qos_t *source = NULL; 30| 50| int16_t size = 0; 31| | 32| 50| ogs_assert(bearer_qos); ------------------ | | 113| 50| do { \ | | 114| 50| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 50|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 50, False: 0] | | | | ------------------ | | ------------------ | | 115| 50| 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| 50| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 50] | | ------------------ ------------------ 33| 50| ogs_assert(octet); ------------------ | | 113| 50| do { \ | | 114| 50| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 50|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 50, False: 0] | | | | ------------------ | | ------------------ | | 115| 50| 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| 50| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 50] | | ------------------ ------------------ 34| | 35| | /* Validate IE length instead of asserting */ 36| 50| if (octet->len != GTP2_BEARER_QOS_LEN) { ------------------ | | 287| 50|#define GTP2_BEARER_QOS_LEN 22 ------------------ | Branch (36:9): [True: 32, False: 18] ------------------ 37| 32| ogs_error("Invalid Bearer QoS IE length [%u], expected [%u]", ------------------ | | 36| 32|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 32| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 32|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 32| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 32|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 32| 0, __VA_ARGS__) | | ------------------ ------------------ 38| 32| octet->len, GTP2_BEARER_QOS_LEN); 39| 32| return 0; 40| 32| } 41| | 42| 18| source = (ogs_gtp2_bearer_qos_t *)octet->data; 43| | 44| 18| memset(bearer_qos, 0, sizeof(ogs_gtp2_bearer_qos_t)); 45| | 46| 18| bearer_qos->pre_emption_capability = source->pre_emption_capability; 47| 18| bearer_qos->priority_level = source->priority_level; 48| 18| bearer_qos->pre_emption_vulnerability = source->pre_emption_vulnerability; 49| 18| size++; 50| | 51| 18| bearer_qos->qci = source->qci; 52| 18| size++; 53| | 54| | /* 55| | * Ch 8.15 Bearer QoS in TS 29.274 v15.9.0 56| | * 57| | * The UL/DL MBR and GBR fields are encoded as kilobits 58| | * per second (1 kbps = 1000 bps) in binary value. 59| | */ 60| 18| bearer_qos->ul_mbr = ogs_buffer_to_uint64( 61| 18| (unsigned char *)octet->data + size, 5) * 1000; 62| 18| size += 5; 63| 18| bearer_qos->dl_mbr = ogs_buffer_to_uint64( 64| 18| (unsigned char *)octet->data + size, 5) * 1000; 65| 18| size += 5; 66| 18| bearer_qos->ul_gbr = ogs_buffer_to_uint64( 67| 18| (unsigned char *)octet->data + size, 5) * 1000; 68| 18| size += 5; 69| 18| bearer_qos->dl_gbr = ogs_buffer_to_uint64( 70| 18| (unsigned char *)octet->data + size, 5) * 1000; 71| 18| size += 5; 72| | 73| 18| ogs_assert(size == octet->len); ------------------ | | 113| 18| do { \ | | 114| 18| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 18|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 18, False: 0] | | | | ------------------ | | ------------------ | | 115| 18| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 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| 18| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 18] | | ------------------ ------------------ 74| | 75| 18| return size; 76| 18|} ogs_gtp2_parse_flow_qos: 211| 21|{ 212| 21| ogs_gtp2_flow_qos_t *source = NULL; 213| 21| int16_t size = 0; 214| | 215| 21| ogs_assert(flow_qos); ------------------ | | 113| 21| do { \ | | 114| 21| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 21|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 21, False: 0] | | | | ------------------ | | ------------------ | | 115| 21| 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| 21| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 21] | | ------------------ ------------------ 216| 21| ogs_assert(octet); ------------------ | | 113| 21| do { \ | | 114| 21| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 21|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 21, False: 0] | | | | ------------------ | | ------------------ | | 115| 21| 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| 21| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 21] | | ------------------ ------------------ 217| | 218| 21| if (octet->len != GTP2_FLOW_QOS_LEN) { ------------------ | | 317| 21|#define GTP2_FLOW_QOS_LEN 21 ------------------ | Branch (218:9): [True: 20, False: 1] ------------------ 219| 20| ogs_error("Invalid Flow QoS IE length [%u], expected [%u]", ------------------ | | 36| 20|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 20|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 220| 20| octet->len, GTP2_FLOW_QOS_LEN); 221| 20| return 0; 222| 20| } 223| | 224| 1| source = (ogs_gtp2_flow_qos_t *)octet->data; 225| | 226| 1| memset(flow_qos, 0, sizeof(ogs_gtp2_flow_qos_t)); 227| | 228| 1| flow_qos->qci = source->qci; 229| 1| size++; 230| | 231| | /* 232| | * Ch 8.16 Flow QoS in TS 29.274 v15.9.0 233| | * 234| | * The UL/DL MBR and GBR fields are encoded as kilobits 235| | * per second (1 kbps = 1000 bps) in binary value. 236| | */ 237| 1| flow_qos->ul_mbr = ogs_buffer_to_uint64( 238| 1| (unsigned char *)octet->data + size, 5) * 1000; 239| 1| size += 5; 240| 1| flow_qos->dl_mbr = ogs_buffer_to_uint64( 241| 1| (unsigned char *)octet->data + size, 5) * 1000; 242| 1| size += 5; 243| 1| flow_qos->ul_gbr = ogs_buffer_to_uint64( 244| 1| (unsigned char *)octet->data + size, 5) * 1000; 245| 1| size += 5; 246| 1| flow_qos->dl_gbr = ogs_buffer_to_uint64( 247| 1| (unsigned char *)octet->data + size, 5) * 1000; 248| 1| size += 5; 249| | 250| 1| ogs_assert(size == octet->len); ------------------ | | 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] | | ------------------ ------------------ 251| | 252| 1| return size; 253| 1|} ogs_gtp2_parse_tft: 298| 668|{ 299| 668| int16_t size = 0; 300| 668| int i, j, len = 0; 301| | 302| 668| ogs_assert(tft); ------------------ | | 113| 668| do { \ | | 114| 668| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 668|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 668, False: 0] | | | | ------------------ | | ------------------ | | 115| 668| 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| 668| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 668] | | ------------------ ------------------ 303| 668| ogs_assert(octet); ------------------ | | 113| 668| do { \ | | 114| 668| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 668|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 668, False: 0] | | | | ------------------ | | ------------------ | | 115| 668| 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| 668| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 668] | | ------------------ ------------------ 304| | 305| 668| memset(tft, 0, sizeof(ogs_gtp2_tft_t)); 306| | 307| 668| if (size + (int)sizeof(tft->flags) > octet->len) { ------------------ | Branch (307:9): [True: 0, False: 668] ------------------ 308| 0| ogs_error("TFT: size[%d]+flags[%d] > IE Length[%d]", ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 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__) | | ------------------ ------------------ 309| 0| size, (int)sizeof(tft->flags), octet->len); 310| 0| return size; 311| 0| } 312| 668| memcpy(&tft->flags, (unsigned char *)octet->data+size, sizeof(tft->flags)); 313| 668| size++; 314| | 315| 668| if (tft->code == OGS_GTP2_TFT_CODE_IGNORE_THIS_IE) { ------------------ | | 358| 668|#define OGS_GTP2_TFT_CODE_IGNORE_THIS_IE 0 ------------------ | Branch (315:9): [True: 32, False: 636] ------------------ 316| 32| ogs_error("Invalid TFT Code(Spare)"); ------------------ | | 36| 32|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 32| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 32|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 32| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 32|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 32| 0, __VA_ARGS__) | | ------------------ ------------------ 317| 32| return size; 318| 32| } 319| | 320| 636| if (tft->code == OGS_GTP2_TFT_CODE_NO_TFT_OPERATION || ------------------ | | 364| 1.27k|#define OGS_GTP2_TFT_CODE_NO_TFT_OPERATION 6 ------------------ | Branch (320:9): [True: 19, False: 617] ------------------ 321| 617| tft->code == OGS_GTP2_TFT_CODE_DELETE_EXISTING_TFT) ------------------ | | 360| 617|#define OGS_GTP2_TFT_CODE_DELETE_EXISTING_TFT 2 ------------------ | Branch (321:9): [True: 18, False: 599] ------------------ 322| 37| return size; 323| | 324| 1.36k| for (i = 0; i < tft->num_of_packet_filter && ------------------ | Branch (324:17): [True: 1.28k, False: 82] ------------------ 325| 1.28k| i < OGS_MAX_NUM_OF_FLOW_IN_GTP ; i++) { ------------------ | | 71| 1.28k|#define OGS_MAX_NUM_OF_FLOW_IN_GTP OGS_MAX_NUM_OF_FLOW_IN_PDR | | ------------------ | | | | 70| 1.28k|#define OGS_MAX_NUM_OF_FLOW_IN_PDR 15 | | ------------------ ------------------ | Branch (325:17): [True: 1.28k, False: 0] ------------------ 326| 1.28k| if (size + (int)sizeof(tft->pf[i].flags) > octet->len) { ------------------ | Branch (326:13): [True: 59, False: 1.22k] ------------------ 327| 59| ogs_error("TFT: size[%d]+pf[%d].flags[%d] > IE Length[%d]", ------------------ | | 36| 59|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 59| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 59|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 59| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 59|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 59| 0, __VA_ARGS__) | | ------------------ ------------------ 328| 59| size, i, (int)sizeof(tft->pf[i].flags), octet->len); 329| 59| return size; 330| 59| } 331| 1.22k| memcpy(&tft->pf[i].flags, (unsigned char *)octet->data+size, 332| 1.22k| sizeof(tft->pf[i].flags)); 333| 1.22k| size += sizeof(tft->pf[i].flags); 334| | 335| 1.22k| if (tft->code == OGS_GTP2_TFT_CODE_DELETE_PACKET_FILTERS_FROM_EXISTING) ------------------ | | 363| 1.22k|#define OGS_GTP2_TFT_CODE_DELETE_PACKET_FILTERS_FROM_EXISTING 5 ------------------ | Branch (335:13): [True: 147, False: 1.07k] ------------------ 336| 147| continue; 337| | 338| 1.07k| if (size + (int)sizeof(tft->pf[i].precedence) > octet->len) { ------------------ | Branch (338:13): [True: 37, False: 1.04k] ------------------ 339| 37| ogs_error("TFT: size[%d]+pf[%d].precedence[%d] > IE Length[%d]", ------------------ | | 36| 37|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 37| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 37|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 37| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 37|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 37| 0, __VA_ARGS__) | | ------------------ ------------------ 340| 37| size, i, (int)sizeof(tft->pf[i].precedence), octet->len); 341| 37| return size; 342| 37| } 343| 1.04k| memcpy(&tft->pf[i].precedence, (unsigned char *)octet->data+size, 344| 1.04k| sizeof(tft->pf[i].precedence)); 345| 1.04k| size += sizeof(tft->pf[i].precedence); 346| | 347| 1.04k| if (size + (int)sizeof(tft->pf[i].content.length) > octet->len) { ------------------ | Branch (347:13): [True: 29, False: 1.01k] ------------------ 348| 29| ogs_error("TFT: size[%d]+pf[%d].content.length[%d] > IE Length[%d]", ------------------ | | 36| 29|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 29| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 29|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 29| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 29|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 29| 0, __VA_ARGS__) | | ------------------ ------------------ 349| 29| size, i, (int)sizeof(tft->pf[i].content.length), 350| 29| octet->len); 351| 29| return size; 352| 29| } 353| 1.01k| memcpy(&tft->pf[i].content.length, (unsigned char *)octet->data+size, 354| 1.01k| sizeof(tft->pf[i].content.length)); 355| 1.01k| size += sizeof(tft->pf[i].content.length); 356| | 357| | /* 358| | * Critical validation: 359| | * content.length must not exceed remaining IE length. 360| | * This prevents out-of-bounds reads/crash for malformed TFT/TAD. 361| | */ 362| 1.01k| if ((int)tft->pf[i].content.length > (octet->len - size)) { ------------------ | Branch (362:13): [True: 43, False: 970] ------------------ 363| 43| ogs_error("TFT: pf[%d].content.length[%u] > remaining[%d] " ------------------ | | 36| 43|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 43| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 43|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 43| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 43|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 43| 0, __VA_ARGS__) | | ------------------ ------------------ 364| 43| "(size[%d], IE[%d])", i, tft->pf[i].content.length, 365| 43| octet->len - size, size, octet->len); 366| 43| return size; 367| 43| } 368| | 369| 970| j = 0; len = 0; 370| 3.15k| while(len < tft->pf[i].content.length) { ------------------ | Branch (370:15): [True: 2.53k, False: 621] ------------------ 371| 2.53k| int comp_max = (int)(sizeof(tft->pf[i].content.component) / 372| 2.53k| sizeof(tft->pf[i].content.component[0])); 373| 2.53k| if (j >= comp_max) { ------------------ | Branch (373:17): [True: 15, False: 2.52k] ------------------ 374| 15| ogs_error("TFT: pf[%d] too many components (j[%d] >= max[%d])", ------------------ | | 36| 15|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 15| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 15|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 15| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 15|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 15| 0, __VA_ARGS__) | | ------------------ ------------------ 375| 15| i, j, comp_max); 376| 15| return size; 377| 15| } 378| 2.52k| if (size + len + (int)sizeof(tft->pf[i].content.component[j].type) > ------------------ | Branch (378:17): [True: 0, False: 2.52k] ------------------ 379| 2.52k| octet->len) { 380| 0| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 381| 0| "type[%d] > IE Length[%d]", 382| 0| size, len, i, j, 383| 0| (int)sizeof(tft->pf[i].content.component[j].type), 384| 0| octet->len); 385| 0| return size; 386| 0| } 387| 2.52k| memcpy(&tft->pf[i].content.component[j].type, 388| 2.52k| (unsigned char *)octet->data+size+len, 389| 2.52k| sizeof(tft->pf[i].content.component[j].type)); 390| 2.52k| len += sizeof(tft->pf[i].content.component[j].type); 391| 2.52k| switch(tft->pf[i].content.component[j].type) { 392| 393| case OGS_PACKET_FILTER_PROTOCOL_IDENTIFIER_NEXT_HEADER_TYPE: ------------------ | | 93| 393|#define OGS_PACKET_FILTER_PROTOCOL_IDENTIFIER_NEXT_HEADER_TYPE 48 ------------------ | Branch (392:13): [True: 393, False: 2.12k] ------------------ 393| 393| if (size + len + ------------------ | Branch (393:21): [True: 19, False: 374] ------------------ 394| 393| (int)sizeof(tft->pf[i].content.component[j].proto) > 395| 393| octet->len) { 396| 19| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 19|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 397| 19| "proto[%d] > IE Length[%d]", size, len, i, j, 398| 19| (int)sizeof(tft->pf[i].content.component[j].proto), 399| 19| octet->len); 400| 19| return size; 401| 19| } 402| 374| memcpy(&tft->pf[i].content.component[j].proto, 403| 374| (unsigned char *)octet->data+size+len, 404| 374| sizeof(tft->pf[i].content.component[j].proto)); 405| 374| len += sizeof(tft->pf[i].content.component[j].proto); 406| 374| break; 407| 209| case OGS_PACKET_FILTER_IPV4_REMOTE_ADDRESS_TYPE: ------------------ | | 94| 209|#define OGS_PACKET_FILTER_IPV4_REMOTE_ADDRESS_TYPE 16 ------------------ | Branch (407:13): [True: 209, False: 2.31k] ------------------ 408| 488| case OGS_PACKET_FILTER_IPV4_LOCAL_ADDRESS_TYPE: ------------------ | | 95| 488|#define OGS_PACKET_FILTER_IPV4_LOCAL_ADDRESS_TYPE 17 ------------------ | Branch (408:13): [True: 279, False: 2.24k] ------------------ 409| 488| if (size + len + ------------------ | Branch (409:21): [True: 34, False: 454] ------------------ 410| 488| (int)sizeof(tft->pf[i].content.component[j].ipv4.addr) > 411| 488| octet->len) { 412| 34| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 34|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 34| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 34|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 34| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 34|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 34| 0, __VA_ARGS__) | | ------------------ ------------------ 413| 34| "ipv4.addr[%d] > IE Length[%d]", 414| 34| size, len, i, j, 415| 34| (int)sizeof(tft->pf[i].content.component[j]. 416| 34| ipv4.addr), 417| 34| octet->len); 418| 34| return size; 419| 34| } 420| 454| memcpy(&tft->pf[i].content.component[j].ipv4.addr, 421| 454| (unsigned char *)octet->data+size+len, 422| 454| sizeof(tft->pf[i].content.component[j].ipv4.addr)); 423| 454| len += sizeof(tft->pf[i].content.component[j].ipv4.addr); 424| | 425| 454| if (size + len + ------------------ | Branch (425:21): [True: 29, False: 425] ------------------ 426| 454| (int)sizeof(tft->pf[i].content.component[j].ipv4.mask) > 427| 454| octet->len) { 428| 29| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 29|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 29| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 29|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 29| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 29|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 29| 0, __VA_ARGS__) | | ------------------ ------------------ 429| 29| "ipv4.mask[%d] > IE Length[%d]", 430| 29| size, len, i, j, 431| 29| (int)sizeof(tft->pf[i].content.component[j]. 432| 29| ipv4.mask), 433| 29| octet->len); 434| 29| return size; 435| 29| } 436| 425| memcpy(&tft->pf[i].content.component[j].ipv4.mask, 437| 425| (unsigned char *)octet->data+size+len, 438| 425| sizeof(tft->pf[i].content.component[j].ipv4.mask)); 439| 425| len += sizeof(tft->pf[i].content.component[j].ipv4.mask); 440| 425| break; 441| 91| case OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_PREFIX_LENGTH_TYPE: ------------------ | | 99| 91|#define OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_PREFIX_LENGTH_TYPE 35 ------------------ | Branch (441:13): [True: 91, False: 2.42k] ------------------ 442| 281| case OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_PREFIX_LENGTH_TYPE: ------------------ | | 97| 281|#define OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_PREFIX_LENGTH_TYPE 33 ------------------ | Branch (442:13): [True: 190, False: 2.33k] ------------------ 443| 281| if (size + len + (int)sizeof(tft->pf[i].content.component[j]. ------------------ | Branch (443:21): [True: 45, False: 236] ------------------ 444| 281| ipv6.addr) > 445| 281| octet->len) { 446| 45| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 45|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 45| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 45|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 45| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 45|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 45| 0, __VA_ARGS__) | | ------------------ ------------------ 447| 45| "ipv6.addr[%d] > IE Length[%d]", 448| 45| size, len, i, j, 449| 45| (int)sizeof(tft->pf[i].content.component[j]. 450| 45| ipv6.addr), 451| 45| octet->len); 452| 45| return size; 453| 45| } 454| 236| memcpy(&tft->pf[i].content.component[j].ipv6.addr, 455| 236| (unsigned char *)octet->data+size+len, 456| 236| sizeof(tft->pf[i].content.component[j].ipv6.addr)); 457| 236| len += sizeof(tft->pf[i].content.component[j].ipv6.addr); 458| | 459| 236| if (size + len + (int)sizeof(tft->pf[i].content.component[j]. ------------------ | Branch (459:21): [True: 19, False: 217] ------------------ 460| 236| ipv6.prefixlen) > 461| 236| octet->len) { 462| 19| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 19|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 19| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 19|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 19| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 19|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 19| 0, __VA_ARGS__) | | ------------------ ------------------ 463| 19| "ipv6.prefixlen[%d] > IE Length[%d]", 464| 19| size, len, i, j, 465| 19| (int)sizeof(tft->pf[i].content.component[j]. 466| 19| ipv6.prefixlen), 467| 19| octet->len); 468| 19| return size; 469| 19| } 470| 217| memcpy(&tft->pf[i].content.component[j].ipv6.prefixlen, 471| 217| (unsigned char *)octet->data+size+len, 472| 217| sizeof(tft->pf[i].content.component[j].ipv6.prefixlen)); 473| 217| len += sizeof(tft->pf[i].content.component[j].ipv6.prefixlen); 474| 217| break; 475| 65| case OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_TYPE: ------------------ | | 98| 65|#define OGS_PACKET_FILTER_IPV6_LOCAL_ADDRESS_TYPE 34 ------------------ | Branch (475:13): [True: 65, False: 2.45k] ------------------ 476| 234| case OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_TYPE: ------------------ | | 96| 234|#define OGS_PACKET_FILTER_IPV6_REMOTE_ADDRESS_TYPE 32 ------------------ | Branch (476:13): [True: 169, False: 2.35k] ------------------ 477| 234| if (size + len + (int)sizeof(tft->pf[i].content.component[j]. ------------------ | Branch (477:21): [True: 46, False: 188] ------------------ 478| 234| ipv6_mask.addr) > 479| 234| octet->len) { 480| 46| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 46|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 46| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 46|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 46| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 46|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 46| 0, __VA_ARGS__) | | ------------------ ------------------ 481| 46| "ipv6_mask.addr[%d] > IE Length[%d]", 482| 46| size, len, i, j, 483| 46| (int)sizeof(tft->pf[i].content.component[j]. 484| 46| ipv6_mask.addr), 485| 46| octet->len); 486| 46| return size; 487| 46| } 488| 188| memcpy(&tft->pf[i].content.component[j].ipv6_mask.addr, 489| 188| (unsigned char *)octet->data+size+len, 490| 188| sizeof(tft->pf[i].content.component[j].ipv6_mask.addr)); 491| 188| len += sizeof(tft->pf[i].content.component[j].ipv6_mask.addr); 492| | 493| 188| if (size + len + (int)sizeof(tft->pf[i].content.component[j]. ------------------ | Branch (493:21): [True: 27, False: 161] ------------------ 494| 188| ipv6_mask.mask) > 495| 188| octet->len) { 496| 27| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 27|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 27| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 27|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 27| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 27|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 27| 0, __VA_ARGS__) | | ------------------ ------------------ 497| 27| "ipv6_mask.mask[%d] > IE Length[%d]", 498| 27| size, len, i, j, 499| 27| (int)sizeof(tft->pf[i].content.component[j]. 500| 27| ipv6_mask.mask), 501| 27| octet->len); 502| 27| return size; 503| 27| } 504| 161| memcpy(&tft->pf[i].content.component[j].ipv6_mask.mask, 505| 161| (unsigned char *)octet->data+size+len, 506| 161| sizeof(tft->pf[i].content.component[j].ipv6_mask.mask)); 507| 161| len += sizeof(tft->pf[i].content.component[j].ipv6_mask.mask); 508| 161| break; 509| 257| case OGS_PACKET_FILTER_SINGLE_LOCAL_PORT_TYPE: ------------------ | | 100| 257|#define OGS_PACKET_FILTER_SINGLE_LOCAL_PORT_TYPE 64 ------------------ | Branch (509:13): [True: 257, False: 2.26k] ------------------ 510| 507| case OGS_PACKET_FILTER_SINGLE_REMOTE_PORT_TYPE: ------------------ | | 102| 507|#define OGS_PACKET_FILTER_SINGLE_REMOTE_PORT_TYPE 80 ------------------ | Branch (510:13): [True: 250, False: 2.27k] ------------------ 511| 507| if (size + len + (int)sizeof(tft->pf[i].content.component[j]. ------------------ | Branch (511:21): [True: 29, False: 478] ------------------ 512| 507| port.low) > 513| 507| octet->len) { 514| 29| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 29|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 29| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 29|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 29| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 29|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 29| 0, __VA_ARGS__) | | ------------------ ------------------ 515| 29| "port.low[%d] > IE Length[%d]", 516| 29| size, len, i, j, 517| 29| (int)sizeof(tft->pf[i].content.component[j]. 518| 29| port.low), 519| 29| octet->len); 520| 29| return size; 521| 29| } 522| 478| memcpy(&tft->pf[i].content.component[j].port.low, 523| 478| (unsigned char *)octet->data+size+len, 524| 478| sizeof(tft->pf[i].content.component[j].port.low)); 525| 478| tft->pf[i].content.component[j].port.low = 526| 478| be16toh(tft->pf[i].content.component[j].port.low); 527| 478| len += sizeof(tft->pf[i].content.component[j].port.low); 528| 478| break; 529| 169| case OGS_PACKET_FILTER_LOCAL_PORT_RANGE_TYPE: ------------------ | | 101| 169|#define OGS_PACKET_FILTER_LOCAL_PORT_RANGE_TYPE 65 ------------------ | Branch (529:13): [True: 169, False: 2.35k] ------------------ 530| 583| case OGS_PACKET_FILTER_REMOTE_PORT_RANGE_TYPE: ------------------ | | 103| 583|#define OGS_PACKET_FILTER_REMOTE_PORT_RANGE_TYPE 81 ------------------ | Branch (530:13): [True: 414, False: 2.10k] ------------------ 531| 583| if (size + len + (int)sizeof(tft->pf[i].content.component[j]. ------------------ | Branch (531:21): [True: 26, False: 557] ------------------ 532| 583| port.low) > 533| 583| octet->len) { 534| 26| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 26|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 26| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 26|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 26| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 26|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 26| 0, __VA_ARGS__) | | ------------------ ------------------ 535| 26| "port.low[%d] > IE Length[%d]", 536| 26| size, len, i, j, 537| 26| (int)sizeof(tft->pf[i].content.component[j]. 538| 26| port.low), 539| 26| octet->len); 540| 26| return size; 541| 26| } 542| 557| memcpy(&tft->pf[i].content.component[j].port.low, 543| 557| (unsigned char *)octet->data+size+len, 544| 557| sizeof(tft->pf[i].content.component[j].port.low)); 545| 557| tft->pf[i].content.component[j].port.low = 546| 557| be16toh(tft->pf[i].content.component[j].port.low); 547| 557| len += sizeof(tft->pf[i].content.component[j].port.low); 548| | 549| 557| if (size + len + (int)sizeof(tft->pf[i].content.component[j]. ------------------ | Branch (549:21): [True: 26, False: 531] ------------------ 550| 557| port.high) > 551| 557| octet->len) { 552| 26| ogs_error("TFT: size[%d]+len[%d]+pf[%d].component[%d]." ------------------ | | 36| 26|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 26| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 26|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 26| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 26|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 26| 0, __VA_ARGS__) | | ------------------ ------------------ 553| 26| "port.high[%d] > IE Length[%d]", 554| 26| size, len, i, j, 555| 26| (int)sizeof(tft->pf[i].content.component[j]. 556| 26| port.high), 557| 26| octet->len); 558| 26| return size; 559| 26| } 560| 531| memcpy(&tft->pf[i].content.component[j].port.high, 561| 531| (unsigned char *)octet->data+size+len, 562| 531| sizeof(tft->pf[i].content.component[j].port.high)); 563| 531| tft->pf[i].content.component[j].port.high = 564| 531| be16toh(tft->pf[i].content.component[j].port.high); 565| 531| len += sizeof(tft->pf[i].content.component[j].port.high); 566| 531| break; 567| 34| default: ------------------ | Branch (567:13): [True: 34, False: 2.48k] ------------------ 568| 34| ogs_error("Unknown Packet Filter Type(%d)", ------------------ | | 36| 34|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 34| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 34|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 34| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 34|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 34| 0, __VA_ARGS__) | | ------------------ ------------------ 569| 34| tft->pf[i].content.component[j].type); 570| 34| return -1; 571| 2.52k| } 572| 2.18k| j++; 573| 2.18k| } 574| 621| tft->pf[i].content.num_of_component = j; 575| 621| size += len; 576| 621| } 577| | 578| 82| if (size != octet->len) ------------------ | Branch (578:9): [True: 47, False: 35] ------------------ 579| 82| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", octet->len, size); ------------------ | | 36| 47|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 47| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 47|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 47| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 47|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 47| 0, __VA_ARGS__) | | ------------------ ------------------ 580| | 581| 82| return size; 582| 599|} ogs_gtp2_parse_uli: 755| 110|{ 756| 110| ogs_gtp2_uli_t *source = NULL; 757| 110| int16_t size = 0; 758| | 759| 110| ogs_assert(uli); ------------------ | | 113| 110| do { \ | | 114| 110| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 110|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 110, False: 0] | | | | ------------------ | | ------------------ | | 115| 110| 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| 110| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 110] | | ------------------ ------------------ 760| 110| ogs_assert(octet); ------------------ | | 113| 110| do { \ | | 114| 110| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 110|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 110, False: 0] | | | | ------------------ | | ------------------ | | 115| 110| 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| 110| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 110] | | ------------------ ------------------ 761| | 762| 110| source = (ogs_gtp2_uli_t *)octet->data; 763| | 764| 110| memset(uli, 0, sizeof(ogs_gtp2_uli_t)); 765| | 766| 110| if (octet->len < 1) { ------------------ | Branch (766:9): [True: 0, False: 110] ------------------ 767| 0| ogs_error("ULI IE too short [%u]", octet->len); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 768| 0| return 0; 769| 0| } 770| | 771| 110| uli->flags = source->flags; 772| 110| size++; 773| | 774| 110| if (uli->flags.cgi) { ------------------ | Branch (774:9): [True: 37, False: 73] ------------------ 775| 37| if (size + sizeof(uli->cgi) > octet->len) { ------------------ | Branch (775:13): [True: 4, False: 33] ------------------ 776| 4| ogs_error("size[%d]+sizeof(uli->cgi)[%d] > IE Length[%d]", ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 777| 4| size, (int)sizeof(uli->cgi), octet->len); 778| 4| return 0; 779| 4| } 780| 33| memcpy(&uli->cgi, 781| 33| (unsigned char *)octet->data + size, sizeof(uli->cgi)); 782| 33| uli->cgi.lac = be16toh(uli->cgi.lac); 783| 33| uli->cgi.ci = be16toh(uli->cgi.ci); 784| 33| size += sizeof(uli->cgi); 785| 33| } 786| 106| if (uli->flags.sai) { ------------------ | Branch (786:9): [True: 46, False: 60] ------------------ 787| 46| if (size + sizeof(uli->sai) > octet->len) { ------------------ | Branch (787:13): [True: 4, False: 42] ------------------ 788| 4| ogs_error("size[%d]+sizeof(uli->sai)[%d] > IE Length[%d]", ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 789| 4| size, (int)sizeof(uli->sai), octet->len); 790| 4| return 0; 791| 4| } 792| 42| memcpy(&uli->sai, 793| 42| (unsigned char *)octet->data + size, sizeof(uli->sai)); 794| 42| uli->sai.lac = be16toh(uli->sai.lac); 795| 42| uli->sai.sac = be16toh(uli->sai.sac); 796| 42| size += sizeof(uli->sai); 797| 42| } 798| 102| if (uli->flags.rai) { ------------------ | Branch (798:9): [True: 39, False: 63] ------------------ 799| 39| if (size + sizeof(uli->rai) > octet->len) { ------------------ | Branch (799:13): [True: 4, False: 35] ------------------ 800| 4| ogs_error("size[%d]+sizeof(uli->lai)[%d] > IE Length[%d]", ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 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__) | | ------------------ ------------------ 801| 4| size, (int)sizeof(uli->lai), octet->len); 802| 4| return 0; 803| 4| } 804| 35| memcpy(&uli->rai, 805| 35| (unsigned char *)octet->data + size, sizeof(uli->rai)); 806| 35| uli->rai.lac = be16toh(uli->rai.lac); 807| 35| uli->rai.rac = be16toh(uli->rai.rac); 808| 35| size += sizeof(uli->rai); 809| 35| } 810| 98| if (uli->flags.tai) { ------------------ | Branch (810:9): [True: 43, False: 55] ------------------ 811| 43| if (size + sizeof(uli->tai) > octet->len) { ------------------ | Branch (811:13): [True: 9, False: 34] ------------------ 812| 9| ogs_error("size[%d]+sizeof(uli->tai)[%d] > IE Length[%d]", ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 9|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 813| 9| size, (int)sizeof(uli->tai), octet->len); 814| 9| return 0; 815| 9| } 816| 34| memcpy(&uli->tai, 817| 34| (unsigned char *)octet->data + size, sizeof(uli->tai)); 818| 34| uli->tai.tac = be16toh(uli->tai.tac); 819| 34| size += sizeof(uli->tai); 820| 34| } 821| 89| if (uli->flags.e_cgi) { ------------------ | Branch (821:9): [True: 46, False: 43] ------------------ 822| 46| if (size + sizeof(uli->e_cgi) > octet->len) { ------------------ | Branch (822:13): [True: 11, False: 35] ------------------ 823| 11| ogs_error("size[%d]+sizeof(uli->e_cgi)[%d] > IE Length[%d]", ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 11|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 824| 11| size, (int)sizeof(uli->e_cgi), octet->len); 825| 11| return 0; 826| 11| } 827| 35| memcpy(&uli->e_cgi, 828| 35| (unsigned char *)octet->data + size, sizeof(uli->e_cgi)); 829| 35| uli->e_cgi.cell_id = be32toh(uli->e_cgi.cell_id); 830| 35| size += sizeof(uli->e_cgi); 831| 35| } 832| 78| if (uli->flags.lai) { ------------------ | Branch (832:9): [True: 44, False: 34] ------------------ 833| 44| if (size + sizeof(uli->lai) > octet->len) { ------------------ | Branch (833:13): [True: 9, False: 35] ------------------ 834| 9| ogs_error("size[%d]+sizeof(uli->lai)[%d] > IE Length[%d]", ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 9|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 835| 9| size, (int)sizeof(uli->lai), octet->len); 836| 9| return 0; 837| 9| } 838| 35| memcpy(&uli->lai, 839| 35| (unsigned char *)octet->data + size, sizeof(uli->lai)); 840| 35| uli->lai.lac = be16toh(uli->lai.lac); 841| 35| size += sizeof(uli->lai); 842| 35| } 843| 69| if (uli->flags.enodeb_id) { ------------------ | Branch (843:9): [True: 35, False: 34] ------------------ 844| 35| if (size + sizeof(uli->enodeb_id) > octet->len) { ------------------ | Branch (844:13): [True: 9, False: 26] ------------------ 845| 9| ogs_error("size[%d]+sizeof(uli->enodeb_id)[%d] > IE Length[%d]", ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 9|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 846| 9| size, (int)sizeof(uli->enodeb_id), octet->len); 847| 9| return 0; 848| 9| } 849| 26| memcpy(&uli->enodeb_id, 850| 26| (unsigned char *)octet->data + size, sizeof(uli->enodeb_id)); 851| 26| uli->enodeb_id.enodeb_id = be16toh(uli->enodeb_id.enodeb_id); 852| 26| size += sizeof(uli->enodeb_id); 853| 26| } 854| 60| if (uli->flags.ext_enodeb_id) { /* TODO */ ------------------ | Branch (854:9): [True: 26, False: 34] ------------------ 855| 26| ogs_error("Extended Macro eNodeB ID in ULI not implemented! see 3GPP TS 29.274 8.21.8"); ------------------ | | 36| 26|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 26| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 26|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 26| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 26|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 26| 0, __VA_ARGS__) | | ------------------ ------------------ 856| 26| } 857| | 858| 60| if (size != octet->len) ------------------ | Branch (858:9): [True: 48, False: 12] ------------------ 859| 60| ogs_error("Mismatch IE Length[%d] != Decoded[%d]", octet->len, size); ------------------ | | 36| 48|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 48| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 56| 48|#define OGS_LOG_DOMAIN __ogs_gtp_domain | | | | ------------------ | | | | 44| 48| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 48|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 48| 0, __VA_ARGS__) | | ------------------ ------------------ 860| | 861| 60| return size; 862| 69|} ogs_fqdn_parse: 708| 83|{ 709| 83| int i = 0, j = 0; 710| 83| uint8_t len = 0; 711| | 712| 399| while (i+1 <= length) { ------------------ | Branch (712:12): [True: 339, False: 60] ------------------ 713| 339| len = src[i++]; 714| 339| if ((j + len + 1) > length) { ------------------ | Branch (714:13): [True: 23, False: 316] ------------------ 715| 23| ogs_error("Invalid FQDN encoding[j:%d+len:%d] + 1 > length[%d]", ------------------ | | 36| 23|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 23| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 23|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 23| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 23|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 23| 0, __VA_ARGS__) | | ------------------ ------------------ 716| 23| j, len, length); 717| 23| ogs_log_hexdump(OGS_LOG_ERROR, (unsigned char *)src, length); ------------------ | | 53| 23| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 32| 23|#define OGS_LOG_DOMAIN 1 | | ------------------ ------------------ 718| 23| return -EINVAL; 719| 23| } 720| 316| memcpy(&dst[j], &src[i], len); 721| | 722| 316| i += len; 723| 316| j += len; 724| | 725| 316| if (i+1 < length) ------------------ | Branch (725:13): [True: 261, False: 55] ------------------ 726| 261| dst[j++] = '.'; 727| 55| else 728| 55| dst[j] = 0; 729| 316| } 730| | 731| 60| return j; 732| 83|} 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: 144| 2.11k|{ /* open5gs/tests/non3gpp/gtp-path.c */ 145| | 146| 2.11k| if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 26| 4.23k|#define kMinInputLength 5 ------------------ if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 27| 2.11k|#define kMaxInputLength 1024 ------------------ | Branch (146:9): [True: 4, False: 2.11k] | Branch (146:35): [True: 22, False: 2.09k] ------------------ 147| 26| return -1; 148| 26| } 149| | 150| 2.09k| if (!initialized) { ------------------ | Branch (150:9): [True: 1, False: 2.08k] ------------------ 151| 1| initialize(); 152| 1| ogs_log_install_domain(&__ogs_gtp_domain, "gtp", OGS_LOG_NONE); 153| 1| ogs_log_install_domain(&__ogs_tlv_domain, "tlv", OGS_LOG_NONE); 154| 1| } 155| | 156| 2.09k| ogs_pkbuf_t *pkbuf; 157| 2.09k| pkbuf = ogs_pkbuf_alloc(NULL, OGS_MAX_SDU_LEN); ------------------ | | 87| 2.09k| ogs_pkbuf_alloc_debug(pool, size, OGS_FILE_LINE) | | ------------------ | | | | 213| 2.09k|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 167| 2.09k|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 168| 2.09k|#define OGS_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 158| | 159| 2.09k| if (pkbuf == NULL) { ------------------ | Branch (159:9): [True: 0, False: 2.09k] ------------------ 160| 0| return 0; 161| 0| } 162| 2.09k| ogs_pkbuf_put_data(pkbuf, Data, Size); 163| | 164| 2.09k| if (GTP_VERSION(Data[0]) == OGS_GTP1_VERSION_1) { ------------------ | | 28| 2.09k|#define GTP_VERSION(byte) (((byte) >> 5) & 0x07) ------------------ if (GTP_VERSION(Data[0]) == OGS_GTP1_VERSION_1) { ------------------ | | 48| 2.09k|#define OGS_GTP1_VERSION_1 1 ------------------ | Branch (164:9): [True: 1.24k, False: 850] ------------------ 165| | /* GTPv1 */ 166| 1.24k| ogs_gtp1_message_t gtp1_message; 167| 1.24k| if (ogs_gtp1_parse_msg(>p1_message, pkbuf) == OGS_OK) ------------------ | | 77| 1.24k|#define OGS_OK 0 ------------------ | Branch (167:13): [True: 955, False: 285] ------------------ 168| 955| parse_gtp1_ies(>p1_message); 169| 1.24k| } else { 170| | /* GTPv2 */ 171| 850| ogs_gtp2_message_t gtp2_message; 172| 850| if (ogs_gtp2_parse_msg(>p2_message, pkbuf) == OGS_OK) ------------------ | | 77| 850|#define OGS_OK 0 ------------------ | Branch (172:13): [True: 693, False: 157] ------------------ 173| 693| parse_gtp2_ies(>p2_message); 174| 850| } 175| | 176| 2.09k| ogs_pkbuf_free(pkbuf); 177| | 178| 2.09k| return 0; 179| 2.09k|} gtp-message-fuzz.c:parse_gtp1_ies: 31| 955|{ 32| 955| ogs_tlv_octet_t *location = NULL; 33| 955| ogs_tlv_octet_t *qos = NULL; 34| | 35| 955| switch (message->h.type) { 36| 207| case OGS_GTP1_CREATE_PDP_CONTEXT_REQUEST_TYPE: ------------------ | | 90| 207|#define OGS_GTP1_CREATE_PDP_CONTEXT_REQUEST_TYPE 16 ------------------ | Branch (36:5): [True: 207, False: 748] ------------------ 37| 207| location = &message->create_pdp_context_request. 38| 207| user_location_information; 39| 207| qos = &message->create_pdp_context_request.quality_of_service_profile; 40| 207| break; 41| 30| case OGS_GTP1_UPDATE_PDP_CONTEXT_REQUEST_TYPE: ------------------ | | 92| 30|#define OGS_GTP1_UPDATE_PDP_CONTEXT_REQUEST_TYPE 18 ------------------ | Branch (41:5): [True: 30, False: 925] ------------------ 42| 30| location = &message->update_pdp_context_request. 43| 30| user_location_information; 44| 30| qos = &message->update_pdp_context_request.quality_of_service_profile; 45| 30| break; 46| 671| case OGS_GTP1_SGSN_CONTEXT_RESPONSE_TYPE: { ------------------ | | 113| 671|#define OGS_GTP1_SGSN_CONTEXT_RESPONSE_TYPE 51 ------------------ | Branch (46:5): [True: 671, False: 284] ------------------ 47| 671| ogs_gtp1_sgsn_context_response_t *response = 48| 671| &message->sgsn_context_response; 49| 671| if (response->mm_context.presence && response->mm_context.len && ------------------ | Branch (49:13): [True: 285, False: 386] | Branch (49:46): [True: 284, False: 1] ------------------ 50| 284| response->mm_context.data) { ------------------ | Branch (50:17): [True: 284, False: 0] ------------------ 51| 284| ogs_gtp1_mm_context_decoded_t decoded; 52| 284| ogs_gtp1_parse_mm_context(&decoded, &response->mm_context); 53| 284| } 54| 671| if (response->pdp_context.presence && response->pdp_context.len && ------------------ | Branch (54:13): [True: 373, False: 298] | Branch (54:47): [True: 371, False: 2] ------------------ 55| 371| response->pdp_context.data) { ------------------ | Branch (55:17): [True: 371, False: 0] ------------------ 56| 371| ogs_gtp1_pdp_context_decoded_t decoded; 57| 371| ogs_gtp1_parse_pdp_context(&decoded, &response->pdp_context); 58| 371| } 59| 671| break; 60| 0| } 61| 47| default: ------------------ | Branch (61:5): [True: 47, False: 908] ------------------ 62| 47| break; 63| 955| } 64| | 65| 955| if (location && location->presence && location->len && location->data) { ------------------ | Branch (65:9): [True: 237, False: 718] | Branch (65:21): [True: 40, False: 197] | Branch (65:43): [True: 39, False: 1] | Branch (65:60): [True: 39, False: 0] ------------------ 66| 39| ogs_gtp1_uli_t decoded; 67| 39| ogs_gtp1_parse_uli(&decoded, location); 68| 39| } 69| 955| if (qos && qos->presence && qos->len && qos->data) { ------------------ | Branch (69:9): [True: 237, False: 718] | Branch (69:16): [True: 151, False: 86] | Branch (69:33): [True: 148, False: 3] | Branch (69:45): [True: 148, False: 0] ------------------ 70| 148| ogs_gtp1_qos_profile_decoded_t decoded; 71| 148| ogs_gtp1_parse_qos_profile(&decoded, qos); 72| 148| } 73| 955|} gtp-message-fuzz.c:parse_gtp2_ies: 92| 693|{ 93| 693| ogs_tlv_octet_t *location = NULL; 94| | 95| 693| switch (message->h.type) { 96| 261| case OGS_GTP2_CREATE_SESSION_REQUEST_TYPE: { ------------------ | | 86| 261|#define OGS_GTP2_CREATE_SESSION_REQUEST_TYPE 32 ------------------ | Branch (96:5): [True: 261, False: 432] ------------------ 97| 261| ogs_gtp2_create_session_request_t *request = 98| 261| &message->create_session_request; 99| 261| size_t index; 100| | 101| 261| location = &request->user_location_information; 102| 261| for (index = 0; 103| 2.34k| index < OGS_ARRAY_SIZE(request->bearer_contexts_to_be_created); ------------------ | | 165| 2.34k|#define OGS_ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) ------------------ | Branch (103:17): [True: 2.08k, False: 261] ------------------ 104| 2.08k| index++) 105| 2.08k| parse_bearer_ies(&request->bearer_contexts_to_be_created[index]); 106| 261| break; 107| 0| } 108| 41| case OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE: ------------------ | | 88| 41|#define OGS_GTP2_MODIFY_BEARER_REQUEST_TYPE 34 ------------------ | Branch (108:5): [True: 41, False: 652] ------------------ 109| 41| location = &message->modify_bearer_request.user_location_information; 110| 41| break; 111| 16| case OGS_GTP2_CREATE_BEARER_REQUEST_TYPE: ------------------ | | 106| 16|#define OGS_GTP2_CREATE_BEARER_REQUEST_TYPE 95 ------------------ | Branch (111:5): [True: 16, False: 677] ------------------ 112| 16| parse_bearer_ies(&message->create_bearer_request.bearer_contexts); 113| 16| break; 114| 302| case OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE: { ------------------ | | 100| 302|#define OGS_GTP2_BEARER_RESOURCE_COMMAND_TYPE 68 ------------------ | Branch (114:5): [True: 302, False: 391] ------------------ 115| 302| ogs_gtp2_bearer_resource_command_t *command = 116| 302| &message->bearer_resource_command; 117| | 118| 302| location = &command->user_location_information; 119| 302| if (command->flow_quality_of_service.presence && ------------------ | Branch (119:13): [True: 22, False: 280] ------------------ 120| 22| command->flow_quality_of_service.len && ------------------ | Branch (120:17): [True: 21, False: 1] ------------------ 121| 21| command->flow_quality_of_service.data) { ------------------ | Branch (121:17): [True: 21, False: 0] ------------------ 122| 21| ogs_gtp2_flow_qos_t decoded; 123| 21| ogs_gtp2_parse_flow_qos(&decoded, &command->flow_quality_of_service); 124| 21| } 125| 302| if (command->traffic_aggregate_description.presence && ------------------ | Branch (125:13): [True: 255, False: 47] ------------------ 126| 255| command->traffic_aggregate_description.len && ------------------ | Branch (126:17): [True: 254, False: 1] ------------------ 127| 254| command->traffic_aggregate_description.data) { ------------------ | Branch (127:17): [True: 254, False: 0] ------------------ 128| 254| ogs_gtp2_tft_t decoded; 129| 254| ogs_gtp2_parse_tft(&decoded, &command->traffic_aggregate_description); 130| 254| } 131| 302| break; 132| 0| } 133| 73| default: ------------------ | Branch (133:5): [True: 73, False: 620] ------------------ 134| 73| break; 135| 693| } 136| | 137| 693| if (location && location->presence && location->len && location->data) { ------------------ | Branch (137:9): [True: 604, False: 89] | Branch (137:21): [True: 113, False: 491] | Branch (137:43): [True: 110, False: 3] | Branch (137:60): [True: 110, False: 0] ------------------ 138| 110| ogs_gtp2_uli_t decoded; 139| 110| ogs_gtp2_parse_uli(&decoded, location); 140| 110| } 141| 693|} gtp-message-fuzz.c:parse_bearer_ies: 76| 2.10k|{ 77| 2.10k| if (!bearer->presence) ------------------ | Branch (77:9): [True: 1.53k, False: 573] ------------------ 78| 1.53k| return; 79| | 80| 573| if (bearer->bearer_level_qos.presence && bearer->bearer_level_qos.len && ------------------ | Branch (80:9): [True: 103, False: 470] | Branch (80:46): [True: 50, False: 53] ------------------ 81| 50| bearer->bearer_level_qos.data) { ------------------ | Branch (81:13): [True: 50, False: 0] ------------------ 82| 50| ogs_gtp2_bearer_qos_t decoded; 83| 50| ogs_gtp2_parse_bearer_qos(&decoded, &bearer->bearer_level_qos); 84| 50| } 85| 573| if (bearer->tft.presence && bearer->tft.len && bearer->tft.data) { ------------------ | Branch (85:9): [True: 448, False: 125] | Branch (85:33): [True: 414, False: 34] | Branch (85:52): [True: 414, False: 0] ------------------ 86| 414| ogs_gtp2_tft_t decoded; 87| 414| ogs_gtp2_parse_tft(&decoded, &bearer->tft); 88| 414| } 89| 573|}