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| 605|{ 66| 605| return &self; 67| 605|} ogs_hash_make: 70| 3|{ 71| 3| ogs_hash_t *ht; 72| 3| ogs_time_t now = ogs_get_monotonic_time(); 73| | 74| 3| ht = ogs_malloc(sizeof(ogs_hash_t)); ------------------ | | 68| 3| ogs_talloc_size(__ogs_talloc_core, size, __location__) ------------------ 75| 3| if (!ht) { ------------------ | Branch (75:9): [True: 0, False: 3] ------------------ 76| 0| ogs_error("ogs_malloc() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 77| 0| return NULL; 78| 0| } 79| | 80| 3| ht->free = NULL; 81| 3| ht->count = 0; 82| 3| ht->max = INITIAL_MAX; ------------------ | | 60| 3|#define INITIAL_MAX 15 /* tunable == 2^n - 1 */ ------------------ 83| 3| ht->seed = (unsigned int)((now >> 32) ^ now ^ 84| 3| (uintptr_t)ht ^ (uintptr_t)&now) - 1; 85| 3| ht->array = alloc_array(ht, ht->max); 86| 3| ht->hash_func = NULL; 87| | 88| 3| return ht; 89| 3|} ogs-hash.c:alloc_array: 63| 3|{ 64| 3| ogs_hash_entry_t **ptr = ogs_calloc(1, sizeof(*ht->array) * (max + 1)); ------------------ | | 70| 3| ogs_talloc_zero_size(__ogs_talloc_core, (nmemb) * (size), __location__) ------------------ 65| 3| ogs_assert(ptr); ------------------ | | 113| 3| do { \ | | 114| 3| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 115| 3| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 3| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3] | | ------------------ ------------------ 66| 3| return ptr; 67| 3|} ogs-log.c:ogs_list_first: 51| 270k|{ 52| 270k| return list->next; 53| 270k|} ogs-log.c:ogs_list_next: 61| 21|{ 62| 21| ogs_list_t *node = (ogs_list_t *)lnode; 63| 21| return node->next; 64| 21|} 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| 6|{ 223| 6| ogs_log_domain_t *domain = NULL; 224| | 225| 6| ogs_assert(name); ------------------ | | 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] | | ------------------ ------------------ 226| | 227| 6| ogs_list_for_each(&domain_list, domain) ------------------ | | 76| 27| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 21, False: 6] | | ------------------ | | 77| 21| node = ogs_list_next(node)) ------------------ 228| 21| if (!ogs_strcasecmp(domain->name, name)) ------------------ | | 63| 21|#define ogs_strcasecmp strcasecmp ------------------ | Branch (228:13): [True: 0, False: 21] ------------------ 229| 0| return domain; 230| | 231| 6| return NULL; 232| 6|} ogs_log_install_domain: 292| 6|{ 293| 6| ogs_log_domain_t *domain = NULL; 294| | 295| 6| ogs_assert(domain_id); ------------------ | | 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] | | ------------------ ------------------ 296| 6| ogs_assert(name); ------------------ | | 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] | | ------------------ ------------------ 297| | 298| 6| domain = ogs_log_find_domain(name); 299| 6| if (domain) { ------------------ | Branch (299:9): [True: 0, False: 6] ------------------ 300| 0| ogs_warn("`%s` log-domain duplicated", name); ------------------ | | 37| 0|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 301| 0| if (level != domain->level) { ------------------ | Branch (301:13): [True: 0, False: 0] ------------------ 302| 0| ogs_warn("[%s]->[%s] log-level changed", ------------------ | | 37| 0|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 32| 0|#define OGS_LOG_DOMAIN 1 | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 303| 0| level_strings[domain->level], level_strings[level]); 304| 0| ogs_log_set_domain_level(domain->id, level); 305| 0| } 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| 6| *domain_id = domain->id; 312| 6|} ogs_log_vprintf: 404| 270k|{ 405| 270k| ogs_log_t *log = NULL; 406| 270k| ogs_log_domain_t *domain = NULL; 407| | 408| 270k| char logstr[OGS_HUGE_LEN]; 409| 270k| char *p, *last; 410| | 411| 270k| int wrote_stderr = 0; 412| | 413| 270k| ogs_list_for_each(&log_list, log) { ------------------ | | 76| 270k| for (node = ogs_list_first(list); (node); \ | | ------------------ | | | Branch (76:39): [True: 270k, False: 0] | | ------------------ | | 77| 270k| node = ogs_list_next(node)) ------------------ 414| 270k| domain = ogs_pool_find(&domain_pool, id); ------------------ | | 154| 270k| (_index > 0 && _index <= (pool)->size) ? (pool)->index[_index-1] : NULL | | ------------------ | | | Branch (154:6): [True: 270k, False: 0] | | | Branch (154:20): [True: 270k, False: 0] | | ------------------ ------------------ 415| 270k| if (!domain) { ------------------ | Branch (415:13): [True: 0, False: 270k] ------------------ 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| 270k| if (domain->level < level) ------------------ | Branch (419:13): [True: 270k, False: 0] ------------------ 420| 270k| return; 421| | 422| 0| p = logstr; 423| 0| last = logstr + OGS_HUGE_LEN; ------------------ | | 210| 0|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 424| | 425| 0| if (!content_only) { ------------------ | Branch (425:13): [True: 0, False: 0] ------------------ 426| 0| if (log->print.timestamp) ------------------ | Branch (426:17): [True: 0, False: 0] ------------------ 427| 0| p = log_timestamp(p, last, log->print.color); 428| 0| if (log->print.domain) ------------------ | Branch (428:17): [True: 0, False: 0] ------------------ 429| 0| p = log_domain(p, last, domain->name, log->print.color); 430| 0| if (log->print.level) ------------------ | Branch (430:17): [True: 0, False: 0] ------------------ 431| 0| p = log_level(p, last, level, log->print.color); 432| 0| } 433| | 434| 0| p = log_content(p, last, format, ap); 435| | 436| 0| if (err) { ------------------ | Branch (436:13): [True: 0, False: 0] ------------------ 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| 0| if (!content_only) { ------------------ | Branch (442:13): [True: 0, False: 0] ------------------ 443| 0| if (log->print.fileline) ------------------ | Branch (443:17): [True: 0, False: 0] ------------------ 444| 0| p = ogs_slprintf(p, last, " (%s:%d)", file, line); 445| 0| if (log->print.function) ------------------ | Branch (445:17): [True: 0, False: 0] ------------------ 446| 0| p = ogs_slprintf(p, last, " %s()", func); 447| 0| if (log->print.linefeed) ------------------ | Branch (447:17): [True: 0, False: 0] ------------------ 448| 0| p = log_linefeed(p, last); 449| 0| } 450| | 451| 0| log->writer(log, level, logstr); 452| | 453| 0| if (log->type == OGS_LOG_STDERR_TYPE) ------------------ | Branch (453:13): [True: 0, False: 0] ------------------ 454| 0| wrote_stderr = 1; 455| 0| } 456| | 457| 0| if (!wrote_stderr) ------------------ | Branch (457:9): [True: 0, False: 0] ------------------ 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| 0|} ogs_log_printf: 486| 270k|{ 487| 270k| va_list args; 488| | 489| 270k| va_start(args, format); 490| 270k| ogs_log_vprintf(level, id, 491| 270k| err, file, line, func, content_only, format, args); 492| | va_end(args); 493| 270k|} ogs_log_hexdump_func: 497| 87.8k|{ 498| 87.8k| size_t n, m; 499| 87.8k| char dumpstr[OGS_HUGE_LEN]; 500| 87.8k| 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| 87.8k| if (!len) ------------------ | Branch (506:9): [True: 2.55k, False: 85.2k] ------------------ 507| 2.55k| return; 508| | 509| 85.2k| last = dumpstr + OGS_HUGE_LEN; ------------------ | | 210| 85.2k|#define OGS_HUGE_LEN 8192 /* Can Stack */ ------------------ 510| 85.2k| p = dumpstr; 511| | 512| 172k| for (n = 0; n < len; n += 16) { ------------------ | Branch (512:17): [True: 87.2k, False: 85.2k] ------------------ 513| 87.2k| p = ogs_slprintf(p, last, "%04x: ", (int)n); 514| | 515| 1.48M| for (m = n; m < n + 16; m++) { ------------------ | Branch (515:21): [True: 1.39M, False: 87.2k] ------------------ 516| 1.39M| if (m > n && (m % 4) == 0) ------------------ | Branch (516:17): [True: 1.30M, False: 87.2k] | Branch (516:26): [True: 261k, False: 1.04M] ------------------ 517| 261k| p = ogs_slprintf(p, last, " "); 518| 1.39M| if (m < len) ------------------ | Branch (518:17): [True: 135k, False: 1.26M] ------------------ 519| 135k| p = ogs_slprintf(p, last, "%02x", data[m]); 520| 1.26M| else 521| 1.26M| p = ogs_slprintf(p, last, " "); 522| 1.39M| } 523| | 524| 87.2k| p = ogs_slprintf(p, last, " "); 525| | 526| 222k| for (m = n; m < len && m < n + 16; m++) ------------------ | Branch (526:21): [True: 137k, False: 85.2k] | Branch (526:32): [True: 135k, False: 1.97k] ------------------ 527| 135k| p = ogs_slprintf(p, last, "%c", isprint(data[m]) ? data[m] : '.'); ------------------ | Branch (527:45): [True: 20.6k, False: 114k] ------------------ 528| | 529| 87.2k| p = ogs_slprintf(p, last, "\n"); 530| 87.2k| } 531| | 532| | ogs_log_print(level, "%s", dumpstr); ------------------ | | 48| 85.2k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | ------------------ | | | | 32| 85.2k|#define OGS_LOG_DOMAIN 1 | | ------------------ | | 49| 85.2k| 0, NULL, 0, NULL, \ | | 50| 85.2k| 1, __VA_ARGS__) ------------------ 533| 85.2k|} 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_mem_init: 34| 1|{ 35| 1| ogs_thread_mutex_init(&mutex); ------------------ | | 37| 1|#define ogs_thread_mutex_init(_n) (void)pthread_mutex_init((_n), NULL) ------------------ 36| | 37| 1| talloc_enable_null_tracking(); 38| | 39| 1|#define TALLOC_MEMSIZE 1 40| 1| __ogs_talloc_core = talloc_named_const(NULL, TALLOC_MEMSIZE, "core"); ------------------ | | 39| 1|#define TALLOC_MEMSIZE 1 ------------------ 41| 1|} ogs_talloc_size: 59| 3|{ 60| 3| void *ptr = NULL; 61| | 62| 3| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 3|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 63| | 64| 3| ptr = talloc_named_const(ctx, size, name); 65| 3| ogs_expect(ptr); ------------------ | | 128| 3| do { \ | | 129| 3| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3, False: 0] | | | | ------------------ | | ------------------ | | 130| 3| else { \ | | 131| 0| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 23| 0|#define OGS_LOG_DOMAIN __ogs_mem_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 0| } \ | | 133| 3| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 3] | | ------------------ ------------------ 66| | 67| 3| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 3|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 68| | 69| 3| return ptr; 70| 3|} ogs_talloc_zero_size: 73| 3.89k|{ 74| 3.89k| void *ptr = NULL; 75| | 76| 3.89k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 3.89k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 77| | 78| 3.89k| ptr = _talloc_zero(ctx, size, name); 79| 3.89k| ogs_expect(ptr); ------------------ | | 128| 3.89k| do { \ | | 129| 3.89k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.89k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.89k, False: 0] | | | | ------------------ | | ------------------ | | 130| 3.89k| else { \ | | 131| 0| ogs_error("%s: Expectation `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 23| 0|#define OGS_LOG_DOMAIN __ogs_mem_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 132| 0| } \ | | 133| 3.89k| } while (0) | | ------------------ | | | Branch (133:14): [Folded, False: 3.89k] | | ------------------ ------------------ 80| | 81| 3.89k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 3.89k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 82| | 83| 3.89k| return ptr; 84| 3.89k|} ogs_talloc_free: 102| 3.88k|{ 103| 3.88k| int ret; 104| | 105| 3.88k| ogs_thread_mutex_lock(&mutex); ------------------ | | 38| 3.88k|#define ogs_thread_mutex_lock (void)pthread_mutex_lock ------------------ 106| | 107| 3.88k| ret = _talloc_free(ptr, location); 108| | 109| 3.88k| ogs_thread_mutex_unlock(&mutex); ------------------ | | 39| 3.88k|#define ogs_thread_mutex_unlock (void)pthread_mutex_unlock ------------------ 110| | 111| 3.88k| return ret; 112| 3.88k|} ogs_pkbuf_put_data: 91| 3.88k|{ 92| 3.88k| void *tmp = ogs_pkbuf_put(pkbuf, len); 93| | 94| 3.88k| memcpy(tmp, data, len); 95| 3.88k| return tmp; 96| 3.88k|} 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| 3.88k|{ 223| 3.88k|#if OGS_USE_TALLOC == 1 224| 3.88k| ogs_pkbuf_t *pkbuf = NULL; 225| | 226| 3.88k| pkbuf = ogs_talloc_zero_size(pool, sizeof(*pkbuf) + size, file_line); 227| 3.88k| if (!pkbuf) { ------------------ | Branch (227:9): [True: 0, False: 3.88k] ------------------ 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| 3.88k| pkbuf->head = pkbuf->_data; 233| 3.88k| pkbuf->end = pkbuf->_data + size; 234| | 235| 3.88k| pkbuf->len = 0; 236| | 237| 3.88k| pkbuf->data = pkbuf->_data; 238| 3.88k| pkbuf->tail = pkbuf->_data; 239| | 240| 3.88k| pkbuf->file_line = file_line; /* For debug */ 241| | 242| 3.88k| 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| 3.88k|} ogs_pkbuf_free: 290| 3.88k|{ 291| 3.88k|#if OGS_USE_TALLOC == 1 292| 3.88k| ogs_talloc_free(pkbuf, OGS_FILE_LINE); ------------------ | | 213| 3.88k|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | ------------------ | | | | 167| 3.88k|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | ------------------ | | | | | | 168| 3.88k|#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| 3.88k|} decoder.c:ogs_pkbuf_pull: 165| 176k|{ 166| 176k| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 176k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 176k] | | ------------------ ------------------ 167| 176k| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 176k|} decoder.c:ogs_pkbuf_pull_inline: 159| 176k|{ 160| 176k| pkbuf->len -= len; 161| 176k| return pkbuf->data += len; 162| 176k|} decoder.c:ogs_pkbuf_push: 147| 37.6k|{ 148| 37.6k| if (ogs_unlikely(ogs_pkbuf_headroom(pkbuf) < (int)len)) ------------------ | | 55| 37.6k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 37.6k] | | ------------------ ------------------ 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| 37.6k| pkbuf->data -= len; 152| 37.6k| pkbuf->len += len; 153| | 154| 37.6k| return pkbuf->data; 155| 37.6k|} decoder.c:ogs_pkbuf_headroom: 104| 37.6k|{ 105| 37.6k| return pkbuf->data - pkbuf->head; 106| 37.6k|} ies.c:ogs_pkbuf_pull: 165| 88.4k|{ 166| 88.4k| return ogs_unlikely(len > pkbuf->len) ? ------------------ | | 55| 88.4k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 485, False: 87.9k] | | ------------------ ------------------ 167| 88.4k| NULL : ogs_pkbuf_pull_inline(pkbuf, len); 168| 88.4k|} ies.c:ogs_pkbuf_pull_inline: 159| 87.9k|{ 160| 87.9k| pkbuf->len -= len; 161| 87.9k| return pkbuf->data += len; 162| 87.9k|} ogs-pkbuf.c:ogs_pkbuf_put: 115| 3.88k|{ 116| 3.88k| void *tmp = pkbuf->tail; 117| | 118| 3.88k| if (ogs_unlikely(ogs_pkbuf_tailroom(pkbuf) < (int)len)) ------------------ | | 55| 3.88k|#define ogs_unlikely(x) __builtin_expect (!!(x), 0) | | ------------------ | | | Branch (55:25): [True: 0, False: 3.88k] | | ------------------ ------------------ 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| 3.88k| pkbuf->tail += len; 122| 3.88k| pkbuf->len += len; 123| | 124| 3.88k| return tmp; 125| 3.88k|} ogs-pkbuf.c:ogs_pkbuf_tailroom: 99| 3.88k|{ 100| 3.88k| return pkbuf->end - pkbuf->tail; 101| 3.88k|} 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| 2.05M|{ 64| 2.05M| 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| 2.05M| r = vsnprintf(str, size, format, ap); 78| 2.05M|#endif 79| 2.05M| str[size-1] = '\0'; 80| | 81| 2.05M| return r; 82| 2.05M|} ogs_vslprintf: 97| 2.05M|{ 98| 2.05M| int r = -1; 99| | 100| 2.05M| ogs_assert(last); ------------------ | | 113| 2.05M| do { \ | | 114| 2.05M| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.05M|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.05M, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.05M| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #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.05M| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.05M] | | ------------------ ------------------ 101| | 102| 2.05M| if (!str) ------------------ | Branch (102:9): [True: 0, False: 2.05M] ------------------ 103| 0| return NULL; 104| | 105| 2.05M| if (str < last) ------------------ | Branch (105:9): [True: 2.05M, False: 0] ------------------ 106| 2.05M| r = ogs_vsnprintf(str, last - str, format, ap); 107| | 108| 2.05M| return (str + r); 109| 2.05M|} ogs_slprintf: 112| 2.05M|{ 113| 2.05M| char *r; 114| 2.05M| va_list ap; 115| | 116| 2.05M| va_start(ap, format); 117| 2.05M| r = ogs_vslprintf(str, last, format, ap); 118| 2.05M| va_end(ap); 119| | 120| 2.05M| return r; 121| 2.05M|} ogs_get_monotonic_time: 241| 3|{ 242| 3|#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC) 243| 3| struct timespec ts; 244| 3| clock_gettime(CLOCK_MONOTONIC, &ts); 245| 3| return ogs_time_from_sec(ts.tv_sec) + ts.tv_nsec / 1000UL; ------------------ | | 97| 3|#define ogs_time_from_sec(sec) ((ogs_time_t)(sec) * OGS_USEC_PER_SEC) | | ------------------ | | | | 76| 3|#define OGS_USEC_PER_SEC (1000000LL) | | ------------------ ------------------ 246| |#elif defined(__APPLE__) 247| | static mach_timebase_info_data_t info = {0}; 248| | static double ratio = 0.0; 249| | 250| | if (!info.denom) { 251| | /* the value from mach_absolute_time () * info.numer / info.denom 252| | * is in nano seconds. So we have to divid by 1000.0 to get micro 253| | * seconds*/ 254| | mach_timebase_info(&info); 255| | ratio = (double) info.numer / (double) info.denom / 1000.0; 256| | } 257| | 258| | return mach_absolute_time() * ratio; 259| |#elif defined(_WIN32) 260| | /* Despite it's name, this is in milliseconds! */ 261| | ogs_time_t ticks = GetTickCount64(); 262| | return (ticks * 1000L); 263| |#elif defined(__hpux__) 264| | ogs_time_t nanosec = gethrtime(); 265| | return (nanosec / 1000UL); 266| |#else 267| |#warning "Monotonic clock is not yet supported on your platform." 268| | struct timeval tv; 269| | 270| | ogs_gettimeofday(&tv); 271| | return ogs_time_from_sec(tv.tv_sec) + tv.tv_usec; 272| |#endif 273| 3|} ogs_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_nas_eps_decode_attach_request: 87| 347|{ 88| 347| ogs_nas_eps_attach_request_t *attach_request = &message->emm.attach_request; 89| 347| int decoded = 0; 90| 347| int size = 0; 91| | 92| 347| ogs_trace("[NAS] Decode ATTACH_REQUEST\n"); ------------------ | | 40| 347|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 347| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 347|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 347| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 347|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 347| 0, __VA_ARGS__) | | ------------------ ------------------ 93| | 94| 347| size = ogs_nas_eps_decode_eps_attach_type(&attach_request->eps_attach_type, pkbuf); 95| 347| if (size < 0) { ------------------ | Branch (95:9): [True: 0, False: 347] ------------------ 96| 0| ogs_error("ogs_nas_eps_decode_eps_attach_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 97| 0| return size; 98| 0| } 99| | 100| 347| decoded += size; 101| | 102| 347| size = ogs_nas_eps_decode_eps_mobile_identity(&attach_request->eps_mobile_identity, pkbuf); 103| 347| if (size < 0) { ------------------ | Branch (103:9): [True: 3, False: 344] ------------------ 104| 3| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 105| 3| return size; 106| 3| } 107| | 108| 344| decoded += size; 109| | 110| 344| size = ogs_nas_eps_decode_ue_network_capability(&attach_request->ue_network_capability, pkbuf); 111| 344| if (size < 0) { ------------------ | Branch (111:9): [True: 11, False: 333] ------------------ 112| 11| ogs_error("ogs_nas_eps_decode_ue_network_capability() failed"); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 113| 11| return size; 114| 11| } 115| | 116| 333| decoded += size; 117| | 118| 333| size = ogs_nas_eps_decode_esm_message_container(&attach_request->esm_message_container, pkbuf); 119| 333| if (size < 0) { ------------------ | Branch (119:9): [True: 7, False: 326] ------------------ 120| 7| ogs_error("ogs_nas_eps_decode_esm_message_container() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 121| 7| return size; 122| 7| } 123| | 124| 326| decoded += size; 125| | 126| 16.8k| while (pkbuf->len > 0) { ------------------ | Branch (126:12): [True: 16.5k, False: 298] ------------------ 127| 16.5k| uint8_t *buffer = pkbuf->data; 128| 16.5k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (128:24): [True: 5.65k, False: 10.9k] ------------------ 129| | 130| 16.5k| size = sizeof(uint8_t); 131| 16.5k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (131:13): [True: 0, False: 16.5k] ------------------ 132| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 133| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 134| 0| } 135| 16.5k| decoded += size; 136| | 137| 16.5k| switch (type) { 138| 218| case OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE: ------------------ | | 156| 218|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE 0x19 ------------------ | Branch (138:9): [True: 218, False: 16.3k] ------------------ 139| 218| size = ogs_nas_eps_decode_p_tmsi_signature(&attach_request->old_p_tmsi_signature, pkbuf); 140| 218| if (size < 0) { ------------------ | Branch (140:17): [True: 1, False: 217] ------------------ 141| 1| ogs_error("ogs_nas_eps_decode_p_tmsi_signature() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 142| 1| return size; 143| 1| } 144| | 145| 217| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT; ------------------ | | 128| 217|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT ((uint64_t)1<<0) ------------------ 146| 217| decoded += size; 147| 217| break; 148| 211| case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_GUTI_TYPE: ------------------ | | 157| 211|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_GUTI_TYPE 0x50 ------------------ | Branch (148:9): [True: 211, False: 16.3k] ------------------ 149| 211| size = ogs_nas_eps_decode_eps_mobile_identity(&attach_request->additional_guti, pkbuf); 150| 211| if (size < 0) { ------------------ | Branch (150:17): [True: 1, False: 210] ------------------ 151| 1| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 152| 1| return size; 153| 1| } 154| | 155| 210| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_GUTI_PRESENT; ------------------ | | 129| 210|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_GUTI_PRESENT ((uint64_t)1<<1) ------------------ 156| 210| decoded += size; 157| 210| break; 158| 261| case OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE: ------------------ | | 158| 261|#define OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE 0x52 ------------------ | Branch (158:9): [True: 261, False: 16.3k] ------------------ 159| 261| size = ogs_nas_eps_decode_tracking_area_identity(&attach_request->last_visited_registered_tai, pkbuf); 160| 261| if (size < 0) { ------------------ | Branch (160:17): [True: 1, False: 260] ------------------ 161| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 162| 1| return size; 163| 1| } 164| | 165| 260| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT; ------------------ | | 130| 260|#define OGS_NAS_EPS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT ((uint64_t)1<<2) ------------------ 166| 260| decoded += size; 167| 260| break; 168| 246| case OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_TYPE: ------------------ | | 159| 246|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_TYPE 0x5C ------------------ | Branch (168:9): [True: 246, False: 16.3k] ------------------ 169| 246| size = ogs_nas_eps_decode_drx_parameter(&attach_request->drx_parameter, pkbuf); 170| 246| if (size < 0) { ------------------ | Branch (170:17): [True: 1, False: 245] ------------------ 171| 1| ogs_error("ogs_nas_eps_decode_drx_parameter() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 172| 1| return size; 173| 1| } 174| | 175| 245| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_PRESENT; ------------------ | | 131| 245|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_PRESENT ((uint64_t)1<<3) ------------------ 176| 245| decoded += size; 177| 245| break; 178| 224| case OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_TYPE: ------------------ | | 160| 224|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_TYPE 0x31 ------------------ | Branch (178:9): [True: 224, False: 16.3k] ------------------ 179| 224| size = ogs_nas_eps_decode_ms_network_capability(&attach_request->ms_network_capability, pkbuf); 180| 224| if (size < 0) { ------------------ | Branch (180:17): [True: 1, False: 223] ------------------ 181| 1| ogs_error("ogs_nas_eps_decode_ms_network_capability() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 182| 1| return size; 183| 1| } 184| | 185| 223| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_PRESENT; ------------------ | | 132| 223|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<4) ------------------ 186| 223| decoded += size; 187| 223| break; 188| 205| case OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 161| 205|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (188:9): [True: 205, False: 16.3k] ------------------ 189| 205| size = ogs_nas_eps_decode_location_area_identification(&attach_request->old_location_area_identification, pkbuf); 190| 205| if (size < 0) { ------------------ | Branch (190:17): [True: 1, False: 204] ------------------ 191| 1| ogs_error("ogs_nas_eps_decode_location_area_identification() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 192| 1| return size; 193| 1| } 194| | 195| 204| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 133| 204|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<5) ------------------ 196| 204| decoded += size; 197| 204| break; 198| 804| case OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_TYPE: ------------------ | | 162| 804|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_TYPE 0x90 ------------------ | Branch (198:9): [True: 804, False: 15.7k] ------------------ 199| 804| decoded--; 200| 804| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 804| do { \ | | 114| 804| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 804|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 804, False: 0] | | | | ------------------ | | ------------------ | | 115| 804| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 804| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 804] | | ------------------ ------------------ 201| 804| size = ogs_nas_eps_decode_tmsi_status(&attach_request->tmsi_status, pkbuf); 202| 804| if (size < 0) { ------------------ | Branch (202:17): [True: 0, False: 804] ------------------ 203| 0| ogs_error("ogs_nas_eps_decode_tmsi_status() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 204| 0| return size; 205| 0| } 206| | 207| 804| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_PRESENT; ------------------ | | 134| 804|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_STATUS_PRESENT ((uint64_t)1<<6) ------------------ 208| 804| decoded += size; 209| 804| break; 210| 199| case OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE: ------------------ | | 163| 199|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE 0x11 ------------------ | Branch (210:9): [True: 199, False: 16.3k] ------------------ 211| 199| size = ogs_nas_eps_decode_mobile_station_classmark_2(&attach_request->mobile_station_classmark_2, pkbuf); 212| 199| if (size < 0) { ------------------ | Branch (212:17): [True: 1, False: 198] ------------------ 213| 1| ogs_error("ogs_nas_eps_decode_mobile_station_classmark_2() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 214| 1| return size; 215| 1| } 216| | 217| 198| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT; ------------------ | | 135| 198|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT ((uint64_t)1<<7) ------------------ 218| 198| decoded += size; 219| 198| break; 220| 229| case OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE: ------------------ | | 164| 229|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE 0x20 ------------------ | Branch (220:9): [True: 229, False: 16.3k] ------------------ 221| 229| size = ogs_nas_eps_decode_mobile_station_classmark_3(&attach_request->mobile_station_classmark_3, pkbuf); 222| 229| if (size < 0) { ------------------ | Branch (222:17): [True: 1, False: 228] ------------------ 223| 1| ogs_error("ogs_nas_eps_decode_mobile_station_classmark_3() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 224| 1| return size; 225| 1| } 226| | 227| 228| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT; ------------------ | | 136| 228|#define OGS_NAS_EPS_ATTACH_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT ((uint64_t)1<<8) ------------------ 228| 228| decoded += size; 229| 228| break; 230| 210| case OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_TYPE: ------------------ | | 165| 210|#define OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_TYPE 0x40 ------------------ | Branch (230:9): [True: 210, False: 16.3k] ------------------ 231| 210| size = ogs_nas_eps_decode_supported_codec_list(&attach_request->supported_codecs, pkbuf); 232| 210| if (size < 0) { ------------------ | Branch (232:17): [True: 2, False: 208] ------------------ 233| 2| ogs_error("ogs_nas_eps_decode_supported_codec_list() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 234| 2| return size; 235| 2| } 236| | 237| 208| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_PRESENT; ------------------ | | 137| 208|#define OGS_NAS_EPS_ATTACH_REQUEST_SUPPORTED_CODECS_PRESENT ((uint64_t)1<<9) ------------------ 238| 208| decoded += size; 239| 208| break; 240| 2.43k| case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE: ------------------ | | 166| 2.43k|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE 0xF0 ------------------ | Branch (240:9): [True: 2.43k, False: 14.1k] ------------------ 241| 2.43k| decoded--; 242| 2.43k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 2.43k| do { \ | | 114| 2.43k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.43k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.43k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.43k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 2.43k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.43k] | | ------------------ ------------------ 243| 2.43k| size = ogs_nas_eps_decode_additional_update_type(&attach_request->additional_update_type, pkbuf); 244| 2.43k| if (size < 0) { ------------------ | Branch (244:17): [True: 0, False: 2.43k] ------------------ 245| 0| ogs_error("ogs_nas_eps_decode_additional_update_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 246| 0| return size; 247| 0| } 248| | 249| 2.43k| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT; ------------------ | | 138| 2.43k|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT ((uint64_t)1<<10) ------------------ 250| 2.43k| decoded += size; 251| 2.43k| break; 252| 204| case OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE: ------------------ | | 167| 204|#define OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE 0x5D ------------------ | Branch (252:9): [True: 204, False: 16.3k] ------------------ 253| 204| size = ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting(&attach_request->voice_domain_preference_and_ue_usage_setting, pkbuf); 254| 204| if (size < 0) { ------------------ | Branch (254:17): [True: 2, False: 202] ------------------ 255| 2| ogs_error("ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 256| 2| return size; 257| 2| } 258| | 259| 202| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT; ------------------ | | 139| 202|#define OGS_NAS_EPS_ATTACH_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT ((uint64_t)1<<11) ------------------ 260| 202| decoded += size; 261| 202| break; 262| 333| case OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_TYPE: ------------------ | | 168| 333|#define OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 ------------------ | Branch (262:9): [True: 333, False: 16.2k] ------------------ 263| 333| decoded--; 264| 333| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 333| do { \ | | 114| 333| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 333|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 333, False: 0] | | | | ------------------ | | ------------------ | | 115| 333| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 333| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 333] | | ------------------ ------------------ 265| 333| size = ogs_nas_eps_decode_device_properties(&attach_request->device_properties, pkbuf); 266| 333| if (size < 0) { ------------------ | Branch (266:17): [True: 0, False: 333] ------------------ 267| 0| ogs_error("ogs_nas_eps_decode_device_properties() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 268| 0| return size; 269| 0| } 270| | 271| 333| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_PRESENT; ------------------ | | 140| 333|#define OGS_NAS_EPS_ATTACH_REQUEST_DEVICE_PROPERTIES_PRESENT ((uint64_t)1<<12) ------------------ 272| 333| decoded += size; 273| 333| break; 274| 1.14k| case OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_TYPE: ------------------ | | 169| 1.14k|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_TYPE 0xE0 ------------------ | Branch (274:9): [True: 1.14k, False: 15.4k] ------------------ 275| 1.14k| decoded--; 276| 1.14k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.14k| do { \ | | 114| 1.14k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.14k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.14k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.14k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.14k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.14k] | | ------------------ ------------------ 277| 1.14k| size = ogs_nas_eps_decode_guti_type(&attach_request->old_guti_type, pkbuf); 278| 1.14k| if (size < 0) { ------------------ | Branch (278:17): [True: 0, False: 1.14k] ------------------ 279| 0| ogs_error("ogs_nas_eps_decode_guti_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 280| 0| return size; 281| 0| } 282| | 283| 1.14k| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_PRESENT; ------------------ | | 141| 1.14k|#define OGS_NAS_EPS_ATTACH_REQUEST_OLD_GUTI_TYPE_PRESENT ((uint64_t)1<<13) ------------------ 284| 1.14k| decoded += size; 285| 1.14k| break; 286| 389| case OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 170| 389|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE 0xC0 ------------------ | Branch (286:9): [True: 389, False: 16.1k] ------------------ 287| 389| decoded--; 288| 389| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 389| do { \ | | 114| 389| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 389|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 389, False: 0] | | | | ------------------ | | ------------------ | | 115| 389| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 389| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 389] | | ------------------ ------------------ 289| 389| size = ogs_nas_eps_decode_ms_network_feature_support(&attach_request->ms_network_feature_support, pkbuf); 290| 389| if (size < 0) { ------------------ | Branch (290:17): [True: 0, False: 389] ------------------ 291| 0| ogs_error("ogs_nas_eps_decode_ms_network_feature_support() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 292| 0| return size; 293| 0| } 294| | 295| 389| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 142| 389|#define OGS_NAS_EPS_ATTACH_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<14) ------------------ 296| 389| decoded += size; 297| 389| break; 298| 225| case OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE: ------------------ | | 171| 225|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE 0x10 ------------------ | Branch (298:9): [True: 225, False: 16.3k] ------------------ 299| 225| size = ogs_nas_eps_decode_network_resource_identifier_container(&attach_request->tmsi_based_nri_container, pkbuf); 300| 225| if (size < 0) { ------------------ | Branch (300:17): [True: 1, False: 224] ------------------ 301| 1| ogs_error("ogs_nas_eps_decode_network_resource_identifier_container() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 302| 1| return size; 303| 1| } 304| | 305| 224| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT; ------------------ | | 143| 224|#define OGS_NAS_EPS_ATTACH_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT ((uint64_t)1<<15) ------------------ 306| 224| decoded += size; 307| 224| break; 308| 204| case OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_TYPE: ------------------ | | 172| 204|#define OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_TYPE 0x6A ------------------ | Branch (308:9): [True: 204, False: 16.3k] ------------------ 309| 204| size = ogs_nas_eps_decode_gprs_timer_2(&attach_request->t3324_value, pkbuf); 310| 204| if (size < 0) { ------------------ | Branch (310:17): [True: 1, False: 203] ------------------ 311| 1| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 312| 1| return size; 313| 1| } 314| | 315| 203| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_PRESENT; ------------------ | | 144| 203|#define OGS_NAS_EPS_ATTACH_REQUEST_T3324_VALUE_PRESENT ((uint64_t)1<<16) ------------------ 316| 203| decoded += size; 317| 203| break; 318| 201| case OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 173| 201|#define OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (318:9): [True: 201, False: 16.3k] ------------------ 319| 201| size = ogs_nas_eps_decode_gprs_timer_3(&attach_request->t3412_extended_value, pkbuf); 320| 201| if (size < 0) { ------------------ | Branch (320:17): [True: 2, False: 199] ------------------ 321| 2| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 322| 2| return size; 323| 2| } 324| | 325| 199| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 145| 199|#define OGS_NAS_EPS_ATTACH_REQUEST_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<17) ------------------ 326| 199| decoded += size; 327| 199| break; 328| 202| case OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 174| 202|#define OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (328:9): [True: 202, False: 16.3k] ------------------ 329| 202| size = ogs_nas_eps_decode_extended_drx_parameters(&attach_request->extended_drx_parameters, pkbuf); 330| 202| if (size < 0) { ------------------ | Branch (330:17): [True: 1, False: 201] ------------------ 331| 1| ogs_error("ogs_nas_eps_decode_extended_drx_parameters() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 332| 1| return size; 333| 1| } 334| | 335| 201| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 146| 201|#define OGS_NAS_EPS_ATTACH_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<18) ------------------ 336| 201| decoded += size; 337| 201| break; 338| 225| case OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE: ------------------ | | 175| 225|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE 0x6F ------------------ | Branch (338:9): [True: 225, False: 16.3k] ------------------ 339| 225| size = ogs_nas_eps_decode_ue_additional_security_capability(&attach_request->ue_additional_security_capability, pkbuf); 340| 225| if (size < 0) { ------------------ | Branch (340:17): [True: 1, False: 224] ------------------ 341| 1| ogs_error("ogs_nas_eps_decode_ue_additional_security_capability() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 342| 1| return size; 343| 1| } 344| | 345| 224| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT; ------------------ | | 147| 224|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT ((uint64_t)1<<19) ------------------ 346| 224| decoded += size; 347| 224| break; 348| 236| case OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_TYPE: ------------------ | | 176| 236|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_TYPE 0x6D ------------------ | Branch (348:9): [True: 236, False: 16.3k] ------------------ 349| 236| size = ogs_nas_eps_decode_ue_status(&attach_request->ue_status, pkbuf); 350| 236| if (size < 0) { ------------------ | Branch (350:17): [True: 1, False: 235] ------------------ 351| 1| ogs_error("ogs_nas_eps_decode_ue_status() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 352| 1| return size; 353| 1| } 354| | 355| 235| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_PRESENT; ------------------ | | 148| 235|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_STATUS_PRESENT ((uint64_t)1<<20) ------------------ 356| 235| decoded += size; 357| 235| break; 358| 269| case OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE: ------------------ | | 177| 269|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE 0x17 ------------------ | Branch (358:9): [True: 269, False: 16.3k] ------------------ 359| 269| size = ogs_nas_eps_decode_additional_information_requested(&attach_request->additional_information_requested, pkbuf); 360| 269| if (size < 0) { ------------------ | Branch (360:17): [True: 2, False: 267] ------------------ 361| 2| ogs_error("ogs_nas_eps_decode_additional_information_requested() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 362| 2| return size; 363| 2| } 364| | 365| 267| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT; ------------------ | | 149| 267|#define OGS_NAS_EPS_ATTACH_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT ((uint64_t)1<<21) ------------------ 366| 267| decoded += size; 367| 267| break; 368| 216| case OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_TYPE: ------------------ | | 178| 216|#define OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_TYPE 0x32 ------------------ | Branch (368:9): [True: 216, False: 16.3k] ------------------ 369| 216| size = ogs_nas_eps_decode_n1_ue_network_capability(&attach_request->n1_ue_network_capability, pkbuf); 370| 216| if (size < 0) { ------------------ | Branch (370:17): [True: 1, False: 215] ------------------ 371| 1| ogs_error("ogs_nas_eps_decode_n1_ue_network_capability() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 372| 1| return size; 373| 1| } 374| | 375| 215| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT; ------------------ | | 150| 215|#define OGS_NAS_EPS_ATTACH_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<22) ------------------ 376| 215| decoded += size; 377| 215| break; 378| 244| case OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE: ------------------ | | 179| 244|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE 0x34 ------------------ | Branch (378:9): [True: 244, False: 16.3k] ------------------ 379| 244| size = ogs_nas_eps_decode_ue_radio_capability_id_availability(&attach_request->ue_radio_capability_id_availability, pkbuf); 380| 244| if (size < 0) { ------------------ | Branch (380:17): [True: 2, False: 242] ------------------ 381| 2| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_availability() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 382| 2| return size; 383| 2| } 384| | 385| 242| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT; ------------------ | | 151| 242|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT ((uint64_t)1<<23) ------------------ 386| 242| decoded += size; 387| 242| break; 388| 268| case OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 180| 268|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (388:9): [True: 268, False: 16.3k] ------------------ 389| 268| size = ogs_nas_eps_decode_wus_assistance_information(&attach_request->requested_wus_assistance_information, pkbuf); 390| 268| if (size < 0) { ------------------ | Branch (390:17): [True: 1, False: 267] ------------------ 391| 1| ogs_error("ogs_nas_eps_decode_wus_assistance_information() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 392| 1| return size; 393| 1| } 394| | 395| 267| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 152| 267|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<24) ------------------ 396| 267| decoded += size; 397| 267| break; 398| 197| case OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_TYPE: ------------------ | | 181| 197|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_TYPE 0x36 ------------------ | Branch (398:9): [True: 197, False: 16.3k] ------------------ 399| 197| size = ogs_nas_eps_decode_nb_s1_drx_parameter(&attach_request->drx_parameter_in_nb_s1_mode, pkbuf); 400| 197| if (size < 0) { ------------------ | Branch (400:17): [True: 1, False: 196] ------------------ 401| 1| ogs_error("ogs_nas_eps_decode_nb_s1_drx_parameter() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 402| 1| return size; 403| 1| } 404| | 405| 196| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 153| 196|#define OGS_NAS_EPS_ATTACH_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<25) ------------------ 406| 196| decoded += size; 407| 196| break; 408| 203| case OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_TYPE: ------------------ | | 182| 203|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (408:9): [True: 203, False: 16.3k] ------------------ 409| 203| size = ogs_nas_eps_decode_imsi_offset(&attach_request->requested_imsi_offset, pkbuf); 410| 203| if (size < 0) { ------------------ | Branch (410:17): [True: 1, False: 202] ------------------ 411| 1| ogs_error("ogs_nas_eps_decode_imsi_offset() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 412| 1| return size; 413| 1| } 414| | 415| 202| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT; ------------------ | | 154| 202|#define OGS_NAS_EPS_ATTACH_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT ((uint64_t)1<<26) ------------------ 416| 202| decoded += size; 417| 202| break; 418| 204| case OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE: ------------------ | | 183| 204|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE 0x26 ------------------ | Branch (418:9): [True: 204, False: 16.3k] ------------------ 419| 204| size = ogs_nas_eps_decode_plmn_identity(&attach_request->ue_determined_plmn_with_disaster_condition, pkbuf); 420| 204| if (size < 0) { ------------------ | Branch (420:17): [True: 1, False: 203] ------------------ 421| 1| ogs_error("ogs_nas_eps_decode_plmn_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 422| 1| return size; 423| 1| } 424| | 425| 203| attach_request->presencemask |= OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT; ------------------ | | 155| 203|#define OGS_NAS_EPS_ATTACH_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT ((uint64_t)1<<27) ------------------ 426| 203| decoded += size; 427| 203| break; 428| 6.36k| default: ------------------ | Branch (428:9): [True: 6.36k, False: 10.2k] ------------------ 429| 6.36k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 6.36k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.36k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6.36k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6.36k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.36k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.36k| 0, __VA_ARGS__) | | ------------------ ------------------ 430| 6.36k| break; 431| 16.5k| } 432| 16.5k| } 433| | 434| 298| return decoded; 435| 326|} ogs_nas_eps_decode_attach_accept: 438| 436|{ 439| 436| ogs_nas_eps_attach_accept_t *attach_accept = &message->emm.attach_accept; 440| 436| int decoded = 0; 441| 436| int size = 0; 442| | 443| 436| ogs_trace("[NAS] Decode ATTACH_ACCEPT\n"); ------------------ | | 40| 436|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 436| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 436|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 436| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 436|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 436| 0, __VA_ARGS__) | | ------------------ ------------------ 444| | 445| 436| size = ogs_nas_eps_decode_eps_attach_result(&attach_accept->eps_attach_result, pkbuf); 446| 436| if (size < 0) { ------------------ | Branch (446:9): [True: 0, False: 436] ------------------ 447| 0| ogs_error("ogs_nas_eps_decode_eps_attach_result() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 448| 0| return size; 449| 0| } 450| | 451| 436| decoded += size; 452| | 453| 436| size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3412_value, pkbuf); 454| 436| if (size < 0) { ------------------ | Branch (454:9): [True: 0, False: 436] ------------------ 455| 0| ogs_error("ogs_nas_eps_decode_gprs_timer() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 456| 0| return size; 457| 0| } 458| | 459| 436| decoded += size; 460| | 461| 436| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->tai_list, pkbuf); 462| 436| if (size < 0) { ------------------ | Branch (462:9): [True: 4, False: 432] ------------------ 463| 4| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 464| 4| return size; 465| 4| } 466| | 467| 432| decoded += size; 468| | 469| 432| size = ogs_nas_eps_decode_esm_message_container(&attach_accept->esm_message_container, pkbuf); 470| 432| if (size < 0) { ------------------ | Branch (470:9): [True: 8, False: 424] ------------------ 471| 8| ogs_error("ogs_nas_eps_decode_esm_message_container() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 472| 8| return size; 473| 8| } 474| | 475| 424| decoded += size; 476| | 477| 18.6k| while (pkbuf->len > 0) { ------------------ | Branch (477:12): [True: 18.2k, False: 390] ------------------ 478| 18.2k| uint8_t *buffer = pkbuf->data; 479| 18.2k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (479:24): [True: 5.63k, False: 12.6k] ------------------ 480| | 481| 18.2k| size = sizeof(uint8_t); 482| 18.2k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (482:13): [True: 0, False: 18.2k] ------------------ 483| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 484| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 485| 0| } 486| 18.2k| decoded += size; 487| | 488| 18.2k| switch (type) { 489| 224| case OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_TYPE: ------------------ | | 262| 224|#define OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_TYPE 0x50 ------------------ | Branch (489:9): [True: 224, False: 18.0k] ------------------ 490| 224| size = ogs_nas_eps_decode_eps_mobile_identity(&attach_accept->guti, pkbuf); 491| 224| if (size < 0) { ------------------ | Branch (491:17): [True: 1, False: 223] ------------------ 492| 1| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 493| 1| return size; 494| 1| } 495| | 496| 223| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_PRESENT; ------------------ | | 228| 223|#define OGS_NAS_EPS_ATTACH_ACCEPT_GUTI_PRESENT ((uint64_t)1<<0) ------------------ 497| 223| decoded += size; 498| 223| break; 499| 310| case OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 263| 310|#define OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (499:9): [True: 310, False: 17.9k] ------------------ 500| 310| size = ogs_nas_eps_decode_location_area_identification(&attach_accept->location_area_identification, pkbuf); 501| 310| if (size < 0) { ------------------ | Branch (501:17): [True: 1, False: 309] ------------------ 502| 1| ogs_error("ogs_nas_eps_decode_location_area_identification() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 503| 1| return size; 504| 1| } 505| | 506| 309| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 229| 309|#define OGS_NAS_EPS_ATTACH_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<1) ------------------ 507| 309| decoded += size; 508| 309| break; 509| 221| case OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_TYPE: ------------------ | | 264| 221|#define OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_TYPE 0x23 ------------------ | Branch (509:9): [True: 221, False: 18.0k] ------------------ 510| 221| size = ogs_nas_eps_decode_mobile_identity(&attach_accept->ms_identity, pkbuf); 511| 221| if (size < 0) { ------------------ | Branch (511:17): [True: 1, False: 220] ------------------ 512| 1| ogs_error("ogs_nas_eps_decode_mobile_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 513| 1| return size; 514| 1| } 515| | 516| 220| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_PRESENT; ------------------ | | 230| 220|#define OGS_NAS_EPS_ATTACH_ACCEPT_MS_IDENTITY_PRESENT ((uint64_t)1<<2) ------------------ 517| 220| decoded += size; 518| 220| break; 519| 249| case OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_TYPE: ------------------ | | 265| 249|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_TYPE 0x53 ------------------ | Branch (519:9): [True: 249, False: 18.0k] ------------------ 520| 249| size = ogs_nas_eps_decode_emm_cause(&attach_accept->emm_cause, pkbuf); 521| 249| if (size < 0) { ------------------ | Branch (521:17): [True: 1, False: 248] ------------------ 522| 1| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 523| 1| return size; 524| 1| } 525| | 526| 248| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_PRESENT; ------------------ | | 231| 248|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMM_CAUSE_PRESENT ((uint64_t)1<<3) ------------------ 527| 248| decoded += size; 528| 248| break; 529| 262| case OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_TYPE: ------------------ | | 266| 262|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_TYPE 0x17 ------------------ | Branch (529:9): [True: 262, False: 17.9k] ------------------ 530| 262| size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3402_value, pkbuf); 531| 262| if (size < 0) { ------------------ | Branch (531:17): [True: 1, False: 261] ------------------ 532| 1| ogs_error("ogs_nas_eps_decode_gprs_timer() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 533| 1| return size; 534| 1| } 535| | 536| 261| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_PRESENT; ------------------ | | 232| 261|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3402_VALUE_PRESENT ((uint64_t)1<<4) ------------------ 537| 261| decoded += size; 538| 261| break; 539| 411| case OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_TYPE: ------------------ | | 267| 411|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_TYPE 0x59 ------------------ | Branch (539:9): [True: 411, False: 17.8k] ------------------ 540| 411| size = ogs_nas_eps_decode_gprs_timer(&attach_accept->t3423_value, pkbuf); 541| 411| if (size < 0) { ------------------ | Branch (541:17): [True: 1, False: 410] ------------------ 542| 1| ogs_error("ogs_nas_eps_decode_gprs_timer() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 543| 1| return size; 544| 1| } 545| | 546| 410| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_PRESENT; ------------------ | | 233| 410|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3423_VALUE_PRESENT ((uint64_t)1<<5) ------------------ 547| 410| decoded += size; 548| 410| break; 549| 207| case OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_TYPE: ------------------ | | 268| 207|#define OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_TYPE 0x4A ------------------ | Branch (549:9): [True: 207, False: 18.0k] ------------------ 550| 207| size = ogs_nas_eps_decode_plmn_list(&attach_accept->equivalent_plmns, pkbuf); 551| 207| if (size < 0) { ------------------ | Branch (551:17): [True: 2, False: 205] ------------------ 552| 2| ogs_error("ogs_nas_eps_decode_plmn_list() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 553| 2| return size; 554| 2| } 555| | 556| 205| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_PRESENT; ------------------ | | 234| 205|#define OGS_NAS_EPS_ATTACH_ACCEPT_EQUIVALENT_PLMNS_PRESENT ((uint64_t)1<<6) ------------------ 557| 205| decoded += size; 558| 205| break; 559| 240| case OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 269| 240|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE 0x34 ------------------ | Branch (559:9): [True: 240, False: 18.0k] ------------------ 560| 240| size = ogs_nas_eps_decode_emergency_number_list(&attach_accept->emergency_number_list, pkbuf); 561| 240| if (size < 0) { ------------------ | Branch (561:17): [True: 1, False: 239] ------------------ 562| 1| ogs_error("ogs_nas_eps_decode_emergency_number_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 563| 1| return size; 564| 1| } 565| | 566| 239| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 235| 239|#define OGS_NAS_EPS_ATTACH_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<7) ------------------ 567| 239| decoded += size; 568| 239| break; 569| 201| case OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 270| 201|#define OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE 0x64 ------------------ | Branch (569:9): [True: 201, False: 18.0k] ------------------ 570| 201| size = ogs_nas_eps_decode_eps_network_feature_support(&attach_accept->eps_network_feature_support, pkbuf); 571| 201| if (size < 0) { ------------------ | Branch (571:17): [True: 1, False: 200] ------------------ 572| 1| ogs_error("ogs_nas_eps_decode_eps_network_feature_support() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 573| 1| return size; 574| 1| } 575| | 576| 200| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 236| 200|#define OGS_NAS_EPS_ATTACH_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<8) ------------------ 577| 200| decoded += size; 578| 200| break; 579| 2.24k| case OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE: ------------------ | | 271| 2.24k|#define OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE 0xF0 ------------------ | Branch (579:9): [True: 2.24k, False: 16.0k] ------------------ 580| 2.24k| decoded--; 581| 2.24k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 2.24k| do { \ | | 114| 2.24k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.24k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.24k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.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, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 2.24k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.24k] | | ------------------ ------------------ 582| 2.24k| size = ogs_nas_eps_decode_additional_update_result(&attach_accept->additional_update_result, pkbuf); 583| 2.24k| if (size < 0) { ------------------ | Branch (583:17): [True: 0, False: 2.24k] ------------------ 584| 0| ogs_error("ogs_nas_eps_decode_additional_update_result() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 585| 0| return size; 586| 0| } 587| | 588| 2.24k| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT; ------------------ | | 237| 2.24k|#define OGS_NAS_EPS_ATTACH_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT ((uint64_t)1<<9) ------------------ 589| 2.24k| decoded += size; 590| 2.24k| break; 591| 243| case OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 272| 243|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (591:9): [True: 243, False: 18.0k] ------------------ 592| 243| size = ogs_nas_eps_decode_gprs_timer_3(&attach_accept->t3412_extended_value, pkbuf); 593| 243| if (size < 0) { ------------------ | Branch (593:17): [True: 2, False: 241] ------------------ 594| 2| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 595| 2| return size; 596| 2| } 597| | 598| 241| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 238| 241|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<10) ------------------ 599| 241| decoded += size; 600| 241| break; 601| 198| case OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_TYPE: ------------------ | | 273| 198|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_TYPE 0x6A ------------------ | Branch (601:9): [True: 198, False: 18.0k] ------------------ 602| 198| size = ogs_nas_eps_decode_gprs_timer_2(&attach_accept->t3324_value, pkbuf); 603| 198| if (size < 0) { ------------------ | Branch (603:17): [True: 1, False: 197] ------------------ 604| 1| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 605| 1| return size; 606| 1| } 607| | 608| 197| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_PRESENT; ------------------ | | 239| 197|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3324_VALUE_PRESENT ((uint64_t)1<<11) ------------------ 609| 197| decoded += size; 610| 197| break; 611| 199| case OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 274| 199|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (611:9): [True: 199, False: 18.0k] ------------------ 612| 199| size = ogs_nas_eps_decode_extended_drx_parameters(&attach_accept->extended_drx_parameters, pkbuf); 613| 199| if (size < 0) { ------------------ | Branch (613:17): [True: 1, False: 198] ------------------ 614| 1| ogs_error("ogs_nas_eps_decode_extended_drx_parameters() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 615| 1| return size; 616| 1| } 617| | 618| 198| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 240| 198|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<12) ------------------ 619| 198| decoded += size; 620| 198| break; 621| 249| case OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_TYPE: ------------------ | | 275| 249|#define OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_TYPE 0x65 ------------------ | Branch (621:9): [True: 249, False: 18.0k] ------------------ 622| 249| size = ogs_nas_eps_decode_dcn_id(&attach_accept->dcn_id, pkbuf); 623| 249| if (size < 0) { ------------------ | Branch (623:17): [True: 1, False: 248] ------------------ 624| 1| ogs_error("ogs_nas_eps_decode_dcn_id() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 625| 1| return size; 626| 1| } 627| | 628| 248| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_PRESENT; ------------------ | | 241| 248|#define OGS_NAS_EPS_ATTACH_ACCEPT_DCN_ID_PRESENT ((uint64_t)1<<13) ------------------ 629| 248| decoded += size; 630| 248| break; 631| 791| case OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_TYPE: ------------------ | | 276| 791|#define OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_TYPE 0xE0 ------------------ | Branch (631:9): [True: 791, False: 17.4k] ------------------ 632| 791| decoded--; 633| 791| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 791| do { \ | | 114| 791| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 791|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 791, False: 0] | | | | ------------------ | | ------------------ | | 115| 791| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 791| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 791] | | ------------------ ------------------ 634| 791| size = ogs_nas_eps_decode_sms_services_status(&attach_accept->sms_services_status, pkbuf); 635| 791| if (size < 0) { ------------------ | Branch (635:17): [True: 0, False: 791] ------------------ 636| 0| ogs_error("ogs_nas_eps_decode_sms_services_status() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 637| 0| return size; 638| 0| } 639| | 640| 791| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_PRESENT; ------------------ | | 242| 791|#define OGS_NAS_EPS_ATTACH_ACCEPT_SMS_SERVICES_STATUS_PRESENT ((uint64_t)1<<14) ------------------ 641| 791| decoded += size; 642| 791| break; 643| 523| case OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_TYPE: ------------------ | | 277| 523|#define OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_TYPE 0xD0 ------------------ | Branch (643:9): [True: 523, False: 17.7k] ------------------ 644| 523| decoded--; 645| 523| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 523| do { \ | | 114| 523| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 523|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 523, False: 0] | | | | ------------------ | | ------------------ | | 115| 523| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 523| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 523] | | ------------------ ------------------ 646| 523| size = ogs_nas_eps_decode_non_nw_provided_policies(&attach_accept->non_nw_provided_policies, pkbuf); 647| 523| if (size < 0) { ------------------ | Branch (647:17): [True: 0, False: 523] ------------------ 648| 0| ogs_error("ogs_nas_eps_decode_non_nw_provided_policies() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 649| 0| return size; 650| 0| } 651| | 652| 523| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_PRESENT; ------------------ | | 243| 523|#define OGS_NAS_EPS_ATTACH_ACCEPT_NON__NW_PROVIDED_POLICIES_PRESENT ((uint64_t)1<<15) ------------------ 653| 523| decoded += size; 654| 523| break; 655| 196| case OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_TYPE: ------------------ | | 278| 196|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_TYPE 0x6B ------------------ | Branch (655:9): [True: 196, False: 18.0k] ------------------ 656| 196| size = ogs_nas_eps_decode_gprs_timer_2(&attach_accept->t3448_value, pkbuf); 657| 196| if (size < 0) { ------------------ | Branch (657:17): [True: 1, False: 195] ------------------ 658| 1| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 659| 1| return size; 660| 1| } 661| | 662| 195| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_PRESENT; ------------------ | | 244| 195|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3448_VALUE_PRESENT ((uint64_t)1<<16) ------------------ 663| 195| decoded += size; 664| 195| break; 665| 473| case OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_TYPE: ------------------ | | 279| 473|#define OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_TYPE 0xC0 ------------------ | Branch (665:9): [True: 473, False: 17.7k] ------------------ 666| 473| decoded--; 667| 473| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 473| do { \ | | 114| 473| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 473|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 473, False: 0] | | | | ------------------ | | ------------------ | | 115| 473| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 473| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 473] | | ------------------ ------------------ 668| 473| size = ogs_nas_eps_decode_network_policy(&attach_accept->network_policy, pkbuf); 669| 473| if (size < 0) { ------------------ | Branch (669:17): [True: 0, False: 473] ------------------ 670| 0| ogs_error("ogs_nas_eps_decode_network_policy() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 671| 0| return size; 672| 0| } 673| | 674| 473| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_PRESENT; ------------------ | | 245| 473|#define OGS_NAS_EPS_ATTACH_ACCEPT_NETWORK_POLICY_PRESENT ((uint64_t)1<<17) ------------------ 675| 473| decoded += size; 676| 473| break; 677| 207| case OGS_NAS_EPS_ATTACH_ACCEPT_T3447_VALUE_TYPE: ------------------ | | 280| 207|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3447_VALUE_TYPE 0x6C ------------------ | Branch (677:9): [True: 207, False: 18.0k] ------------------ 678| 207| size = ogs_nas_eps_decode_gprs_timer_3(&attach_accept->t3447_value, pkbuf); 679| 207| if (size < 0) { ------------------ | Branch (679:17): [True: 1, False: 206] ------------------ 680| 1| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 681| 1| return size; 682| 1| } 683| | 684| 206| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_T3447_VALUE_PRESENT; ------------------ | | 246| 206|#define OGS_NAS_EPS_ATTACH_ACCEPT_T3447_VALUE_PRESENT ((uint64_t)1<<18) ------------------ 685| 206| decoded += size; 686| 206| break; 687| 215| case OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 281| 215|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE 0x7A ------------------ | Branch (687:9): [True: 215, False: 18.0k] ------------------ 688| 215| size = ogs_nas_eps_decode_extended_emergency_number_list(&attach_accept->extended_emergency_number_list, pkbuf); 689| 215| if (size < 0) { ------------------ | Branch (689:17): [True: 1, False: 214] ------------------ 690| 1| ogs_error("ogs_nas_eps_decode_extended_emergency_number_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 691| 1| return size; 692| 1| } 693| | 694| 214| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 247| 214|#define OGS_NAS_EPS_ATTACH_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<19) ------------------ 695| 214| decoded += size; 696| 214| break; 697| 203| case OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_TYPE: ------------------ | | 282| 203|#define OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_TYPE 0x7C ------------------ | Branch (697:9): [True: 203, False: 18.0k] ------------------ 698| 203| size = ogs_nas_eps_decode_ciphering_key_data(&attach_accept->ciphering_key_data, pkbuf); 699| 203| if (size < 0) { ------------------ | Branch (699:17): [True: 1, False: 202] ------------------ 700| 1| ogs_error("ogs_nas_eps_decode_ciphering_key_data() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 701| 1| return size; 702| 1| } 703| | 704| 202| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_PRESENT; ------------------ | | 248| 202|#define OGS_NAS_EPS_ATTACH_ACCEPT_CIPHERING_KEY_DATA_PRESENT ((uint64_t)1<<20) ------------------ 705| 202| decoded += size; 706| 202| break; 707| 204| case OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 283| 204|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (707:9): [True: 204, False: 18.0k] ------------------ 708| 204| size = ogs_nas_eps_decode_ue_radio_capability_id(&attach_accept->ue_radio_capability_id, pkbuf); 709| 204| if (size < 0) { ------------------ | Branch (709:17): [True: 1, False: 203] ------------------ 710| 1| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 711| 1| return size; 712| 1| } 713| | 714| 203| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 249| 203|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<21) ------------------ 715| 203| decoded += size; 716| 203| break; 717| 1.18k| case OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE: ------------------ | | 284| 1.18k|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE 0xB0 ------------------ | Branch (717:9): [True: 1.18k, False: 17.0k] ------------------ 718| 1.18k| decoded--; 719| 1.18k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.18k| do { \ | | 114| 1.18k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.18k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.18k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.18k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.18k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.18k] | | ------------------ ------------------ 720| 1.18k| size = ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication(&attach_accept->ue_radio_capability_id_deletion_indication, pkbuf); 721| 1.18k| if (size < 0) { ------------------ | Branch (721:17): [True: 0, False: 1.18k] ------------------ 722| 0| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 723| 0| return size; 724| 0| } 725| | 726| 1.18k| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT; ------------------ | | 250| 1.18k|#define OGS_NAS_EPS_ATTACH_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT ((uint64_t)1<<22) ------------------ 727| 1.18k| decoded += size; 728| 1.18k| break; 729| 225| case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 285| 225|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (729:9): [True: 225, False: 18.0k] ------------------ 730| 225| size = ogs_nas_eps_decode_wus_assistance_information(&attach_accept->negotiated_wus_assistance_information, pkbuf); 731| 225| if (size < 0) { ------------------ | Branch (731:17): [True: 1, False: 224] ------------------ 732| 1| ogs_error("ogs_nas_eps_decode_wus_assistance_information() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 733| 1| return size; 734| 1| } 735| | 736| 224| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 251| 224|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<23) ------------------ 737| 224| decoded += size; 738| 224| break; 739| 207| case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE: ------------------ | | 286| 207|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE 0x36 ------------------ | Branch (739:9): [True: 207, False: 18.0k] ------------------ 740| 207| size = ogs_nas_eps_decode_nb_s1_drx_parameter(&attach_accept->negotiated_drx_parameter_in_nb_s1_mode, pkbuf); 741| 207| if (size < 0) { ------------------ | Branch (741:17): [True: 1, False: 206] ------------------ 742| 1| ogs_error("ogs_nas_eps_decode_nb_s1_drx_parameter() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 743| 1| return size; 744| 1| } 745| | 746| 206| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 252| 206|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<24) ------------------ 747| 206| decoded += size; 748| 206| break; 749| 210| case OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE: ------------------ | | 287| 210|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (749:9): [True: 210, False: 18.0k] ------------------ 750| 210| size = ogs_nas_eps_decode_imsi_offset(&attach_accept->negotiated_imsi_offset, pkbuf); 751| 210| if (size < 0) { ------------------ | Branch (751:17): [True: 1, False: 209] ------------------ 752| 1| ogs_error("ogs_nas_eps_decode_imsi_offset() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 753| 1| return size; 754| 1| } 755| | 756| 209| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT; ------------------ | | 253| 209|#define OGS_NAS_EPS_ATTACH_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT ((uint64_t)1<<25) ------------------ 757| 209| decoded += size; 758| 209| break; 759| 208| case OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 288| 208|#define OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (759:9): [True: 208, False: 18.0k] ------------------ 760| 208| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 761| 208| if (size < 0) { ------------------ | Branch (761:17): [True: 1, False: 207] ------------------ 762| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 763| 1| return size; 764| 1| } 765| | 766| 207| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 254| 207|#define OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<26) ------------------ 767| 207| decoded += size; 768| 207| break; 769| 214| case OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 289| 214|#define OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE 0x1E ------------------ | Branch (769:9): [True: 214, False: 18.0k] ------------------ 770| 214| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_accept->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf); 771| 214| if (size < 0) { ------------------ | Branch (771:17): [True: 1, False: 213] ------------------ 772| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 773| 1| return size; 774| 1| } 775| | 776| 213| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 255| 213|#define OGS_NAS_EPS_ATTACH_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT ((uint64_t)1<<27) ------------------ 777| 213| decoded += size; 778| 213| break; 779| 207| case OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE: ------------------ | | 290| 207|#define OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE 0x1F ------------------ | Branch (779:9): [True: 207, False: 18.0k] ------------------ 780| 207| size = ogs_nas_eps_decode_unavailability_configuration(&attach_accept->unavailability_configuration, pkbuf); 781| 207| if (size < 0) { ------------------ | Branch (781:17): [True: 2, False: 205] ------------------ 782| 2| ogs_error("ogs_nas_eps_decode_unavailability_configuration() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 783| 2| return size; 784| 2| } 785| | 786| 205| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT; ------------------ | | 256| 205|#define OGS_NAS_EPS_ATTACH_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT ((uint64_t)1<<28) ------------------ 787| 205| decoded += size; 788| 205| break; 789| 212| case OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 291| 212|#define OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (789:9): [True: 212, False: 18.0k] ------------------ 790| 212| size = ogs_nas_eps_decode_access_technology_utilization_control(&attach_accept->access_technology_utilization_control, pkbuf); 791| 212| if (size < 0) { ------------------ | Branch (791:17): [True: 1, False: 211] ------------------ 792| 1| ogs_error("ogs_nas_eps_decode_access_technology_utilization_control() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 793| 1| return size; 794| 1| } 795| | 796| 211| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 257| 211|#define OGS_NAS_EPS_ATTACH_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<29) ------------------ 797| 211| decoded += size; 798| 211| break; 799| 230| case OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 292| 230|#define OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (799:9): [True: 230, False: 18.0k] ------------------ 800| 230| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&attach_accept->s_f_satellite_operation_parameters, pkbuf); 801| 230| if (size < 0) { ------------------ | Branch (801:17): [True: 1, False: 229] ------------------ 802| 1| ogs_error("ogs_nas_eps_decode_s_f_satellite_operation_parameters() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 803| 1| return size; 804| 1| } 805| | 806| 229| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 258| 229|#define OGS_NAS_EPS_ATTACH_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<30) ------------------ 807| 229| decoded += size; 808| 229| break; 809| 242| case OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE: ------------------ | | 293| 242|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE 0x22 ------------------ | Branch (809:9): [True: 242, False: 18.0k] ------------------ 810| 242| size = ogs_nas_eps_decode_registration_wait_range(&attach_accept->disaster_roaming_wait_range, pkbuf); 811| 242| if (size < 0) { ------------------ | Branch (811:17): [True: 2, False: 240] ------------------ 812| 2| ogs_error("ogs_nas_eps_decode_registration_wait_range() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 813| 2| return size; 814| 2| } 815| | 816| 240| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT; ------------------ | | 259| 240|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT ((uint64_t)1<<31) ------------------ 817| 240| decoded += size; 818| 240| break; 819| 212| case OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 294| 212|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (819:9): [True: 212, False: 18.0k] ------------------ 820| 212| size = ogs_nas_eps_decode_registration_wait_range(&attach_accept->disaster_return_wait_range, pkbuf); 821| 212| if (size < 0) { ------------------ | Branch (821:17): [True: 1, False: 211] ------------------ 822| 1| ogs_error("ogs_nas_eps_decode_registration_wait_range() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 823| 1| return size; 824| 1| } 825| | 826| 211| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 260| 211|#define OGS_NAS_EPS_ATTACH_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<32) ------------------ 827| 211| decoded += size; 828| 211| break; 829| 225| case OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE: ------------------ | | 295| 225|#define OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE 0x25 ------------------ | Branch (829:9): [True: 225, False: 18.0k] ------------------ 830| 225| size = ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition(&attach_accept->list_of_plmns_to_be_used_in_disaster_condition, pkbuf); 831| 225| if (size < 0) { ------------------ | Branch (831:17): [True: 2, False: 223] ------------------ 832| 2| ogs_error("ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 833| 2| return size; 834| 2| } 835| | 836| 223| attach_accept->presencemask |= OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT; ------------------ | | 261| 223|#define OGS_NAS_EPS_ATTACH_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT ((uint64_t)1<<33) ------------------ 837| 223| decoded += size; 838| 223| break; 839| 6.40k| default: ------------------ | Branch (839:9): [True: 6.40k, False: 11.8k] ------------------ 840| 6.40k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 6.40k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.40k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6.40k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6.40k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.40k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.40k| 0, __VA_ARGS__) | | ------------------ ------------------ 841| 6.40k| break; 842| 18.2k| } 843| 18.2k| } 844| | 845| 390| return decoded; 846| 424|} ogs_nas_eps_decode_attach_complete: 849| 40|{ 850| 40| ogs_nas_eps_attach_complete_t *attach_complete = &message->emm.attach_complete; 851| 40| int decoded = 0; 852| 40| int size = 0; 853| | 854| 40| ogs_trace("[NAS] Decode ATTACH_COMPLETE\n"); ------------------ | | 40| 40|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 40| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 40|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 40| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 40|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 40| 0, __VA_ARGS__) | | ------------------ ------------------ 855| | 856| 40| size = ogs_nas_eps_decode_esm_message_container(&attach_complete->esm_message_container, pkbuf); 857| 40| if (size < 0) { ------------------ | Branch (857:9): [True: 20, False: 20] ------------------ 858| 20| ogs_error("ogs_nas_eps_decode_esm_message_container() failed"); ------------------ | | 36| 20|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 859| 20| return size; 860| 20| } 861| | 862| 20| decoded += size; 863| | 864| 20| return decoded; 865| 40|} ogs_nas_eps_decode_attach_reject: 868| 157|{ 869| 157| ogs_nas_eps_attach_reject_t *attach_reject = &message->emm.attach_reject; 870| 157| int decoded = 0; 871| 157| int size = 0; 872| | 873| 157| ogs_trace("[NAS] Decode ATTACH_REJECT\n"); ------------------ | | 40| 157|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 157| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 157|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 157| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 157|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 157| 0, __VA_ARGS__) | | ------------------ ------------------ 874| | 875| 157| size = ogs_nas_eps_decode_emm_cause(&attach_reject->emm_cause, pkbuf); 876| 157| if (size < 0) { ------------------ | Branch (876:9): [True: 0, False: 157] ------------------ 877| 0| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 878| 0| return size; 879| 0| } 880| | 881| 157| decoded += size; 882| | 883| 6.35k| while (pkbuf->len > 0) { ------------------ | Branch (883:12): [True: 6.22k, False: 124] ------------------ 884| 6.22k| uint8_t *buffer = pkbuf->data; 885| 6.22k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (885:24): [True: 1.51k, False: 4.71k] ------------------ 886| | 887| 6.22k| size = sizeof(uint8_t); 888| 6.22k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (888:13): [True: 0, False: 6.22k] ------------------ 889| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 890| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 891| 0| } 892| 6.22k| decoded += size; 893| | 894| 6.22k| switch (type) { 895| 269| case OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_TYPE: ------------------ | | 365| 269|#define OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_TYPE 0x78 ------------------ | Branch (895:9): [True: 269, False: 5.95k] ------------------ 896| 269| size = ogs_nas_eps_decode_esm_message_container(&attach_reject->esm_message_container, pkbuf); 897| 269| if (size < 0) { ------------------ | Branch (897:17): [True: 8, False: 261] ------------------ 898| 8| ogs_error("ogs_nas_eps_decode_esm_message_container() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 899| 8| return size; 900| 8| } 901| | 902| 261| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_PRESENT; ------------------ | | 356| 261|#define OGS_NAS_EPS_ATTACH_REJECT_ESM_MESSAGE_CONTAINER_PRESENT ((uint64_t)1<<0) ------------------ 903| 261| decoded += size; 904| 261| break; 905| 209| case OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_TYPE: ------------------ | | 366| 209|#define OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_TYPE 0x5F ------------------ | Branch (905:9): [True: 209, False: 6.01k] ------------------ 906| 209| size = ogs_nas_eps_decode_gprs_timer_2(&attach_reject->t3346_value, pkbuf); 907| 209| if (size < 0) { ------------------ | Branch (907:17): [True: 4, False: 205] ------------------ 908| 4| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 909| 4| return size; 910| 4| } 911| | 912| 205| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_PRESENT; ------------------ | | 357| 205|#define OGS_NAS_EPS_ATTACH_REJECT_T3346_VALUE_PRESENT ((uint64_t)1<<1) ------------------ 913| 205| decoded += size; 914| 205| break; 915| 237| case OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_TYPE: ------------------ | | 367| 237|#define OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_TYPE 0x16 ------------------ | Branch (915:9): [True: 237, False: 5.99k] ------------------ 916| 237| size = ogs_nas_eps_decode_gprs_timer_2(&attach_reject->t3402_value, pkbuf); 917| 237| if (size < 0) { ------------------ | Branch (917:17): [True: 6, False: 231] ------------------ 918| 6| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 919| 6| return size; 920| 6| } 921| | 922| 231| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_PRESENT; ------------------ | | 358| 231|#define OGS_NAS_EPS_ATTACH_REJECT_T3402_VALUE_PRESENT ((uint64_t)1<<2) ------------------ 923| 231| decoded += size; 924| 231| break; 925| 622| case OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_TYPE: ------------------ | | 368| 622|#define OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_TYPE 0xA0 ------------------ | Branch (925:9): [True: 622, False: 5.60k] ------------------ 926| 622| decoded--; 927| 622| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 622| do { \ | | 114| 622| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 622|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 622, False: 0] | | | | ------------------ | | ------------------ | | 115| 622| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 622| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 622] | | ------------------ ------------------ 928| 622| size = ogs_nas_eps_decode_extended_emm_cause(&attach_reject->extended_emm_cause, pkbuf); 929| 622| if (size < 0) { ------------------ | Branch (929:17): [True: 0, False: 622] ------------------ 930| 0| ogs_error("ogs_nas_eps_decode_extended_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 931| 0| return size; 932| 0| } 933| | 934| 622| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_PRESENT; ------------------ | | 359| 622|#define OGS_NAS_EPS_ATTACH_REJECT_EXTENDED_EMM_CAUSE_PRESENT ((uint64_t)1<<3) ------------------ 935| 622| decoded += size; 936| 622| break; 937| 426| case OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE: ------------------ | | 369| 426|#define OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE 0x1C ------------------ | Branch (937:9): [True: 426, False: 5.80k] ------------------ 938| 426| size = ogs_nas_eps_decode_gprs_timer_3(&attach_reject->lower_bound_timer_value, pkbuf); 939| 426| if (size < 0) { ------------------ | Branch (939:17): [True: 3, False: 423] ------------------ 940| 3| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 941| 3| return size; 942| 3| } 943| | 944| 423| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT; ------------------ | | 360| 423|#define OGS_NAS_EPS_ATTACH_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT ((uint64_t)1<<4) ------------------ 945| 423| decoded += size; 946| 423| break; 947| 222| case OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 370| 222|#define OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (947:9): [True: 222, False: 6.00k] ------------------ 948| 222| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 949| 222| if (size < 0) { ------------------ | Branch (949:17): [True: 2, False: 220] ------------------ 950| 2| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 951| 2| return size; 952| 2| } 953| | 954| 220| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 361| 220|#define OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<5) ------------------ 955| 220| decoded += size; 956| 220| break; 957| 207| case OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 371| 207|#define OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE 0x1E ------------------ | Branch (957:9): [True: 207, False: 6.02k] ------------------ 958| 207| size = ogs_nas_eps_decode_tracking_area_identity_list(&attach_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf); 959| 207| if (size < 0) { ------------------ | Branch (959:17): [True: 1, False: 206] ------------------ 960| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 961| 1| return size; 962| 1| } 963| | 964| 206| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 362| 206|#define OGS_NAS_EPS_ATTACH_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT ((uint64_t)1<<6) ------------------ 965| 206| decoded += size; 966| 206| break; 967| 216| case OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 372| 216|#define OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (967:9): [True: 216, False: 6.01k] ------------------ 968| 216| size = ogs_nas_eps_decode_access_technology_utilization_control(&attach_reject->access_technology_utilization_control, pkbuf); 969| 216| if (size < 0) { ------------------ | Branch (969:17): [True: 2, False: 214] ------------------ 970| 2| ogs_error("ogs_nas_eps_decode_access_technology_utilization_control() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 971| 2| return size; 972| 2| } 973| | 974| 214| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 363| 214|#define OGS_NAS_EPS_ATTACH_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<7) ------------------ 975| 214| decoded += size; 976| 214| break; 977| 259| case OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 373| 259|#define OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (977:9): [True: 259, False: 5.96k] ------------------ 978| 259| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&attach_reject->s_f_satellite_operation_parameters, pkbuf); 979| 259| if (size < 0) { ------------------ | Branch (979:17): [True: 7, False: 252] ------------------ 980| 7| ogs_error("ogs_nas_eps_decode_s_f_satellite_operation_parameters() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 981| 7| return size; 982| 7| } 983| | 984| 252| attach_reject->presencemask |= OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 364| 252|#define OGS_NAS_EPS_ATTACH_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<8) ------------------ 985| 252| decoded += size; 986| 252| break; 987| 3.56k| default: ------------------ | Branch (987:9): [True: 3.56k, False: 2.66k] ------------------ 988| 3.56k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.56k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.56k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.56k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.56k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.56k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.56k| 0, __VA_ARGS__) | | ------------------ ------------------ 989| 3.56k| break; 990| 6.22k| } 991| 6.22k| } 992| | 993| 124| return decoded; 994| 157|} ogs_nas_eps_decode_detach_request_from_ue: 997| 9|{ 998| 9| ogs_nas_eps_detach_request_from_ue_t *detach_request_from_ue = &message->emm.detach_request_from_ue; 999| 9| int decoded = 0; 1000| 9| int size = 0; 1001| | 1002| 9| ogs_trace("[NAS] Decode DETACH_REQUEST\n"); ------------------ | | 40| 9|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1003| | 1004| 9| size = ogs_nas_eps_decode_detach_type(&detach_request_from_ue->detach_type, pkbuf); 1005| 9| if (size < 0) { ------------------ | Branch (1005:9): [True: 0, False: 9] ------------------ 1006| 0| ogs_error("ogs_nas_eps_decode_detach_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1007| 0| return size; 1008| 0| } 1009| | 1010| 9| decoded += size; 1011| | 1012| 9| size = ogs_nas_eps_decode_eps_mobile_identity(&detach_request_from_ue->eps_mobile_identity, pkbuf); 1013| 9| if (size < 0) { ------------------ | Branch (1013:9): [True: 1, False: 8] ------------------ 1014| 1| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1015| 1| return size; 1016| 1| } 1017| | 1018| 8| decoded += size; 1019| | 1020| 8| return decoded; 1021| 9|} ogs_nas_eps_decode_tracking_area_update_request: 1131| 679|{ 1132| 679| ogs_nas_eps_tracking_area_update_request_t *tracking_area_update_request = &message->emm.tracking_area_update_request; 1133| 679| int decoded = 0; 1134| 679| int size = 0; 1135| | 1136| 679| ogs_trace("[NAS] Decode TRACKING_AREA_UPDATE_REQUEST\n"); ------------------ | | 40| 679|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 679| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 679|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 679| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 679|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 679| 0, __VA_ARGS__) | | ------------------ ------------------ 1137| | 1138| 679| size = ogs_nas_eps_decode_eps_update_type(&tracking_area_update_request->eps_update_type, pkbuf); 1139| 679| if (size < 0) { ------------------ | Branch (1139:9): [True: 0, False: 679] ------------------ 1140| 0| ogs_error("ogs_nas_eps_decode_eps_update_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1141| 0| return size; 1142| 0| } 1143| | 1144| 679| decoded += size; 1145| | 1146| 679| size = ogs_nas_eps_decode_eps_mobile_identity(&tracking_area_update_request->old_guti, pkbuf); 1147| 679| if (size < 0) { ------------------ | Branch (1147:9): [True: 7, False: 672] ------------------ 1148| 7| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1149| 7| return size; 1150| 7| } 1151| | 1152| 672| decoded += size; 1153| | 1154| 34.3k| while (pkbuf->len > 0) { ------------------ | Branch (1154:12): [True: 33.9k, False: 467] ------------------ 1155| 33.9k| uint8_t *buffer = pkbuf->data; 1156| 33.9k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (1156:24): [True: 12.1k, False: 21.7k] ------------------ 1157| | 1158| 33.9k| size = sizeof(uint8_t); 1159| 33.9k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1159:13): [True: 0, False: 33.9k] ------------------ 1160| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1161| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 1162| 0| } 1163| 33.9k| decoded += size; 1164| | 1165| 33.9k| switch (type) { 1166| 1.14k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_TYPE: ------------------ | | 478| 1.14k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_TYPE 0xB0 ------------------ | Branch (1166:9): [True: 1.14k, False: 32.7k] ------------------ 1167| 1.14k| decoded--; 1168| 1.14k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.14k| do { \ | | 114| 1.14k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.14k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.14k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.14k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.14k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.14k] | | ------------------ ------------------ 1169| 1.14k| size = ogs_nas_eps_decode_key_set_identifier(&tracking_area_update_request->non_current_native_nas_key_set_identifier, pkbuf); 1170| 1.14k| if (size < 0) { ------------------ | Branch (1170:17): [True: 0, False: 1.14k] ------------------ 1171| 0| ogs_error("ogs_nas_eps_decode_key_set_identifier() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1172| 0| return size; 1173| 0| } 1174| | 1175| 1.14k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_PRESENT; ------------------ | | 441| 1.14k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NON_CURRENT_NATIVE_NAS_KEY_SET_IDENTIFIER_PRESENT ((uint64_t)1<<0) ------------------ 1176| 1.14k| decoded += size; 1177| 1.14k| break; 1178| 1.12k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_TYPE: ------------------ | | 479| 1.12k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_TYPE 0x80 ------------------ | Branch (1178:9): [True: 1.12k, False: 32.7k] ------------------ 1179| 1.12k| decoded--; 1180| 1.12k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.12k| do { \ | | 114| 1.12k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.12k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.12k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.12k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.12k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.12k] | | ------------------ ------------------ 1181| 1.12k| size = ogs_nas_eps_decode_ciphering_key_sequence_number(&tracking_area_update_request->gprs_ciphering_key_sequence_number, pkbuf); 1182| 1.12k| if (size < 0) { ------------------ | Branch (1182:17): [True: 0, False: 1.12k] ------------------ 1183| 0| ogs_error("ogs_nas_eps_decode_ciphering_key_sequence_number() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1184| 0| return size; 1185| 0| } 1186| | 1187| 1.12k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_PRESENT; ------------------ | | 442| 1.12k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_GPRS_CIPHERING_KEY_SEQUENCE_NUMBER_PRESENT ((uint64_t)1<<1) ------------------ 1188| 1.12k| decoded += size; 1189| 1.12k| break; 1190| 429| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE: ------------------ | | 480| 429|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_TYPE 0x19 ------------------ | Branch (1190:9): [True: 429, False: 33.4k] ------------------ 1191| 429| size = ogs_nas_eps_decode_p_tmsi_signature(&tracking_area_update_request->old_p_tmsi_signature, pkbuf); 1192| 429| if (size < 0) { ------------------ | Branch (1192:17): [True: 8, False: 421] ------------------ 1193| 8| ogs_error("ogs_nas_eps_decode_p_tmsi_signature() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1194| 8| return size; 1195| 8| } 1196| | 1197| 421| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT; ------------------ | | 443| 421|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_P_TMSI_SIGNATURE_PRESENT ((uint64_t)1<<2) ------------------ 1198| 421| decoded += size; 1199| 421| break; 1200| 537| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_TYPE: ------------------ | | 481| 537|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_TYPE 0x50 ------------------ | Branch (1200:9): [True: 537, False: 33.3k] ------------------ 1201| 537| size = ogs_nas_eps_decode_eps_mobile_identity(&tracking_area_update_request->additional_guti, pkbuf); 1202| 537| if (size < 0) { ------------------ | Branch (1202:17): [True: 7, False: 530] ------------------ 1203| 7| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1204| 7| return size; 1205| 7| } 1206| | 1207| 530| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_PRESENT; ------------------ | | 444| 530|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_GUTI_PRESENT ((uint64_t)1<<3) ------------------ 1208| 530| decoded += size; 1209| 530| break; 1210| 251| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_TYPE: ------------------ | | 482| 251|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_TYPE 0x55 ------------------ | Branch (1210:9): [True: 251, False: 33.6k] ------------------ 1211| 251| size = ogs_nas_eps_decode_nonce(&tracking_area_update_request->nonceue, pkbuf); 1212| 251| if (size < 0) { ------------------ | Branch (1212:17): [True: 7, False: 244] ------------------ 1213| 7| ogs_error("ogs_nas_eps_decode_nonce() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1214| 7| return size; 1215| 7| } 1216| | 1217| 244| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_PRESENT; ------------------ | | 445| 244|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_NONCEUE_PRESENT ((uint64_t)1<<4) ------------------ 1218| 244| decoded += size; 1219| 244| break; 1220| 392| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_TYPE: ------------------ | | 483| 392|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_TYPE 0x58 ------------------ | Branch (1220:9): [True: 392, False: 33.5k] ------------------ 1221| 392| size = ogs_nas_eps_decode_ue_network_capability(&tracking_area_update_request->ue_network_capability, pkbuf); 1222| 392| if (size < 0) { ------------------ | Branch (1222:17): [True: 8, False: 384] ------------------ 1223| 8| ogs_error("ogs_nas_eps_decode_ue_network_capability() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1224| 8| return size; 1225| 8| } 1226| | 1227| 384| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_PRESENT; ------------------ | | 446| 384|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<5) ------------------ 1228| 384| decoded += size; 1229| 384| break; 1230| 354| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE: ------------------ | | 484| 354|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_TYPE 0x52 ------------------ | Branch (1230:9): [True: 354, False: 33.5k] ------------------ 1231| 354| size = ogs_nas_eps_decode_tracking_area_identity(&tracking_area_update_request->last_visited_registered_tai, pkbuf); 1232| 354| if (size < 0) { ------------------ | Branch (1232:17): [True: 9, False: 345] ------------------ 1233| 9| ogs_error("ogs_nas_eps_decode_tracking_area_identity() failed"); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1234| 9| return size; 1235| 9| } 1236| | 1237| 345| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT; ------------------ | | 447| 345|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT ((uint64_t)1<<6) ------------------ 1238| 345| decoded += size; 1239| 345| break; 1240| 314| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_TYPE: ------------------ | | 485| 314|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_TYPE 0x5C ------------------ | Branch (1240:9): [True: 314, False: 33.5k] ------------------ 1241| 314| size = ogs_nas_eps_decode_drx_parameter(&tracking_area_update_request->drx_parameter, pkbuf); 1242| 314| if (size < 0) { ------------------ | Branch (1242:17): [True: 6, False: 308] ------------------ 1243| 6| ogs_error("ogs_nas_eps_decode_drx_parameter() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1244| 6| return size; 1245| 6| } 1246| | 1247| 308| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_PRESENT; ------------------ | | 448| 308|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_PRESENT ((uint64_t)1<<7) ------------------ 1248| 308| decoded += size; 1249| 308| break; 1250| 806| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_TYPE: ------------------ | | 486| 806|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_TYPE 0xA0 ------------------ | Branch (1250:9): [True: 806, False: 33.0k] ------------------ 1251| 806| decoded--; 1252| 806| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 806| do { \ | | 114| 806| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 806|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 806, False: 0] | | | | ------------------ | | ------------------ | | 115| 806| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 806| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 806] | | ------------------ ------------------ 1253| 806| size = ogs_nas_eps_decode_ue_radio_capability_information_update_needed(&tracking_area_update_request->ue_radio_capability_information_update_needed, pkbuf); 1254| 806| if (size < 0) { ------------------ | Branch (1254:17): [True: 0, False: 806] ------------------ 1255| 0| ogs_error("ogs_nas_eps_decode_ue_radio_capability_information_update_needed() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1256| 0| return size; 1257| 0| } 1258| | 1259| 806| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_PRESENT; ------------------ | | 449| 806|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED_PRESENT ((uint64_t)1<<8) ------------------ 1260| 806| decoded += size; 1261| 806| break; 1262| 237| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE: ------------------ | | 487| 237|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 ------------------ | Branch (1262:9): [True: 237, False: 33.6k] ------------------ 1263| 237| size = ogs_nas_eps_decode_eps_bearer_context_status(&tracking_area_update_request->eps_bearer_context_status, pkbuf); 1264| 237| if (size < 0) { ------------------ | Branch (1264:17): [True: 4, False: 233] ------------------ 1265| 4| ogs_error("ogs_nas_eps_decode_eps_bearer_context_status() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 1266| 4| return size; 1267| 4| } 1268| | 1269| 233| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT; ------------------ | | 450| 233|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT ((uint64_t)1<<9) ------------------ 1270| 233| decoded += size; 1271| 233| break; 1272| 247| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_TYPE: ------------------ | | 488| 247|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_TYPE 0x31 ------------------ | Branch (1272:9): [True: 247, False: 33.6k] ------------------ 1273| 247| size = ogs_nas_eps_decode_ms_network_capability(&tracking_area_update_request->ms_network_capability, pkbuf); 1274| 247| if (size < 0) { ------------------ | Branch (1274:17): [True: 9, False: 238] ------------------ 1275| 9| ogs_error("ogs_nas_eps_decode_ms_network_capability() failed"); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1276| 9| return size; 1277| 9| } 1278| | 1279| 238| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_PRESENT; ------------------ | | 451| 238|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<10) ------------------ 1280| 238| decoded += size; 1281| 238| break; 1282| 252| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 489| 252|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (1282:9): [True: 252, False: 33.6k] ------------------ 1283| 252| size = ogs_nas_eps_decode_location_area_identification(&tracking_area_update_request->old_location_area_identification, pkbuf); 1284| 252| if (size < 0) { ------------------ | Branch (1284:17): [True: 1, False: 251] ------------------ 1285| 1| ogs_error("ogs_nas_eps_decode_location_area_identification() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1286| 1| return size; 1287| 1| } 1288| | 1289| 251| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 452| 251|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<11) ------------------ 1290| 251| decoded += size; 1291| 251| break; 1292| 1.34k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_TYPE: ------------------ | | 490| 1.34k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_TYPE 0x90 ------------------ | Branch (1292:9): [True: 1.34k, False: 32.5k] ------------------ 1293| 1.34k| decoded--; 1294| 1.34k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.34k| do { \ | | 114| 1.34k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.34k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.34k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.34k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.34k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.34k] | | ------------------ ------------------ 1295| 1.34k| size = ogs_nas_eps_decode_tmsi_status(&tracking_area_update_request->tmsi_status, pkbuf); 1296| 1.34k| if (size < 0) { ------------------ | Branch (1296:17): [True: 0, False: 1.34k] ------------------ 1297| 0| ogs_error("ogs_nas_eps_decode_tmsi_status() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1298| 0| return size; 1299| 0| } 1300| | 1301| 1.34k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_PRESENT; ------------------ | | 453| 1.34k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_STATUS_PRESENT ((uint64_t)1<<12) ------------------ 1302| 1.34k| decoded += size; 1303| 1.34k| break; 1304| 348| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE: ------------------ | | 491| 348|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_TYPE 0x11 ------------------ | Branch (1304:9): [True: 348, False: 33.5k] ------------------ 1305| 348| size = ogs_nas_eps_decode_mobile_station_classmark_2(&tracking_area_update_request->mobile_station_classmark_2, pkbuf); 1306| 348| if (size < 0) { ------------------ | Branch (1306:17): [True: 6, False: 342] ------------------ 1307| 6| ogs_error("ogs_nas_eps_decode_mobile_station_classmark_2() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1308| 6| return size; 1309| 6| } 1310| | 1311| 342| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT; ------------------ | | 454| 342|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_2_PRESENT ((uint64_t)1<<13) ------------------ 1312| 342| decoded += size; 1313| 342| break; 1314| 310| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE: ------------------ | | 492| 310|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_TYPE 0x20 ------------------ | Branch (1314:9): [True: 310, False: 33.5k] ------------------ 1315| 310| size = ogs_nas_eps_decode_mobile_station_classmark_3(&tracking_area_update_request->mobile_station_classmark_3, pkbuf); 1316| 310| if (size < 0) { ------------------ | Branch (1316:17): [True: 8, False: 302] ------------------ 1317| 8| ogs_error("ogs_nas_eps_decode_mobile_station_classmark_3() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1318| 8| return size; 1319| 8| } 1320| | 1321| 302| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT; ------------------ | | 455| 302|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MOBILE_STATION_CLASSMARK_3_PRESENT ((uint64_t)1<<14) ------------------ 1322| 302| decoded += size; 1323| 302| break; 1324| 272| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_TYPE: ------------------ | | 493| 272|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_TYPE 0x40 ------------------ | Branch (1324:9): [True: 272, False: 33.6k] ------------------ 1325| 272| size = ogs_nas_eps_decode_supported_codec_list(&tracking_area_update_request->supported_codecs, pkbuf); 1326| 272| if (size < 0) { ------------------ | Branch (1326:17): [True: 4, False: 268] ------------------ 1327| 4| ogs_error("ogs_nas_eps_decode_supported_codec_list() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 1328| 4| return size; 1329| 4| } 1330| | 1331| 268| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_PRESENT; ------------------ | | 456| 268|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_SUPPORTED_CODECS_PRESENT ((uint64_t)1<<15) ------------------ 1332| 268| decoded += size; 1333| 268| break; 1334| 4.56k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE: ------------------ | | 494| 4.56k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_TYPE 0xF0 ------------------ | Branch (1334:9): [True: 4.56k, False: 29.3k] ------------------ 1335| 4.56k| decoded--; 1336| 4.56k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 4.56k| do { \ | | 114| 4.56k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 4.56k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 4.56k, False: 0] | | | | ------------------ | | ------------------ | | 115| 4.56k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.56k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 4.56k] | | ------------------ ------------------ 1337| 4.56k| size = ogs_nas_eps_decode_additional_update_type(&tracking_area_update_request->additional_update_type, pkbuf); 1338| 4.56k| if (size < 0) { ------------------ | Branch (1338:17): [True: 0, False: 4.56k] ------------------ 1339| 0| ogs_error("ogs_nas_eps_decode_additional_update_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1340| 0| return size; 1341| 0| } 1342| | 1343| 4.56k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT; ------------------ | | 457| 4.56k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_UPDATE_TYPE_PRESENT ((uint64_t)1<<16) ------------------ 1344| 4.56k| decoded += size; 1345| 4.56k| break; 1346| 245| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE: ------------------ | | 495| 245|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_TYPE 0x5D ------------------ | Branch (1346:9): [True: 245, False: 33.6k] ------------------ 1347| 245| size = ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting(&tracking_area_update_request->voice_domain_preference_and_ue_usage_setting, pkbuf); 1348| 245| if (size < 0) { ------------------ | Branch (1348:17): [True: 7, False: 238] ------------------ 1349| 7| ogs_error("ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1350| 7| return size; 1351| 7| } 1352| | 1353| 238| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT; ------------------ | | 458| 238|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING_PRESENT ((uint64_t)1<<17) ------------------ 1354| 238| decoded += size; 1355| 238| break; 1356| 974| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_TYPE: ------------------ | | 496| 974|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_TYPE 0xE0 ------------------ | Branch (1356:9): [True: 974, False: 32.9k] ------------------ 1357| 974| decoded--; 1358| 974| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 974| do { \ | | 114| 974| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 974|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 974, False: 0] | | | | ------------------ | | ------------------ | | 115| 974| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 974| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 974] | | ------------------ ------------------ 1359| 974| size = ogs_nas_eps_decode_guti_type(&tracking_area_update_request->old_guti_type, pkbuf); 1360| 974| if (size < 0) { ------------------ | Branch (1360:17): [True: 0, False: 974] ------------------ 1361| 0| ogs_error("ogs_nas_eps_decode_guti_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1362| 0| return size; 1363| 0| } 1364| | 1365| 974| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_PRESENT; ------------------ | | 459| 974|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_OLD_GUTI_TYPE_PRESENT ((uint64_t)1<<18) ------------------ 1366| 974| decoded += size; 1367| 974| break; 1368| 1.31k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_TYPE: ------------------ | | 497| 1.31k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 ------------------ | Branch (1368:9): [True: 1.31k, False: 32.5k] ------------------ 1369| 1.31k| decoded--; 1370| 1.31k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.31k| do { \ | | 114| 1.31k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.31k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.31k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.31k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.31k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.31k] | | ------------------ ------------------ 1371| 1.31k| size = ogs_nas_eps_decode_device_properties(&tracking_area_update_request->device_properties, pkbuf); 1372| 1.31k| if (size < 0) { ------------------ | Branch (1372:17): [True: 0, False: 1.31k] ------------------ 1373| 0| ogs_error("ogs_nas_eps_decode_device_properties() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1374| 0| return size; 1375| 0| } 1376| | 1377| 1.31k| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_PRESENT; ------------------ | | 460| 1.31k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DEVICE_PROPERTIES_PRESENT ((uint64_t)1<<19) ------------------ 1378| 1.31k| decoded += size; 1379| 1.31k| break; 1380| 903| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 498| 903|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_TYPE 0xC0 ------------------ | Branch (1380:9): [True: 903, False: 32.9k] ------------------ 1381| 903| decoded--; 1382| 903| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 903| do { \ | | 114| 903| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 903|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 903, False: 0] | | | | ------------------ | | ------------------ | | 115| 903| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 903| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 903] | | ------------------ ------------------ 1383| 903| size = ogs_nas_eps_decode_ms_network_feature_support(&tracking_area_update_request->ms_network_feature_support, pkbuf); 1384| 903| if (size < 0) { ------------------ | Branch (1384:17): [True: 0, False: 903] ------------------ 1385| 0| ogs_error("ogs_nas_eps_decode_ms_network_feature_support() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1386| 0| return size; 1387| 0| } 1388| | 1389| 903| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 461| 903|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_MS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<20) ------------------ 1390| 903| decoded += size; 1391| 903| break; 1392| 278| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE: ------------------ | | 499| 278|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_TYPE 0x10 ------------------ | Branch (1392:9): [True: 278, False: 33.6k] ------------------ 1393| 278| size = ogs_nas_eps_decode_network_resource_identifier_container(&tracking_area_update_request->tmsi_based_nri_container, pkbuf); 1394| 278| if (size < 0) { ------------------ | Branch (1394:17): [True: 15, False: 263] ------------------ 1395| 15| ogs_error("ogs_nas_eps_decode_network_resource_identifier_container() failed"); ------------------ | | 36| 15|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 15| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 15|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 15| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 15|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 15| 0, __VA_ARGS__) | | ------------------ ------------------ 1396| 15| return size; 1397| 15| } 1398| | 1399| 263| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT; ------------------ | | 462| 263|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_TMSI_BASED_NRI_CONTAINER_PRESENT ((uint64_t)1<<21) ------------------ 1400| 263| decoded += size; 1401| 263| break; 1402| 207| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_TYPE: ------------------ | | 500| 207|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_TYPE 0x6A ------------------ | Branch (1402:9): [True: 207, False: 33.6k] ------------------ 1403| 207| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_request->t3324_value, pkbuf); 1404| 207| if (size < 0) { ------------------ | Branch (1404:17): [True: 2, False: 205] ------------------ 1405| 2| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 1406| 2| return size; 1407| 2| } 1408| | 1409| 205| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_PRESENT; ------------------ | | 463| 205|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3324_VALUE_PRESENT ((uint64_t)1<<22) ------------------ 1410| 205| decoded += size; 1411| 205| break; 1412| 211| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 501| 211|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (1412:9): [True: 211, False: 33.6k] ------------------ 1413| 211| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_request->t3412_extended_value, pkbuf); 1414| 211| if (size < 0) { ------------------ | Branch (1414:17): [True: 3, False: 208] ------------------ 1415| 3| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 1416| 3| return size; 1417| 3| } 1418| | 1419| 208| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 464| 208|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<23) ------------------ 1420| 208| decoded += size; 1421| 208| break; 1422| 209| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 502| 209|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (1422:9): [True: 209, False: 33.6k] ------------------ 1423| 209| size = ogs_nas_eps_decode_extended_drx_parameters(&tracking_area_update_request->extended_drx_parameters, pkbuf); 1424| 209| if (size < 0) { ------------------ | Branch (1424:17): [True: 2, False: 207] ------------------ 1425| 2| ogs_error("ogs_nas_eps_decode_extended_drx_parameters() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 1426| 2| return size; 1427| 2| } 1428| | 1429| 207| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 465| 207|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<24) ------------------ 1430| 207| decoded += size; 1431| 207| break; 1432| 262| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE: ------------------ | | 503| 262|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE 0x6F ------------------ | Branch (1432:9): [True: 262, False: 33.6k] ------------------ 1433| 262| size = ogs_nas_eps_decode_ue_additional_security_capability(&tracking_area_update_request->ue_additional_security_capability, pkbuf); 1434| 262| if (size < 0) { ------------------ | Branch (1434:17): [True: 10, False: 252] ------------------ 1435| 10| ogs_error("ogs_nas_eps_decode_ue_additional_security_capability() failed"); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 1436| 10| return size; 1437| 10| } 1438| | 1439| 252| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT; ------------------ | | 466| 252|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT ((uint64_t)1<<25) ------------------ 1440| 252| decoded += size; 1441| 252| break; 1442| 266| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_TYPE: ------------------ | | 504| 266|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_TYPE 0x6D ------------------ | Branch (1442:9): [True: 266, False: 33.6k] ------------------ 1443| 266| size = ogs_nas_eps_decode_ue_status(&tracking_area_update_request->ue_status, pkbuf); 1444| 266| if (size < 0) { ------------------ | Branch (1444:17): [True: 11, False: 255] ------------------ 1445| 11| ogs_error("ogs_nas_eps_decode_ue_status() failed"); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 1446| 11| return size; 1447| 11| } 1448| | 1449| 255| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_PRESENT; ------------------ | | 467| 255|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_STATUS_PRESENT ((uint64_t)1<<26) ------------------ 1450| 255| decoded += size; 1451| 255| break; 1452| 499| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE: ------------------ | | 505| 499|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_TYPE 0x17 ------------------ | Branch (1452:9): [True: 499, False: 33.4k] ------------------ 1453| 499| size = ogs_nas_eps_decode_additional_information_requested(&tracking_area_update_request->additional_information_requested, pkbuf); 1454| 499| if (size < 0) { ------------------ | Branch (1454:17): [True: 8, False: 491] ------------------ 1455| 8| ogs_error("ogs_nas_eps_decode_additional_information_requested() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1456| 8| return size; 1457| 8| } 1458| | 1459| 491| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT; ------------------ | | 468| 491|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_ADDITIONAL_INFORMATION_REQUESTED_PRESENT ((uint64_t)1<<27) ------------------ 1460| 491| decoded += size; 1461| 491| break; 1462| 421| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_TYPE: ------------------ | | 506| 421|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_TYPE 0x32 ------------------ | Branch (1462:9): [True: 421, False: 33.4k] ------------------ 1463| 421| size = ogs_nas_eps_decode_n1_ue_network_capability(&tracking_area_update_request->n1_ue_network_capability, pkbuf); 1464| 421| if (size < 0) { ------------------ | Branch (1464:17): [True: 15, False: 406] ------------------ 1465| 15| ogs_error("ogs_nas_eps_decode_n1_ue_network_capability() failed"); ------------------ | | 36| 15|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 15| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 15|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 15| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 15|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 15| 0, __VA_ARGS__) | | ------------------ ------------------ 1466| 15| return size; 1467| 15| } 1468| | 1469| 406| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT; ------------------ | | 469| 406|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_N1_UE_NETWORK_CAPABILITY_PRESENT ((uint64_t)1<<28) ------------------ 1470| 406| decoded += size; 1471| 406| break; 1472| 507| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE: ------------------ | | 507| 507|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_TYPE 0x34 ------------------ | Branch (1472:9): [True: 507, False: 33.3k] ------------------ 1473| 507| size = ogs_nas_eps_decode_ue_radio_capability_id_availability(&tracking_area_update_request->ue_radio_capability_id_availability, pkbuf); 1474| 507| if (size < 0) { ------------------ | Branch (1474:17): [True: 14, False: 493] ------------------ 1475| 14| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_availability() failed"); ------------------ | | 36| 14|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 14| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 14|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 14| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 14|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 14| 0, __VA_ARGS__) | | ------------------ ------------------ 1476| 14| return size; 1477| 14| } 1478| | 1479| 493| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT; ------------------ | | 470| 493|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_RADIO_CAPABILITY_ID_AVAILABILITY_PRESENT ((uint64_t)1<<29) ------------------ 1480| 493| decoded += size; 1481| 493| break; 1482| 317| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 508| 317|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (1482:9): [True: 317, False: 33.5k] ------------------ 1483| 317| size = ogs_nas_eps_decode_wus_assistance_information(&tracking_area_update_request->requested_wus_assistance_information, pkbuf); 1484| 317| if (size < 0) { ------------------ | Branch (1484:17): [True: 1, False: 316] ------------------ 1485| 1| ogs_error("ogs_nas_eps_decode_wus_assistance_information() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1486| 1| return size; 1487| 1| } 1488| | 1489| 316| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 471| 316|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<30) ------------------ 1490| 316| decoded += size; 1491| 316| break; 1492| 213| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_TYPE: ------------------ | | 509| 213|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_TYPE 0x36 ------------------ | Branch (1492:9): [True: 213, False: 33.6k] ------------------ 1493| 213| size = ogs_nas_eps_decode_nb_s1_drx_parameter(&tracking_area_update_request->drx_parameter_in_nb_s1_mode, pkbuf); 1494| 213| if (size < 0) { ------------------ | Branch (1494:17): [True: 3, False: 210] ------------------ 1495| 3| ogs_error("ogs_nas_eps_decode_nb_s1_drx_parameter() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 1496| 3| return size; 1497| 3| } 1498| | 1499| 210| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 472| 210|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<31) ------------------ 1500| 210| decoded += size; 1501| 210| break; 1502| 314| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_TYPE: ------------------ | | 510| 314|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (1502:9): [True: 314, False: 33.5k] ------------------ 1503| 314| size = ogs_nas_eps_decode_imsi_offset(&tracking_area_update_request->requested_imsi_offset, pkbuf); 1504| 314| if (size < 0) { ------------------ | Branch (1504:17): [True: 2, False: 312] ------------------ 1505| 2| ogs_error("ogs_nas_eps_decode_imsi_offset() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 1506| 2| return size; 1507| 2| } 1508| | 1509| 312| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT; ------------------ | | 473| 312|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_REQUESTED_IMSI_OFFSET_PRESENT ((uint64_t)1<<32) ------------------ 1510| 312| decoded += size; 1511| 312| break; 1512| 617| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_TYPE: ------------------ | | 511| 617|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_TYPE 0x29 ------------------ | Branch (1512:9): [True: 617, False: 33.2k] ------------------ 1513| 617| size = ogs_nas_eps_decode_ue_request_type(&tracking_area_update_request->ue_request_type, pkbuf); 1514| 617| if (size < 0) { ------------------ | Branch (1514:17): [True: 13, False: 604] ------------------ 1515| 13| ogs_error("ogs_nas_eps_decode_ue_request_type() failed"); ------------------ | | 36| 13|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 13| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 13|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 13| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 13|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 13| 0, __VA_ARGS__) | | ------------------ ------------------ 1516| 13| return size; 1517| 13| } 1518| | 1519| 604| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_PRESENT; ------------------ | | 474| 604|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_REQUEST_TYPE_PRESENT ((uint64_t)1<<33) ------------------ 1520| 604| decoded += size; 1521| 604| break; 1522| 416| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_TYPE: ------------------ | | 512| 416|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_TYPE 0x28 ------------------ | Branch (1522:9): [True: 416, False: 33.4k] ------------------ 1523| 416| size = ogs_nas_eps_decode_paging_restriction(&tracking_area_update_request->paging_restriction, pkbuf); 1524| 416| if (size < 0) { ------------------ | Branch (1524:17): [True: 9, False: 407] ------------------ 1525| 9| ogs_error("ogs_nas_eps_decode_paging_restriction() failed"); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1526| 9| return size; 1527| 9| } 1528| | 1529| 407| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_PRESENT; ------------------ | | 475| 407|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_PAGING_RESTRICTION_PRESENT ((uint64_t)1<<34) ------------------ 1530| 407| decoded += size; 1531| 407| break; 1532| 231| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_TYPE: ------------------ | | 513| 231|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_TYPE 0x30 ------------------ | Branch (1532:9): [True: 231, False: 33.6k] ------------------ 1533| 231| size = ogs_nas_eps_decode_unavailability_information(&tracking_area_update_request->unavailability_information, pkbuf); 1534| 231| if (size < 0) { ------------------ | Branch (1534:17): [True: 6, False: 225] ------------------ 1535| 6| ogs_error("ogs_nas_eps_decode_unavailability_information() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1536| 6| return size; 1537| 6| } 1538| | 1539| 225| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_PRESENT; ------------------ | | 476| 225|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UNAVAILABILITY_INFORMATION_PRESENT ((uint64_t)1<<35) ------------------ 1540| 225| decoded += size; 1541| 225| break; 1542| 247| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE: ------------------ | | 514| 247|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_TYPE 0x26 ------------------ | Branch (1542:9): [True: 247, False: 33.6k] ------------------ 1543| 247| size = ogs_nas_eps_decode_plmn_identity(&tracking_area_update_request->ue_determined_plmn_with_disaster_condition, pkbuf); 1544| 247| if (size < 0) { ------------------ | Branch (1544:17): [True: 7, False: 240] ------------------ 1545| 7| ogs_error("ogs_nas_eps_decode_plmn_identity() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1546| 7| return size; 1547| 7| } 1548| | 1549| 240| tracking_area_update_request->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT; ------------------ | | 477| 240|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST_UE_DETERMINED_PLMN_WITH_DISASTER_CONDITION_PRESENT ((uint64_t)1<<36) ------------------ 1550| 240| decoded += size; 1551| 240| break; 1552| 12.3k| default: ------------------ | Branch (1552:9): [True: 12.3k, False: 21.5k] ------------------ 1553| 12.3k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 12.3k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12.3k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12.3k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12.3k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12.3k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12.3k| 0, __VA_ARGS__) | | ------------------ ------------------ 1554| 12.3k| break; 1555| 33.9k| } 1556| 33.9k| } 1557| | 1558| 467| return decoded; 1559| 672|} ogs_nas_eps_decode_tracking_area_update_accept: 1562| 794|{ 1563| 794| ogs_nas_eps_tracking_area_update_accept_t *tracking_area_update_accept = &message->emm.tracking_area_update_accept; 1564| 794| int decoded = 0; 1565| 794| int size = 0; 1566| | 1567| 794| ogs_trace("[NAS] Decode TRACKING_AREA_UPDATE_ACCEPT\n"); ------------------ | | 40| 794|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 794| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 794|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 794| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 794|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 794| 0, __VA_ARGS__) | | ------------------ ------------------ 1568| | 1569| 794| size = ogs_nas_eps_decode_eps_update_result(&tracking_area_update_accept->eps_update_result, pkbuf); 1570| 794| if (size < 0) { ------------------ | Branch (1570:9): [True: 0, False: 794] ------------------ 1571| 0| ogs_error("ogs_nas_eps_decode_eps_update_result() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1572| 0| return size; 1573| 0| } 1574| | 1575| 794| decoded += size; 1576| | 1577| 33.5k| while (pkbuf->len > 0) { ------------------ | Branch (1577:12): [True: 33.0k, False: 520] ------------------ 1578| 33.0k| uint8_t *buffer = pkbuf->data; 1579| 33.0k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (1579:24): [True: 9.47k, False: 23.5k] ------------------ 1580| | 1581| 33.0k| size = sizeof(uint8_t); 1582| 33.0k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1582:13): [True: 0, False: 33.0k] ------------------ 1583| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1584| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 1585| 0| } 1586| 33.0k| decoded += size; 1587| | 1588| 33.0k| switch (type) { 1589| 264| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_TYPE: ------------------ | | 606| 264|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_TYPE 0x5A ------------------ | Branch (1589:9): [True: 264, False: 32.7k] ------------------ 1590| 264| size = ogs_nas_eps_decode_gprs_timer(&tracking_area_update_accept->t3412_value, pkbuf); 1591| 264| if (size < 0) { ------------------ | Branch (1591:17): [True: 2, False: 262] ------------------ 1592| 2| ogs_error("ogs_nas_eps_decode_gprs_timer() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 1593| 2| return size; 1594| 2| } 1595| | 1596| 262| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_PRESENT; ------------------ | | 566| 262|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_VALUE_PRESENT ((uint64_t)1<<0) ------------------ 1597| 262| decoded += size; 1598| 262| break; 1599| 491| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_TYPE: ------------------ | | 607| 491|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_TYPE 0x50 ------------------ | Branch (1599:9): [True: 491, False: 32.5k] ------------------ 1600| 491| size = ogs_nas_eps_decode_eps_mobile_identity(&tracking_area_update_accept->guti, pkbuf); 1601| 491| if (size < 0) { ------------------ | Branch (1601:17): [True: 1, False: 490] ------------------ 1602| 1| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1603| 1| return size; 1604| 1| } 1605| | 1606| 490| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_PRESENT; ------------------ | | 567| 490|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_GUTI_PRESENT ((uint64_t)1<<1) ------------------ 1607| 490| decoded += size; 1608| 490| break; 1609| 269| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_TYPE: ------------------ | | 608| 269|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_TYPE 0x54 ------------------ | Branch (1609:9): [True: 269, False: 32.7k] ------------------ 1610| 269| size = ogs_nas_eps_decode_tracking_area_identity_list(&tracking_area_update_accept->tai_list, pkbuf); 1611| 269| if (size < 0) { ------------------ | Branch (1611:17): [True: 2, False: 267] ------------------ 1612| 2| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 1613| 2| return size; 1614| 2| } 1615| | 1616| 267| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_PRESENT; ------------------ | | 568| 267|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_TAI_LIST_PRESENT ((uint64_t)1<<2) ------------------ 1617| 267| decoded += size; 1618| 267| break; 1619| 494| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_TYPE: ------------------ | | 609| 494|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 ------------------ | Branch (1619:9): [True: 494, False: 32.5k] ------------------ 1620| 494| size = ogs_nas_eps_decode_eps_bearer_context_status(&tracking_area_update_accept->eps_bearer_context_status, pkbuf); 1621| 494| if (size < 0) { ------------------ | Branch (1621:17): [True: 15, False: 479] ------------------ 1622| 15| ogs_error("ogs_nas_eps_decode_eps_bearer_context_status() failed"); ------------------ | | 36| 15|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 15| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 15|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 15| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 15|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 15| 0, __VA_ARGS__) | | ------------------ ------------------ 1623| 15| return size; 1624| 15| } 1625| | 1626| 479| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_PRESENT; ------------------ | | 569| 479|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_BEARER_CONTEXT_STATUS_PRESENT ((uint64_t)1<<3) ------------------ 1627| 479| decoded += size; 1628| 479| break; 1629| 344| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE: ------------------ | | 610| 344|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_TYPE 0x13 ------------------ | Branch (1629:9): [True: 344, False: 32.7k] ------------------ 1630| 344| size = ogs_nas_eps_decode_location_area_identification(&tracking_area_update_accept->location_area_identification, pkbuf); 1631| 344| if (size < 0) { ------------------ | Branch (1631:17): [True: 10, False: 334] ------------------ 1632| 10| ogs_error("ogs_nas_eps_decode_location_area_identification() failed"); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 1633| 10| return size; 1634| 10| } 1635| | 1636| 334| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT; ------------------ | | 570| 334|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LOCATION_AREA_IDENTIFICATION_PRESENT ((uint64_t)1<<4) ------------------ 1637| 334| decoded += size; 1638| 334| break; 1639| 206| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_TYPE: ------------------ | | 611| 206|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_TYPE 0x23 ------------------ | Branch (1639:9): [True: 206, False: 32.8k] ------------------ 1640| 206| size = ogs_nas_eps_decode_mobile_identity(&tracking_area_update_accept->ms_identity, pkbuf); 1641| 206| if (size < 0) { ------------------ | Branch (1641:17): [True: 1, False: 205] ------------------ 1642| 1| ogs_error("ogs_nas_eps_decode_mobile_identity() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1643| 1| return size; 1644| 1| } 1645| | 1646| 205| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_PRESENT; ------------------ | | 571| 205|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MS_IDENTITY_PRESENT ((uint64_t)1<<5) ------------------ 1647| 205| decoded += size; 1648| 205| break; 1649| 497| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_TYPE: ------------------ | | 612| 497|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_TYPE 0x53 ------------------ | Branch (1649:9): [True: 497, False: 32.5k] ------------------ 1650| 497| size = ogs_nas_eps_decode_emm_cause(&tracking_area_update_accept->emm_cause, pkbuf); 1651| 497| if (size < 0) { ------------------ | Branch (1651:17): [True: 7, False: 490] ------------------ 1652| 7| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1653| 7| return size; 1654| 7| } 1655| | 1656| 490| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_PRESENT; ------------------ | | 572| 490|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMM_CAUSE_PRESENT ((uint64_t)1<<6) ------------------ 1657| 490| decoded += size; 1658| 490| break; 1659| 372| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_TYPE: ------------------ | | 613| 372|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_TYPE 0x17 ------------------ | Branch (1659:9): [True: 372, False: 32.6k] ------------------ 1660| 372| size = ogs_nas_eps_decode_gprs_timer(&tracking_area_update_accept->t3402_value, pkbuf); 1661| 372| if (size < 0) { ------------------ | Branch (1661:17): [True: 1, False: 371] ------------------ 1662| 1| ogs_error("ogs_nas_eps_decode_gprs_timer() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1663| 1| return size; 1664| 1| } 1665| | 1666| 371| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_PRESENT; ------------------ | | 573| 371|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3402_VALUE_PRESENT ((uint64_t)1<<7) ------------------ 1667| 371| decoded += size; 1668| 371| break; 1669| 340| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_TYPE: ------------------ | | 614| 340|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_TYPE 0x59 ------------------ | Branch (1669:9): [True: 340, False: 32.7k] ------------------ 1670| 340| size = ogs_nas_eps_decode_gprs_timer(&tracking_area_update_accept->t3423_value, pkbuf); 1671| 340| if (size < 0) { ------------------ | Branch (1671:17): [True: 5, False: 335] ------------------ 1672| 5| ogs_error("ogs_nas_eps_decode_gprs_timer() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 1673| 5| return size; 1674| 5| } 1675| | 1676| 335| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_PRESENT; ------------------ | | 574| 335|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3423_VALUE_PRESENT ((uint64_t)1<<8) ------------------ 1677| 335| decoded += size; 1678| 335| break; 1679| 494| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_TYPE: ------------------ | | 615| 494|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_TYPE 0x4A ------------------ | Branch (1679:9): [True: 494, False: 32.5k] ------------------ 1680| 494| size = ogs_nas_eps_decode_plmn_list(&tracking_area_update_accept->equivalent_plmns, pkbuf); 1681| 494| if (size < 0) { ------------------ | Branch (1681:17): [True: 17, False: 477] ------------------ 1682| 17| ogs_error("ogs_nas_eps_decode_plmn_list() failed"); ------------------ | | 36| 17|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 17| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 17|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 17| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 17|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 17| 0, __VA_ARGS__) | | ------------------ ------------------ 1683| 17| return size; 1684| 17| } 1685| | 1686| 477| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_PRESENT; ------------------ | | 575| 477|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EQUIVALENT_PLMNS_PRESENT ((uint64_t)1<<9) ------------------ 1687| 477| decoded += size; 1688| 477| break; 1689| 443| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 616| 443|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_TYPE 0x34 ------------------ | Branch (1689:9): [True: 443, False: 32.6k] ------------------ 1690| 443| size = ogs_nas_eps_decode_emergency_number_list(&tracking_area_update_accept->emergency_number_list, pkbuf); 1691| 443| if (size < 0) { ------------------ | Branch (1691:17): [True: 17, False: 426] ------------------ 1692| 17| ogs_error("ogs_nas_eps_decode_emergency_number_list() failed"); ------------------ | | 36| 17|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 17| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 17|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 17| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 17|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 17| 0, __VA_ARGS__) | | ------------------ ------------------ 1693| 17| return size; 1694| 17| } 1695| | 1696| 426| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 576| 426|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<10) ------------------ 1697| 426| decoded += size; 1698| 426| break; 1699| 421| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE: ------------------ | | 617| 421|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_TYPE 0x64 ------------------ | Branch (1699:9): [True: 421, False: 32.6k] ------------------ 1700| 421| size = ogs_nas_eps_decode_eps_network_feature_support(&tracking_area_update_accept->eps_network_feature_support, pkbuf); 1701| 421| if (size < 0) { ------------------ | Branch (1701:17): [True: 12, False: 409] ------------------ 1702| 12| ogs_error("ogs_nas_eps_decode_eps_network_feature_support() failed"); ------------------ | | 36| 12|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 1703| 12| return size; 1704| 12| } 1705| | 1706| 409| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT; ------------------ | | 577| 409|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_NETWORK_FEATURE_SUPPORT_PRESENT ((uint64_t)1<<11) ------------------ 1707| 409| decoded += size; 1708| 409| break; 1709| 3.75k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE: ------------------ | | 618| 3.75k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_TYPE 0xF0 ------------------ | Branch (1709:9): [True: 3.75k, False: 29.2k] ------------------ 1710| 3.75k| decoded--; 1711| 3.75k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 3.75k| do { \ | | 114| 3.75k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.75k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.75k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.75k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 3.75k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.75k] | | ------------------ ------------------ 1712| 3.75k| size = ogs_nas_eps_decode_additional_update_result(&tracking_area_update_accept->additional_update_result, pkbuf); 1713| 3.75k| if (size < 0) { ------------------ | Branch (1713:17): [True: 0, False: 3.75k] ------------------ 1714| 0| ogs_error("ogs_nas_eps_decode_additional_update_result() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1715| 0| return size; 1716| 0| } 1717| | 1718| 3.75k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT; ------------------ | | 578| 3.75k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ADDITIONAL_UPDATE_RESULT_PRESENT ((uint64_t)1<<12) ------------------ 1719| 3.75k| decoded += size; 1720| 3.75k| break; 1721| 218| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_TYPE: ------------------ | | 619| 218|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_TYPE 0x5E ------------------ | Branch (1721:9): [True: 218, False: 32.8k] ------------------ 1722| 218| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_accept->t3412_extended_value, pkbuf); 1723| 218| if (size < 0) { ------------------ | Branch (1723:17): [True: 6, False: 212] ------------------ 1724| 6| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1725| 6| return size; 1726| 6| } 1727| | 1728| 212| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_PRESENT; ------------------ | | 579| 212|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3412_EXTENDED_VALUE_PRESENT ((uint64_t)1<<13) ------------------ 1729| 212| decoded += size; 1730| 212| break; 1731| 221| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_TYPE: ------------------ | | 620| 221|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_TYPE 0x6A ------------------ | Branch (1731:9): [True: 221, False: 32.8k] ------------------ 1732| 221| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_accept->t3324_value, pkbuf); 1733| 221| if (size < 0) { ------------------ | Branch (1733:17): [True: 3, False: 218] ------------------ 1734| 3| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 1735| 3| return size; 1736| 3| } 1737| | 1738| 218| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_PRESENT; ------------------ | | 580| 218|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3324_VALUE_PRESENT ((uint64_t)1<<14) ------------------ 1739| 218| decoded += size; 1740| 218| break; 1741| 468| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE: ------------------ | | 621| 468|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_TYPE 0x6E ------------------ | Branch (1741:9): [True: 468, False: 32.5k] ------------------ 1742| 468| size = ogs_nas_eps_decode_extended_drx_parameters(&tracking_area_update_accept->extended_drx_parameters, pkbuf); 1743| 468| if (size < 0) { ------------------ | Branch (1743:17): [True: 10, False: 458] ------------------ 1744| 10| ogs_error("ogs_nas_eps_decode_extended_drx_parameters() failed"); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 1745| 10| return size; 1746| 10| } 1747| | 1748| 458| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT; ------------------ | | 581| 458|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_DRX_PARAMETERS_PRESENT ((uint64_t)1<<15) ------------------ 1749| 458| decoded += size; 1750| 458| break; 1751| 367| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_TYPE: ------------------ | | 622| 367|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_TYPE 0x68 ------------------ | Branch (1751:9): [True: 367, False: 32.6k] ------------------ 1752| 367| size = ogs_nas_eps_decode_header_compression_configuration_status(&tracking_area_update_accept->header_compression_configuration_status, pkbuf); 1753| 367| if (size < 0) { ------------------ | Branch (1753:17): [True: 11, False: 356] ------------------ 1754| 11| ogs_error("ogs_nas_eps_decode_header_compression_configuration_status() failed"); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 1755| 11| return size; 1756| 11| } 1757| | 1758| 356| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_PRESENT; ------------------ | | 582| 356|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_HEADER_COMPRESSION_CONFIGURATION_STATUS_PRESENT ((uint64_t)1<<16) ------------------ 1759| 356| decoded += size; 1760| 356| break; 1761| 262| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_TYPE: ------------------ | | 623| 262|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_TYPE 0x65 ------------------ | Branch (1761:9): [True: 262, False: 32.7k] ------------------ 1762| 262| size = ogs_nas_eps_decode_dcn_id(&tracking_area_update_accept->dcn_id, pkbuf); 1763| 262| if (size < 0) { ------------------ | Branch (1763:17): [True: 9, False: 253] ------------------ 1764| 9| ogs_error("ogs_nas_eps_decode_dcn_id() failed"); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1765| 9| return size; 1766| 9| } 1767| | 1768| 253| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_PRESENT; ------------------ | | 583| 253|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DCN_ID_PRESENT ((uint64_t)1<<17) ------------------ 1769| 253| decoded += size; 1770| 253| break; 1771| 1.24k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_TYPE: ------------------ | | 624| 1.24k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_TYPE 0xE0 ------------------ | Branch (1771:9): [True: 1.24k, False: 31.8k] ------------------ 1772| 1.24k| decoded--; 1773| 1.24k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 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, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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] | | ------------------ ------------------ 1774| 1.24k| size = ogs_nas_eps_decode_sms_services_status(&tracking_area_update_accept->sms_services_status, pkbuf); 1775| 1.24k| if (size < 0) { ------------------ | Branch (1775:17): [True: 0, False: 1.24k] ------------------ 1776| 0| ogs_error("ogs_nas_eps_decode_sms_services_status() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1777| 0| return size; 1778| 0| } 1779| | 1780| 1.24k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_PRESENT; ------------------ | | 584| 1.24k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_SMS_SERVICES_STATUS_PRESENT ((uint64_t)1<<18) ------------------ 1781| 1.24k| decoded += size; 1782| 1.24k| break; 1783| 1.20k| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_TYPE: ------------------ | | 625| 1.20k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_TYPE 0xD0 ------------------ | Branch (1783:9): [True: 1.20k, False: 31.8k] ------------------ 1784| 1.20k| decoded--; 1785| 1.20k| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 1.20k| do { \ | | 114| 1.20k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 1.20k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 1.20k, False: 0] | | | | ------------------ | | ------------------ | | 115| 1.20k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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.20k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 1.20k] | | ------------------ ------------------ 1786| 1.20k| size = ogs_nas_eps_decode_non_nw_provided_policies(&tracking_area_update_accept->non_nw_policies, pkbuf); 1787| 1.20k| if (size < 0) { ------------------ | Branch (1787:17): [True: 0, False: 1.20k] ------------------ 1788| 0| ogs_error("ogs_nas_eps_decode_non_nw_provided_policies() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1789| 0| return size; 1790| 0| } 1791| | 1792| 1.20k| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_PRESENT; ------------------ | | 585| 1.20k|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NON__NW_POLICIES_PRESENT ((uint64_t)1<<19) ------------------ 1793| 1.20k| decoded += size; 1794| 1.20k| break; 1795| 227| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_TYPE: ------------------ | | 626| 227|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_TYPE 0x6B ------------------ | Branch (1795:9): [True: 227, False: 32.8k] ------------------ 1796| 227| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_accept->t3448_value, pkbuf); 1797| 227| if (size < 0) { ------------------ | Branch (1797:17): [True: 8, False: 219] ------------------ 1798| 8| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1799| 8| return size; 1800| 8| } 1801| | 1802| 219| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_PRESENT; ------------------ | | 586| 219|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3448_VALUE_PRESENT ((uint64_t)1<<20) ------------------ 1803| 219| decoded += size; 1804| 219| break; 1805| 784| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_TYPE: ------------------ | | 627| 784|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_TYPE 0xC0 ------------------ | Branch (1805:9): [True: 784, False: 32.2k] ------------------ 1806| 784| decoded--; 1807| 784| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 784| do { \ | | 114| 784| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 784|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 784, False: 0] | | | | ------------------ | | ------------------ | | 115| 784| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 784| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 784] | | ------------------ ------------------ 1808| 784| size = ogs_nas_eps_decode_network_policy(&tracking_area_update_accept->network_policy, pkbuf); 1809| 784| if (size < 0) { ------------------ | Branch (1809:17): [True: 0, False: 784] ------------------ 1810| 0| ogs_error("ogs_nas_eps_decode_network_policy() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1811| 0| return size; 1812| 0| } 1813| | 1814| 784| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_PRESENT; ------------------ | | 587| 784|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NETWORK_POLICY_PRESENT ((uint64_t)1<<21) ------------------ 1815| 784| decoded += size; 1816| 784| break; 1817| 369| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_TYPE: ------------------ | | 628| 369|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_TYPE 0x6C ------------------ | Branch (1817:9): [True: 369, False: 32.6k] ------------------ 1818| 369| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_accept->t3447_value, pkbuf); 1819| 369| if (size < 0) { ------------------ | Branch (1819:17): [True: 5, False: 364] ------------------ 1820| 5| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 1821| 5| return size; 1822| 5| } 1823| | 1824| 364| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_PRESENT; ------------------ | | 588| 364|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_T3447_VALUE_PRESENT ((uint64_t)1<<22) ------------------ 1825| 364| decoded += size; 1826| 364| break; 1827| 305| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE: ------------------ | | 629| 305|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_TYPE 0x7A ------------------ | Branch (1827:9): [True: 305, False: 32.7k] ------------------ 1828| 305| size = ogs_nas_eps_decode_extended_emergency_number_list(&tracking_area_update_accept->extended_emergency_number_list, pkbuf); 1829| 305| if (size < 0) { ------------------ | Branch (1829:17): [True: 29, False: 276] ------------------ 1830| 29| ogs_error("ogs_nas_eps_decode_extended_emergency_number_list() failed"); ------------------ | | 36| 29|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 29| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 29|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 29| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 29|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 29| 0, __VA_ARGS__) | | ------------------ ------------------ 1831| 29| return size; 1832| 29| } 1833| | 1834| 276| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT; ------------------ | | 589| 276|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EXTENDED_EMERGENCY_NUMBER_LIST_PRESENT ((uint64_t)1<<23) ------------------ 1835| 276| decoded += size; 1836| 276| break; 1837| 471| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_TYPE: ------------------ | | 630| 471|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_TYPE 0x7C ------------------ | Branch (1837:9): [True: 471, False: 32.5k] ------------------ 1838| 471| size = ogs_nas_eps_decode_ciphering_key_data(&tracking_area_update_accept->ciphering_key_data, pkbuf); 1839| 471| if (size < 0) { ------------------ | Branch (1839:17): [True: 35, False: 436] ------------------ 1840| 35| ogs_error("ogs_nas_eps_decode_ciphering_key_data() failed"); ------------------ | | 36| 35|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 35| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 35|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 35| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 35|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 35| 0, __VA_ARGS__) | | ------------------ ------------------ 1841| 35| return size; 1842| 35| } 1843| | 1844| 436| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_PRESENT; ------------------ | | 590| 436|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_CIPHERING_KEY_DATA_PRESENT ((uint64_t)1<<24) ------------------ 1845| 436| decoded += size; 1846| 436| break; 1847| 211| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 631| 211|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (1847:9): [True: 211, False: 32.8k] ------------------ 1848| 211| size = ogs_nas_eps_decode_ue_radio_capability_id(&tracking_area_update_accept->ue_radio_capability_id, pkbuf); 1849| 211| if (size < 0) { ------------------ | Branch (1849:17): [True: 3, False: 208] ------------------ 1850| 3| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 1851| 3| return size; 1852| 3| } 1853| | 1854| 208| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 591| 208|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<25) ------------------ 1855| 208| decoded += size; 1856| 208| break; 1857| 777| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE: ------------------ | | 632| 777|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE 0xB0 ------------------ | Branch (1857:9): [True: 777, False: 32.2k] ------------------ 1858| 777| decoded--; 1859| 777| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 777| do { \ | | 114| 777| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 777|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 777, False: 0] | | | | ------------------ | | ------------------ | | 115| 777| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 777| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 777] | | ------------------ ------------------ 1860| 777| size = ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication(&tracking_area_update_accept->ue_radio_capability_id_deletion_indication, pkbuf); 1861| 777| if (size < 0) { ------------------ | Branch (1861:17): [True: 0, False: 777] ------------------ 1862| 0| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1863| 0| return size; 1864| 0| } 1865| | 1866| 777| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT; ------------------ | | 592| 777|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT ((uint64_t)1<<26) ------------------ 1867| 777| decoded += size; 1868| 777| break; 1869| 250| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE: ------------------ | | 633| 250|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_TYPE 0x35 ------------------ | Branch (1869:9): [True: 250, False: 32.7k] ------------------ 1870| 250| size = ogs_nas_eps_decode_wus_assistance_information(&tracking_area_update_accept->negotiated_wus_assistance_information, pkbuf); 1871| 250| if (size < 0) { ------------------ | Branch (1871:17): [True: 6, False: 244] ------------------ 1872| 6| ogs_error("ogs_nas_eps_decode_wus_assistance_information() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1873| 6| return size; 1874| 6| } 1875| | 1876| 244| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT; ------------------ | | 593| 244|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_WUS_ASSISTANCE_INFORMATION_PRESENT ((uint64_t)1<<27) ------------------ 1877| 244| decoded += size; 1878| 244| break; 1879| 362| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE: ------------------ | | 634| 362|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_TYPE 0x36 ------------------ | Branch (1879:9): [True: 362, False: 32.6k] ------------------ 1880| 362| size = ogs_nas_eps_decode_nb_s1_drx_parameter(&tracking_area_update_accept->negotiated_drx_parameter_in_nb_s1_mode, pkbuf); 1881| 362| if (size < 0) { ------------------ | Branch (1881:17): [True: 8, False: 354] ------------------ 1882| 8| ogs_error("ogs_nas_eps_decode_nb_s1_drx_parameter() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1883| 8| return size; 1884| 8| } 1885| | 1886| 354| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT; ------------------ | | 594| 354|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_DRX_PARAMETER_IN_NB_S1_MODE_PRESENT ((uint64_t)1<<28) ------------------ 1887| 354| decoded += size; 1888| 354| break; 1889| 242| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE: ------------------ | | 635| 242|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_TYPE 0x38 ------------------ | Branch (1889:9): [True: 242, False: 32.8k] ------------------ 1890| 242| size = ogs_nas_eps_decode_imsi_offset(&tracking_area_update_accept->negotiated_imsi_offset, pkbuf); 1891| 242| if (size < 0) { ------------------ | Branch (1891:17): [True: 8, False: 234] ------------------ 1892| 8| ogs_error("ogs_nas_eps_decode_imsi_offset() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1893| 8| return size; 1894| 8| } 1895| | 1896| 234| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT; ------------------ | | 595| 234|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_NEGOTIATED_IMSI_OFFSET_PRESENT ((uint64_t)1<<29) ------------------ 1897| 234| decoded += size; 1898| 234| break; 1899| 354| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_TYPE: ------------------ | | 636| 354|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_TYPE 0x37 ------------------ | Branch (1899:9): [True: 354, False: 32.6k] ------------------ 1900| 354| size = ogs_nas_eps_decode_eps_additional_request_result(&tracking_area_update_accept->eps_additional_request_result, pkbuf); 1901| 354| if (size < 0) { ------------------ | Branch (1901:17): [True: 8, False: 346] ------------------ 1902| 8| ogs_error("ogs_nas_eps_decode_eps_additional_request_result() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1903| 8| return size; 1904| 8| } 1905| | 1906| 346| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_PRESENT; ------------------ | | 596| 346|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_EPS_ADDITIONAL_REQUEST_RESULT_PRESENT ((uint64_t)1<<30) ------------------ 1907| 346| decoded += size; 1908| 346| break; 1909| 200| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 637| 200|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (1909:9): [True: 200, False: 32.8k] ------------------ 1910| 200| size = ogs_nas_eps_decode_tracking_area_identity_list(&tracking_area_update_accept->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 1911| 200| if (size < 0) { ------------------ | Branch (1911:17): [True: 1, False: 199] ------------------ 1912| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1913| 1| return size; 1914| 1| } 1915| | 1916| 199| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 597| 199|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<31) ------------------ 1917| 199| decoded += size; 1918| 199| break; 1919| 214| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 638| 214|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE 0x1E ------------------ | Branch (1919:9): [True: 214, False: 32.8k] ------------------ 1920| 214| size = ogs_nas_eps_decode_tracking_area_identity_list(&tracking_area_update_accept->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf); 1921| 214| if (size < 0) { ------------------ | Branch (1921:17): [True: 1, False: 213] ------------------ 1922| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1923| 1| return size; 1924| 1| } 1925| | 1926| 213| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 598| 213|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT ((uint64_t)1<<32) ------------------ 1927| 213| decoded += size; 1928| 213| break; 1929| 218| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_TYPE: ------------------ | | 639| 218|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_TYPE 0x39 ------------------ | Branch (1929:9): [True: 218, False: 32.8k] ------------------ 1930| 218| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_accept->maximum_time_offset, pkbuf); 1931| 218| if (size < 0) { ------------------ | Branch (1931:17): [True: 1, False: 217] ------------------ 1932| 1| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1933| 1| return size; 1934| 1| } 1935| | 1936| 217| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_PRESENT; ------------------ | | 599| 217|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_MAXIMUM_TIME_OFFSET_PRESENT ((uint64_t)1<<33) ------------------ 1937| 217| decoded += size; 1938| 217| break; 1939| 249| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE: ------------------ | | 640| 249|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_TYPE 0x1F ------------------ | Branch (1939:9): [True: 249, False: 32.8k] ------------------ 1940| 249| size = ogs_nas_eps_decode_unavailability_configuration(&tracking_area_update_accept->unavailability_configuration, pkbuf); 1941| 249| if (size < 0) { ------------------ | Branch (1941:17): [True: 9, False: 240] ------------------ 1942| 9| ogs_error("ogs_nas_eps_decode_unavailability_configuration() failed"); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1943| 9| return size; 1944| 9| } 1945| | 1946| 240| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT; ------------------ | | 600| 240|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_UNAVAILABILITY_CONFIGURATION_PRESENT ((uint64_t)1<<34) ------------------ 1947| 240| decoded += size; 1948| 240| break; 1949| 488| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 641| 488|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (1949:9): [True: 488, False: 32.5k] ------------------ 1950| 488| size = ogs_nas_eps_decode_access_technology_utilization_control(&tracking_area_update_accept->access_technology_utilization_control, pkbuf); 1951| 488| if (size < 0) { ------------------ | Branch (1951:17): [True: 1, False: 487] ------------------ 1952| 1| ogs_error("ogs_nas_eps_decode_access_technology_utilization_control() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1953| 1| return size; 1954| 1| } 1955| | 1956| 487| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 601| 487|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<35) ------------------ 1957| 487| decoded += size; 1958| 487| break; 1959| 216| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 642| 216|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (1959:9): [True: 216, False: 32.8k] ------------------ 1960| 216| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&tracking_area_update_accept->s_f_satellite_operation_parameters, pkbuf); 1961| 216| if (size < 0) { ------------------ | Branch (1961:17): [True: 3, False: 213] ------------------ 1962| 3| ogs_error("ogs_nas_eps_decode_s_f_satellite_operation_parameters() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 1963| 3| return size; 1964| 3| } 1965| | 1966| 213| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 602| 213|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<36) ------------------ 1967| 213| decoded += size; 1968| 213| break; 1969| 219| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE: ------------------ | | 643| 219|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_TYPE 0x22 ------------------ | Branch (1969:9): [True: 219, False: 32.8k] ------------------ 1970| 219| size = ogs_nas_eps_decode_registration_wait_range(&tracking_area_update_accept->disaster_roaming_wait_range, pkbuf); 1971| 219| if (size < 0) { ------------------ | Branch (1971:17): [True: 5, False: 214] ------------------ 1972| 5| ogs_error("ogs_nas_eps_decode_registration_wait_range() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 1973| 5| return size; 1974| 5| } 1975| | 1976| 214| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT; ------------------ | | 603| 214|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_ROAMING_WAIT_RANGE_PRESENT ((uint64_t)1<<37) ------------------ 1977| 214| decoded += size; 1978| 214| break; 1979| 231| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 644| 231|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (1979:9): [True: 231, False: 32.8k] ------------------ 1980| 231| size = ogs_nas_eps_decode_registration_wait_range(&tracking_area_update_accept->disaster_return_wait_range, pkbuf); 1981| 231| if (size < 0) { ------------------ | Branch (1981:17): [True: 4, False: 227] ------------------ 1982| 4| ogs_error("ogs_nas_eps_decode_registration_wait_range() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 1983| 4| return size; 1984| 4| } 1985| | 1986| 227| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 604| 227|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<38) ------------------ 1987| 227| decoded += size; 1988| 227| break; 1989| 246| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE: ------------------ | | 645| 246|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_TYPE 0x25 ------------------ | Branch (1989:9): [True: 246, False: 32.8k] ------------------ 1990| 246| size = ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition(&tracking_area_update_accept->list_of_plmns_to_be_used_in_disaster_condition, pkbuf); 1991| 246| if (size < 0) { ------------------ | Branch (1991:17): [True: 10, False: 236] ------------------ 1992| 10| ogs_error("ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition() failed"); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 1993| 10| return size; 1994| 10| } 1995| | 1996| 236| tracking_area_update_accept->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT; ------------------ | | 605| 236|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT_LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION_PRESENT ((uint64_t)1<<39) ------------------ 1997| 236| decoded += size; 1998| 236| break; 1999| 14.0k| default: ------------------ | Branch (1999:9): [True: 14.0k, False: 19.0k] ------------------ 2000| 14.0k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 14.0k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 14.0k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 14.0k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 14.0k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 14.0k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 14.0k| 0, __VA_ARGS__) | | ------------------ ------------------ 2001| 14.0k| break; 2002| 33.0k| } 2003| 33.0k| } 2004| | 2005| 520| return decoded; 2006| 794|} ogs_nas_eps_decode_tracking_area_update_reject: 2009| 135|{ 2010| 135| ogs_nas_eps_tracking_area_update_reject_t *tracking_area_update_reject = &message->emm.tracking_area_update_reject; 2011| 135| int decoded = 0; 2012| 135| int size = 0; 2013| | 2014| 135| ogs_trace("[NAS] Decode TRACKING_AREA_UPDATE_REJECT\n"); ------------------ | | 40| 135|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 135| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 135|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 135| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 135|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 135| 0, __VA_ARGS__) | | ------------------ ------------------ 2015| | 2016| 135| size = ogs_nas_eps_decode_emm_cause(&tracking_area_update_reject->emm_cause, pkbuf); 2017| 135| if (size < 0) { ------------------ | Branch (2017:9): [True: 0, False: 135] ------------------ 2018| 0| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2019| 0| return size; 2020| 0| } 2021| | 2022| 135| decoded += size; 2023| | 2024| 7.28k| while (pkbuf->len > 0) { ------------------ | Branch (2024:12): [True: 7.17k, False: 115] ------------------ 2025| 7.17k| uint8_t *buffer = pkbuf->data; 2026| 7.17k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2026:24): [True: 2.26k, False: 4.91k] ------------------ 2027| | 2028| 7.17k| size = sizeof(uint8_t); 2029| 7.17k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2029:13): [True: 0, False: 7.17k] ------------------ 2030| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2031| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2032| 0| } 2033| 7.17k| decoded += size; 2034| | 2035| 7.17k| switch (type) { 2036| 243| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_TYPE: ------------------ | | 707| 243|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_TYPE 0x5F ------------------ | Branch (2036:9): [True: 243, False: 6.93k] ------------------ 2037| 243| size = ogs_nas_eps_decode_gprs_timer_2(&tracking_area_update_reject->t3346_value, pkbuf); 2038| 243| if (size < 0) { ------------------ | Branch (2038:17): [True: 4, False: 239] ------------------ 2039| 4| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2040| 4| return size; 2041| 4| } 2042| | 2043| 239| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_PRESENT; ------------------ | | 699| 239|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_T3346_VALUE_PRESENT ((uint64_t)1<<0) ------------------ 2044| 239| decoded += size; 2045| 239| break; 2046| 716| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_TYPE: ------------------ | | 708| 716|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_TYPE 0xA0 ------------------ | Branch (2046:9): [True: 716, False: 6.45k] ------------------ 2047| 716| decoded--; 2048| 716| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 716| do { \ | | 114| 716| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 716|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 716, False: 0] | | | | ------------------ | | ------------------ | | 115| 716| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 716| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 716] | | ------------------ ------------------ 2049| 716| size = ogs_nas_eps_decode_extended_emm_cause(&tracking_area_update_reject->extended_emm_cause, pkbuf); 2050| 716| if (size < 0) { ------------------ | Branch (2050:17): [True: 0, False: 716] ------------------ 2051| 0| ogs_error("ogs_nas_eps_decode_extended_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2052| 0| return size; 2053| 0| } 2054| | 2055| 716| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_PRESENT; ------------------ | | 700| 716|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_EXTENDED_EMM_CAUSE_PRESENT ((uint64_t)1<<1) ------------------ 2056| 716| decoded += size; 2057| 716| break; 2058| 236| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE: ------------------ | | 709| 236|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE 0x1C ------------------ | Branch (2058:9): [True: 236, False: 6.93k] ------------------ 2059| 236| size = ogs_nas_eps_decode_gprs_timer_3(&tracking_area_update_reject->lower_bound_timer_value, pkbuf); 2060| 236| if (size < 0) { ------------------ | Branch (2060:17): [True: 3, False: 233] ------------------ 2061| 3| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 2062| 3| return size; 2063| 3| } 2064| | 2065| 233| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT; ------------------ | | 701| 233|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT ((uint64_t)1<<2) ------------------ 2066| 233| decoded += size; 2067| 233| break; 2068| 216| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 710| 216|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (2068:9): [True: 216, False: 6.95k] ------------------ 2069| 216| size = ogs_nas_eps_decode_tracking_area_identity_list(&tracking_area_update_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 2070| 216| if (size < 0) { ------------------ | Branch (2070:17): [True: 2, False: 214] ------------------ 2071| 2| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2072| 2| return size; 2073| 2| } 2074| | 2075| 214| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 702| 214|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<3) ------------------ 2076| 214| decoded += size; 2077| 214| break; 2078| 220| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 711| 220|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE 0x1E ------------------ | Branch (2078:9): [True: 220, False: 6.95k] ------------------ 2079| 220| size = ogs_nas_eps_decode_tracking_area_identity_list(&tracking_area_update_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf); 2080| 220| if (size < 0) { ------------------ | Branch (2080:17): [True: 1, False: 219] ------------------ 2081| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2082| 1| return size; 2083| 1| } 2084| | 2085| 219| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 703| 219|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT ((uint64_t)1<<4) ------------------ 2086| 219| decoded += size; 2087| 219| break; 2088| 211| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 712| 211|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (2088:9): [True: 211, False: 6.96k] ------------------ 2089| 211| size = ogs_nas_eps_decode_access_technology_utilization_control(&tracking_area_update_reject->access_technology_utilization_control, pkbuf); 2090| 211| if (size < 0) { ------------------ | Branch (2090:17): [True: 4, False: 207] ------------------ 2091| 4| ogs_error("ogs_nas_eps_decode_access_technology_utilization_control() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2092| 4| return size; 2093| 4| } 2094| | 2095| 207| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 704| 207|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<5) ------------------ 2096| 207| decoded += size; 2097| 207| break; 2098| 267| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 713| 267|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (2098:9): [True: 267, False: 6.90k] ------------------ 2099| 267| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&tracking_area_update_reject->s_f_satellite_operation_parameters, pkbuf); 2100| 267| if (size < 0) { ------------------ | Branch (2100:17): [True: 4, False: 263] ------------------ 2101| 4| ogs_error("ogs_nas_eps_decode_s_f_satellite_operation_parameters() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2102| 4| return size; 2103| 4| } 2104| | 2105| 263| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 705| 263|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<6) ------------------ 2106| 263| decoded += size; 2107| 263| break; 2108| 207| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 714| 207|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (2108:9): [True: 207, False: 6.96k] ------------------ 2109| 207| size = ogs_nas_eps_decode_registration_wait_range(&tracking_area_update_reject->disaster_return_wait_range, pkbuf); 2110| 207| if (size < 0) { ------------------ | Branch (2110:17): [True: 2, False: 205] ------------------ 2111| 2| ogs_error("ogs_nas_eps_decode_registration_wait_range() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2112| 2| return size; 2113| 2| } 2114| | 2115| 205| tracking_area_update_reject->presencemask |= OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 706| 205|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<7) ------------------ 2116| 205| decoded += size; 2117| 205| break; 2118| 4.85k| default: ------------------ | Branch (2118:9): [True: 4.85k, False: 2.31k] ------------------ 2119| 4.85k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 4.85k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4.85k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4.85k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4.85k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4.85k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4.85k| 0, __VA_ARGS__) | | ------------------ ------------------ 2120| 4.85k| break; 2121| 7.17k| } 2122| 7.17k| } 2123| | 2124| 115| return decoded; 2125| 135|} ogs_nas_eps_decode_extended_service_request: 2128| 120|{ 2129| 120| ogs_nas_eps_extended_service_request_t *extended_service_request = &message->emm.extended_service_request; 2130| 120| int decoded = 0; 2131| 120| int size = 0; 2132| | 2133| 120| ogs_trace("[NAS] Decode EXTENDED_SERVICE_REQUEST\n"); ------------------ | | 40| 120|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 120| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 120|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 120| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 120|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 120| 0, __VA_ARGS__) | | ------------------ ------------------ 2134| | 2135| 120| size = ogs_nas_eps_decode_service_type(&extended_service_request->service_type, pkbuf); 2136| 120| if (size < 0) { ------------------ | Branch (2136:9): [True: 0, False: 120] ------------------ 2137| 0| ogs_error("ogs_nas_eps_decode_service_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2138| 0| return size; 2139| 0| } 2140| | 2141| 120| decoded += size; 2142| | 2143| 120| size = ogs_nas_eps_decode_mobile_identity(&extended_service_request->m_tmsi, pkbuf); 2144| 120| if (size < 0) { ------------------ | Branch (2144:9): [True: 6, False: 114] ------------------ 2145| 6| ogs_error("ogs_nas_eps_decode_mobile_identity() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2146| 6| return size; 2147| 6| } 2148| | 2149| 114| decoded += size; 2150| | 2151| 10.5k| while (pkbuf->len > 0) { ------------------ | Branch (2151:12): [True: 10.4k, False: 97] ------------------ 2152| 10.4k| uint8_t *buffer = pkbuf->data; 2153| 10.4k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2153:24): [True: 5.01k, False: 5.43k] ------------------ 2154| | 2155| 10.4k| size = sizeof(uint8_t); 2156| 10.4k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2156:13): [True: 0, False: 10.4k] ------------------ 2157| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2158| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2159| 0| } 2160| 10.4k| decoded += size; 2161| | 2162| 10.4k| switch (type) { 2163| 739| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_TYPE: ------------------ | | 741| 739|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_TYPE 0xB0 ------------------ | Branch (2163:9): [True: 739, False: 9.71k] ------------------ 2164| 739| decoded--; 2165| 739| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 739| do { \ | | 114| 739| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 739|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 739, False: 0] | | | | ------------------ | | ------------------ | | 115| 739| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 739| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 739] | | ------------------ ------------------ 2166| 739| size = ogs_nas_eps_decode_csfb_response(&extended_service_request->csfb_response, pkbuf); 2167| 739| if (size < 0) { ------------------ | Branch (2167:17): [True: 0, False: 739] ------------------ 2168| 0| ogs_error("ogs_nas_eps_decode_csfb_response() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2169| 0| return size; 2170| 0| } 2171| | 2172| 739| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_PRESENT; ------------------ | | 736| 739|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_CSFB_RESPONSE_PRESENT ((uint64_t)1<<0) ------------------ 2173| 739| decoded += size; 2174| 739| break; 2175| 201| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE: ------------------ | | 742| 201|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_TYPE 0x57 ------------------ | Branch (2175:9): [True: 201, False: 10.2k] ------------------ 2176| 201| size = ogs_nas_eps_decode_eps_bearer_context_status(&extended_service_request->eps_bearer_context_status, pkbuf); 2177| 201| if (size < 0) { ------------------ | Branch (2177:17): [True: 4, False: 197] ------------------ 2178| 4| ogs_error("ogs_nas_eps_decode_eps_bearer_context_status() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2179| 4| return size; 2180| 4| } 2181| | 2182| 197| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT; ------------------ | | 737| 197|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_EPS_BEARER_CONTEXT_STATUS_PRESENT ((uint64_t)1<<1) ------------------ 2183| 197| decoded += size; 2184| 197| break; 2185| 908| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_TYPE: ------------------ | | 743| 908|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_TYPE 0xD0 ------------------ | Branch (2185:9): [True: 908, False: 9.55k] ------------------ 2186| 908| decoded--; 2187| 908| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 908| do { \ | | 114| 908| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 908|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 908, False: 0] | | | | ------------------ | | ------------------ | | 115| 908| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 908| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 908] | | ------------------ ------------------ 2188| 908| size = ogs_nas_eps_decode_device_properties(&extended_service_request->device_properties, pkbuf); 2189| 908| if (size < 0) { ------------------ | Branch (2189:17): [True: 0, False: 908] ------------------ 2190| 0| ogs_error("ogs_nas_eps_decode_device_properties() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2191| 0| return size; 2192| 0| } 2193| | 2194| 908| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_PRESENT; ------------------ | | 738| 908|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_DEVICE_PROPERTIES_PRESENT ((uint64_t)1<<2) ------------------ 2195| 908| decoded += size; 2196| 908| break; 2197| 287| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_TYPE: ------------------ | | 744| 287|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_TYPE 0x29 ------------------ | Branch (2197:9): [True: 287, False: 10.1k] ------------------ 2198| 287| size = ogs_nas_eps_decode_ue_request_type(&extended_service_request->ue_request_type, pkbuf); 2199| 287| if (size < 0) { ------------------ | Branch (2199:17): [True: 6, False: 281] ------------------ 2200| 6| ogs_error("ogs_nas_eps_decode_ue_request_type() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2201| 6| return size; 2202| 6| } 2203| | 2204| 281| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_PRESENT; ------------------ | | 739| 281|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_UE_REQUEST_TYPE_PRESENT ((uint64_t)1<<3) ------------------ 2205| 281| decoded += size; 2206| 281| break; 2207| 357| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_TYPE: ------------------ | | 745| 357|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_TYPE 0x28 ------------------ | Branch (2207:9): [True: 357, False: 10.1k] ------------------ 2208| 357| size = ogs_nas_eps_decode_paging_restriction(&extended_service_request->paging_restriction, pkbuf); 2209| 357| if (size < 0) { ------------------ | Branch (2209:17): [True: 7, False: 350] ------------------ 2210| 7| ogs_error("ogs_nas_eps_decode_paging_restriction() failed"); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 2211| 7| return size; 2212| 7| } 2213| | 2214| 350| extended_service_request->presencemask |= OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_PRESENT; ------------------ | | 740| 350|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST_PAGING_RESTRICTION_PRESENT ((uint64_t)1<<4) ------------------ 2215| 350| decoded += size; 2216| 350| break; 2217| 7.96k| default: ------------------ | Branch (2217:9): [True: 7.96k, False: 2.49k] ------------------ 2218| 7.96k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 7.96k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7.96k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7.96k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7.96k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7.96k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7.96k| 0, __VA_ARGS__) | | ------------------ ------------------ 2219| 7.96k| break; 2220| 10.4k| } 2221| 10.4k| } 2222| | 2223| 97| return decoded; 2224| 114|} ogs_nas_eps_decode_service_request: 2227| 12|{ 2228| 12| ogs_nas_eps_service_request_t *service_request = &message->emm.service_request; 2229| 12| int decoded = 0; 2230| 12| int size = 0; 2231| | 2232| 12| ogs_trace("[NAS] Decode SERVICE_REQUEST\n"); ------------------ | | 40| 12|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 2233| | 2234| 12| size = ogs_nas_eps_decode_ksi_and_sequence_number(&service_request->ksi_and_sequence_number, pkbuf); 2235| 12| if (size < 0) { ------------------ | Branch (2235:9): [True: 0, False: 12] ------------------ 2236| 0| ogs_error("ogs_nas_eps_decode_ksi_and_sequence_number() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2237| 0| return size; 2238| 0| } 2239| | 2240| 12| decoded += size; 2241| | 2242| 12| size = ogs_nas_eps_decode_short_mac(&service_request->message_authentication_code, pkbuf); 2243| 12| if (size < 0) { ------------------ | Branch (2243:9): [True: 0, False: 12] ------------------ 2244| 0| ogs_error("ogs_nas_eps_decode_short_mac() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2245| 0| return size; 2246| 0| } 2247| | 2248| 12| decoded += size; 2249| | 2250| 12| return decoded; 2251| 12|} ogs_nas_eps_decode_service_reject: 2254| 130|{ 2255| 130| ogs_nas_eps_service_reject_t *service_reject = &message->emm.service_reject; 2256| 130| int decoded = 0; 2257| 130| int size = 0; 2258| | 2259| 130| ogs_trace("[NAS] Decode SERVICE_REJECT\n"); ------------------ | | 40| 130|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 130| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 130|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 130| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 130|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 130| 0, __VA_ARGS__) | | ------------------ ------------------ 2260| | 2261| 130| size = ogs_nas_eps_decode_emm_cause(&service_reject->emm_cause, pkbuf); 2262| 130| if (size < 0) { ------------------ | Branch (2262:9): [True: 0, False: 130] ------------------ 2263| 0| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2264| 0| return size; 2265| 0| } 2266| | 2267| 130| decoded += size; 2268| | 2269| 5.61k| while (pkbuf->len > 0) { ------------------ | Branch (2269:12): [True: 5.51k, False: 107] ------------------ 2270| 5.51k| uint8_t *buffer = pkbuf->data; 2271| 5.51k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2271:24): [True: 1.52k, False: 3.98k] ------------------ 2272| | 2273| 5.51k| size = sizeof(uint8_t); 2274| 5.51k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2274:13): [True: 0, False: 5.51k] ------------------ 2275| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2276| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2277| 0| } 2278| 5.51k| decoded += size; 2279| | 2280| 5.51k| switch (type) { 2281| 205| case OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_TYPE: ------------------ | | 785| 205|#define OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_TYPE 0x5B ------------------ | Branch (2281:9): [True: 205, False: 5.30k] ------------------ 2282| 205| size = ogs_nas_eps_decode_gprs_timer(&service_reject->t3442_value, pkbuf); 2283| 205| if (size < 0) { ------------------ | Branch (2283:17): [True: 2, False: 203] ------------------ 2284| 2| ogs_error("ogs_nas_eps_decode_gprs_timer() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2285| 2| return size; 2286| 2| } 2287| | 2288| 203| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_PRESENT; ------------------ | | 776| 203|#define OGS_NAS_EPS_SERVICE_REJECT_T3442_VALUE_PRESENT ((uint64_t)1<<0) ------------------ 2289| 203| decoded += size; 2290| 203| break; 2291| 235| case OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_TYPE: ------------------ | | 786| 235|#define OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_TYPE 0x5F ------------------ | Branch (2291:9): [True: 235, False: 5.27k] ------------------ 2292| 235| size = ogs_nas_eps_decode_gprs_timer_2(&service_reject->t3346_value, pkbuf); 2293| 235| if (size < 0) { ------------------ | Branch (2293:17): [True: 2, False: 233] ------------------ 2294| 2| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2295| 2| return size; 2296| 2| } 2297| | 2298| 233| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_PRESENT; ------------------ | | 777| 233|#define OGS_NAS_EPS_SERVICE_REJECT_T3346_VALUE_PRESENT ((uint64_t)1<<1) ------------------ 2299| 233| decoded += size; 2300| 233| break; 2301| 196| case OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_TYPE: ------------------ | | 787| 196|#define OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_TYPE 0x6B ------------------ | Branch (2301:9): [True: 196, False: 5.31k] ------------------ 2302| 196| size = ogs_nas_eps_decode_gprs_timer_2(&service_reject->t3448_value, pkbuf); 2303| 196| if (size < 0) { ------------------ | Branch (2303:17): [True: 1, False: 195] ------------------ 2304| 1| ogs_error("ogs_nas_eps_decode_gprs_timer_2() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2305| 1| return size; 2306| 1| } 2307| | 2308| 195| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_PRESENT; ------------------ | | 778| 195|#define OGS_NAS_EPS_SERVICE_REJECT_T3448_VALUE_PRESENT ((uint64_t)1<<2) ------------------ 2309| 195| decoded += size; 2310| 195| break; 2311| 201| case OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE: ------------------ | | 788| 201|#define OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_TYPE 0x1C ------------------ | Branch (2311:9): [True: 201, False: 5.31k] ------------------ 2312| 201| size = ogs_nas_eps_decode_gprs_timer_3(&service_reject->lower_bound_timer_value, pkbuf); 2313| 201| if (size < 0) { ------------------ | Branch (2313:17): [True: 3, False: 198] ------------------ 2314| 3| ogs_error("ogs_nas_eps_decode_gprs_timer_3() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 2315| 3| return size; 2316| 3| } 2317| | 2318| 198| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT; ------------------ | | 779| 198|#define OGS_NAS_EPS_SERVICE_REJECT_LOWER_BOUND_TIMER_VALUE_PRESENT ((uint64_t)1<<3) ------------------ 2319| 198| decoded += size; 2320| 198| break; 2321| 328| case OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE: ------------------ | | 789| 328|#define OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_TYPE 0x1D ------------------ | Branch (2321:9): [True: 328, False: 5.18k] ------------------ 2322| 328| size = ogs_nas_eps_decode_tracking_area_identity_list(&service_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_for_roaming, pkbuf); 2323| 328| if (size < 0) { ------------------ | Branch (2323:17): [True: 2, False: 326] ------------------ 2324| 2| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2325| 2| return size; 2326| 2| } 2327| | 2328| 326| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT; ------------------ | | 780| 326|#define OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FOR_ROAMING_PRESENT ((uint64_t)1<<4) ------------------ 2329| 326| decoded += size; 2330| 326| break; 2331| 208| case OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE: ------------------ | | 790| 208|#define OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_TYPE 0x1E ------------------ | Branch (2331:9): [True: 208, False: 5.30k] ------------------ 2332| 208| size = ogs_nas_eps_decode_tracking_area_identity_list(&service_reject->forbidden_tai_for_the_list_of_forbidden_tracking_areas_forregional_provision_of_service, pkbuf); 2333| 208| if (size < 0) { ------------------ | Branch (2333:17): [True: 3, False: 205] ------------------ 2334| 3| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 2335| 3| return size; 2336| 3| } 2337| | 2338| 205| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT; ------------------ | | 781| 205|#define OGS_NAS_EPS_SERVICE_REJECT_FORBIDDEN_TAI_FOR_THE_LIST_OF_FORBIDDEN_TRACKING_AREAS_FORREGIONAL_PROVISION_OF_SERVICE_PRESENT ((uint64_t)1<<5) ------------------ 2339| 205| decoded += size; 2340| 205| break; 2341| 198| case OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 791| 198|#define OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (2341:9): [True: 198, False: 5.31k] ------------------ 2342| 198| size = ogs_nas_eps_decode_access_technology_utilization_control(&service_reject->access_technology_utilization_control, pkbuf); 2343| 198| if (size < 0) { ------------------ | Branch (2343:17): [True: 2, False: 196] ------------------ 2344| 2| ogs_error("ogs_nas_eps_decode_access_technology_utilization_control() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2345| 2| return size; 2346| 2| } 2347| | 2348| 196| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 782| 196|#define OGS_NAS_EPS_SERVICE_REJECT_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<6) ------------------ 2349| 196| decoded += size; 2350| 196| break; 2351| 235| case OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE: ------------------ | | 792| 235|#define OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_TYPE 0x21 ------------------ | Branch (2351:9): [True: 235, False: 5.27k] ------------------ 2352| 235| size = ogs_nas_eps_decode_s_f_satellite_operation_parameters(&service_reject->s_f_satellite_operation_parameters, pkbuf); 2353| 235| if (size < 0) { ------------------ | Branch (2353:17): [True: 4, False: 231] ------------------ 2354| 4| ogs_error("ogs_nas_eps_decode_s_f_satellite_operation_parameters() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2355| 4| return size; 2356| 4| } 2357| | 2358| 231| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT; ------------------ | | 783| 231|#define OGS_NAS_EPS_SERVICE_REJECT_S_F_SATELLITE_OPERATION_PARAMETERS_PRESENT ((uint64_t)1<<7) ------------------ 2359| 231| decoded += size; 2360| 231| break; 2361| 221| case OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE: ------------------ | | 793| 221|#define OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_TYPE 0x24 ------------------ | Branch (2361:9): [True: 221, False: 5.29k] ------------------ 2362| 221| size = ogs_nas_eps_decode_registration_wait_range(&service_reject->disaster_return_wait_range, pkbuf); 2363| 221| if (size < 0) { ------------------ | Branch (2363:17): [True: 4, False: 217] ------------------ 2364| 4| ogs_error("ogs_nas_eps_decode_registration_wait_range() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2365| 4| return size; 2366| 4| } 2367| | 2368| 217| service_reject->presencemask |= OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT; ------------------ | | 784| 217|#define OGS_NAS_EPS_SERVICE_REJECT_DISASTER_RETURN_WAIT_RANGE_PRESENT ((uint64_t)1<<8) ------------------ 2369| 217| decoded += size; 2370| 217| break; 2371| 3.48k| default: ------------------ | Branch (2371:9): [True: 3.48k, False: 2.02k] ------------------ 2372| 3.48k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.48k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.48k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.48k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.48k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.48k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.48k| 0, __VA_ARGS__) | | ------------------ ------------------ 2373| 3.48k| break; 2374| 5.51k| } 2375| 5.51k| } 2376| | 2377| 107| return decoded; 2378| 130|} ogs_nas_eps_decode_guti_reallocation_command: 2381| 114|{ 2382| 114| ogs_nas_eps_guti_reallocation_command_t *guti_reallocation_command = &message->emm.guti_reallocation_command; 2383| 114| int decoded = 0; 2384| 114| int size = 0; 2385| | 2386| 114| ogs_trace("[NAS] Decode GUTI_REALLOCATION_COMMAND\n"); ------------------ | | 40| 114|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 114| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 114|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 114| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 114|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 114| 0, __VA_ARGS__) | | ------------------ ------------------ 2387| | 2388| 114| size = ogs_nas_eps_decode_eps_mobile_identity(&guti_reallocation_command->guti, pkbuf); 2389| 114| if (size < 0) { ------------------ | Branch (2389:9): [True: 4, False: 110] ------------------ 2390| 4| ogs_error("ogs_nas_eps_decode_eps_mobile_identity() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2391| 4| return size; 2392| 4| } 2393| | 2394| 110| decoded += size; 2395| | 2396| 6.58k| while (pkbuf->len > 0) { ------------------ | Branch (2396:12): [True: 6.48k, False: 100] ------------------ 2397| 6.48k| uint8_t *buffer = pkbuf->data; 2398| 6.48k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2398:24): [True: 2.24k, False: 4.23k] ------------------ 2399| | 2400| 6.48k| size = sizeof(uint8_t); 2401| 6.48k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2401:13): [True: 0, False: 6.48k] ------------------ 2402| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2403| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2404| 0| } 2405| 6.48k| decoded += size; 2406| | 2407| 6.48k| switch (type) { 2408| 215| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_TYPE: ------------------ | | 821| 215|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_TYPE 0x54 ------------------ | Branch (2408:9): [True: 215, False: 6.27k] ------------------ 2409| 215| size = ogs_nas_eps_decode_tracking_area_identity_list(&guti_reallocation_command->tai_list, pkbuf); 2410| 215| if (size < 0) { ------------------ | Branch (2410:17): [True: 1, False: 214] ------------------ 2411| 1| ogs_error("ogs_nas_eps_decode_tracking_area_identity_list() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2412| 1| return size; 2413| 1| } 2414| | 2415| 214| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_PRESENT; ------------------ | | 816| 214|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_TAI_LIST_PRESENT ((uint64_t)1<<0) ------------------ 2416| 214| decoded += size; 2417| 214| break; 2418| 245| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_TYPE: ------------------ | | 822| 245|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_TYPE 0x65 ------------------ | Branch (2418:9): [True: 245, False: 6.24k] ------------------ 2419| 245| size = ogs_nas_eps_decode_dcn_id(&guti_reallocation_command->dcn_id, pkbuf); 2420| 245| if (size < 0) { ------------------ | Branch (2420:17): [True: 6, False: 239] ------------------ 2421| 6| ogs_error("ogs_nas_eps_decode_dcn_id() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2422| 6| return size; 2423| 6| } 2424| | 2425| 239| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_PRESENT; ------------------ | | 817| 239|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_DCN_ID_PRESENT ((uint64_t)1<<1) ------------------ 2426| 239| decoded += size; 2427| 239| break; 2428| 240| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 823| 240|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (2428:9): [True: 240, False: 6.24k] ------------------ 2429| 240| size = ogs_nas_eps_decode_ue_radio_capability_id(&guti_reallocation_command->ue_radio_capability_id, pkbuf); 2430| 240| if (size < 0) { ------------------ | Branch (2430:17): [True: 1, False: 239] ------------------ 2431| 1| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2432| 1| return size; 2433| 1| } 2434| | 2435| 239| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 818| 239|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<2) ------------------ 2436| 239| decoded += size; 2437| 239| break; 2438| 497| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE: ------------------ | | 824| 497|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_TYPE 0xB0 ------------------ | Branch (2438:9): [True: 497, False: 5.98k] ------------------ 2439| 497| decoded--; 2440| 497| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 497| do { \ | | 114| 497| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 497|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 497, False: 0] | | | | ------------------ | | ------------------ | | 115| 497| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 497| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 497] | | ------------------ ------------------ 2441| 497| size = ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication(&guti_reallocation_command->ue_radio_capability_id_deletion_indication, pkbuf); 2442| 497| if (size < 0) { ------------------ | Branch (2442:17): [True: 0, False: 497] ------------------ 2443| 0| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2444| 0| return size; 2445| 0| } 2446| | 2447| 497| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT; ------------------ | | 819| 497|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_UE_RADIO_CAPABILITY_ID_DELETION_INDICATION_PRESENT ((uint64_t)1<<3) ------------------ 2448| 497| decoded += size; 2449| 497| break; 2450| 212| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE: ------------------ | | 825| 212|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_TYPE 0x20 ------------------ | Branch (2450:9): [True: 212, False: 6.27k] ------------------ 2451| 212| size = ogs_nas_eps_decode_access_technology_utilization_control(&guti_reallocation_command->access_technology_utilization_control, pkbuf); 2452| 212| if (size < 0) { ------------------ | Branch (2452:17): [True: 2, False: 210] ------------------ 2453| 2| ogs_error("ogs_nas_eps_decode_access_technology_utilization_control() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2454| 2| return size; 2455| 2| } 2456| | 2457| 210| guti_reallocation_command->presencemask |= OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT; ------------------ | | 820| 210|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND_ACCESS_TECHNOLOGY_UTILIZATION_CONTROL_PRESENT ((uint64_t)1<<4) ------------------ 2458| 210| decoded += size; 2459| 210| break; 2460| 5.07k| default: ------------------ | Branch (2460:9): [True: 5.07k, False: 1.40k] ------------------ 2461| 5.07k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 5.07k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5.07k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5.07k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5.07k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5.07k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5.07k| 0, __VA_ARGS__) | | ------------------ ------------------ 2462| 5.07k| break; 2463| 6.48k| } 2464| 6.48k| } 2465| | 2466| 100| return decoded; 2467| 110|} ogs_nas_eps_decode_authentication_request: 2470| 28|{ 2471| 28| ogs_nas_eps_authentication_request_t *authentication_request = &message->emm.authentication_request; 2472| 28| int decoded = 0; 2473| 28| int size = 0; 2474| | 2475| 28| ogs_trace("[NAS] Decode AUTHENTICATION_REQUEST\n"); ------------------ | | 40| 28|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 28| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 28|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 28| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 28|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 28| 0, __VA_ARGS__) | | ------------------ ------------------ 2476| | 2477| 28| size = ogs_nas_eps_decode_key_set_identifier(&authentication_request->nas_key_set_identifierasme, pkbuf); 2478| 28| if (size < 0) { ------------------ | Branch (2478:9): [True: 0, False: 28] ------------------ 2479| 0| ogs_error("ogs_nas_eps_decode_key_set_identifier() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2480| 0| return size; 2481| 0| } 2482| | 2483| 28| decoded += size; 2484| | 2485| 28| size = ogs_nas_eps_decode_authentication_parameter_rand(&authentication_request->authentication_parameter_rand, pkbuf); 2486| 28| if (size < 0) { ------------------ | Branch (2486:9): [True: 8, False: 20] ------------------ 2487| 8| ogs_error("ogs_nas_eps_decode_authentication_parameter_rand() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2488| 8| return size; 2489| 8| } 2490| | 2491| 20| decoded += size; 2492| | 2493| 20| size = ogs_nas_eps_decode_authentication_parameter_autn(&authentication_request->authentication_parameter_autn, pkbuf); 2494| 20| if (size < 0) { ------------------ | Branch (2494:9): [True: 5, False: 15] ------------------ 2495| 5| ogs_error("ogs_nas_eps_decode_authentication_parameter_autn() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2496| 5| return size; 2497| 5| } 2498| | 2499| 15| decoded += size; 2500| | 2501| 15| return decoded; 2502| 20|} ogs_nas_eps_decode_authentication_response: 2505| 28|{ 2506| 28| ogs_nas_eps_authentication_response_t *authentication_response = &message->emm.authentication_response; 2507| 28| int decoded = 0; 2508| 28| int size = 0; 2509| | 2510| 28| ogs_trace("[NAS] Decode AUTHENTICATION_RESPONSE\n"); ------------------ | | 40| 28|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 28| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 28|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 28| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 28|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 28| 0, __VA_ARGS__) | | ------------------ ------------------ 2511| | 2512| 28| size = ogs_nas_eps_decode_authentication_response_parameter(&authentication_response->authentication_response_parameter, pkbuf); 2513| 28| if (size < 0) { ------------------ | Branch (2513:9): [True: 5, False: 23] ------------------ 2514| 5| ogs_error("ogs_nas_eps_decode_authentication_response_parameter() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2515| 5| return size; 2516| 5| } 2517| | 2518| 23| decoded += size; 2519| | 2520| 23| return decoded; 2521| 28|} ogs_nas_eps_decode_identity_request: 2524| 9|{ 2525| 9| ogs_nas_eps_identity_request_t *identity_request = &message->emm.identity_request; 2526| 9| int decoded = 0; 2527| 9| int size = 0; 2528| | 2529| 9| ogs_trace("[NAS] Decode IDENTITY_REQUEST\n"); ------------------ | | 40| 9|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 2530| | 2531| 9| size = ogs_nas_eps_decode_identity_type_2(&identity_request->identity_type, pkbuf); 2532| 9| if (size < 0) { ------------------ | Branch (2532:9): [True: 0, False: 9] ------------------ 2533| 0| ogs_error("ogs_nas_eps_decode_identity_type_2() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2534| 0| return size; 2535| 0| } 2536| | 2537| 9| decoded += size; 2538| | 2539| 9| return decoded; 2540| 9|} ogs_nas_eps_decode_identity_response: 2543| 20|{ 2544| 20| ogs_nas_eps_identity_response_t *identity_response = &message->emm.identity_response; 2545| 20| int decoded = 0; 2546| 20| int size = 0; 2547| | 2548| 20| ogs_trace("[NAS] Decode IDENTITY_RESPONSE\n"); ------------------ | | 40| 20|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 2549| | 2550| 20| size = ogs_nas_eps_decode_mobile_identity(&identity_response->mobile_identity, pkbuf); 2551| 20| if (size < 0) { ------------------ | Branch (2551:9): [True: 5, False: 15] ------------------ 2552| 5| ogs_error("ogs_nas_eps_decode_mobile_identity() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2553| 5| return size; 2554| 5| } 2555| | 2556| 15| decoded += size; 2557| | 2558| 15| return decoded; 2559| 20|} ogs_nas_eps_decode_authentication_failure: 2562| 73|{ 2563| 73| ogs_nas_eps_authentication_failure_t *authentication_failure = &message->emm.authentication_failure; 2564| 73| int decoded = 0; 2565| 73| int size = 0; 2566| | 2567| 73| ogs_trace("[NAS] Decode AUTHENTICATION_FAILURE\n"); ------------------ | | 40| 73|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 73| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 73|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 73| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 73|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 73| 0, __VA_ARGS__) | | ------------------ ------------------ 2568| | 2569| 73| size = ogs_nas_eps_decode_emm_cause(&authentication_failure->emm_cause, pkbuf); 2570| 73| if (size < 0) { ------------------ | Branch (2570:9): [True: 0, False: 73] ------------------ 2571| 0| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2572| 0| return size; 2573| 0| } 2574| | 2575| 73| decoded += size; 2576| | 2577| 5.08k| while (pkbuf->len > 0) { ------------------ | Branch (2577:12): [True: 5.02k, False: 56] ------------------ 2578| 5.02k| uint8_t *buffer = pkbuf->data; 2579| 5.02k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2579:24): [True: 1.81k, False: 3.20k] ------------------ 2580| | 2581| 5.02k| size = sizeof(uint8_t); 2582| 5.02k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2582:13): [True: 0, False: 5.02k] ------------------ 2583| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2584| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2585| 0| } 2586| 5.02k| decoded += size; 2587| | 2588| 5.02k| switch (type) { 2589| 484| case OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_TYPE: ------------------ | | 887| 484|#define OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_TYPE 0x30 ------------------ | Branch (2589:9): [True: 484, False: 4.54k] ------------------ 2590| 484| size = ogs_nas_eps_decode_authentication_failure_parameter(&authentication_failure->authentication_failure_parameter, pkbuf); 2591| 484| if (size < 0) { ------------------ | Branch (2591:17): [True: 17, False: 467] ------------------ 2592| 17| ogs_error("ogs_nas_eps_decode_authentication_failure_parameter() failed"); ------------------ | | 36| 17|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 17| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 17|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 17| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 17|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 17| 0, __VA_ARGS__) | | ------------------ ------------------ 2593| 17| return size; 2594| 17| } 2595| | 2596| 467| authentication_failure->presencemask |= OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_PRESENT; ------------------ | | 886| 467|#define OGS_NAS_EPS_AUTHENTICATION_FAILURE_AUTHENTICATION_FAILURE_PARAMETER_PRESENT ((uint64_t)1<<0) ------------------ 2597| 467| decoded += size; 2598| 467| break; 2599| 4.54k| default: ------------------ | Branch (2599:9): [True: 4.54k, False: 484] ------------------ 2600| 4.54k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 4.54k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4.54k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4.54k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4.54k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4.54k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4.54k| 0, __VA_ARGS__) | | ------------------ ------------------ 2601| 4.54k| break; 2602| 5.02k| } 2603| 5.02k| } 2604| | 2605| 56| return decoded; 2606| 73|} ogs_nas_eps_decode_security_mode_command: 2609| 121|{ 2610| 121| ogs_nas_eps_security_mode_command_t *security_mode_command = &message->emm.security_mode_command; 2611| 121| int decoded = 0; 2612| 121| int size = 0; 2613| | 2614| 121| ogs_trace("[NAS] Decode SECURITY_MODE_COMMAND\n"); ------------------ | | 40| 121|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 121| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 121|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 121| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 121|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 121| 0, __VA_ARGS__) | | ------------------ ------------------ 2615| | 2616| 121| size = ogs_nas_eps_decode_security_algorithms(&security_mode_command->selected_nas_security_algorithms, pkbuf); 2617| 121| if (size < 0) { ------------------ | Branch (2617:9): [True: 0, False: 121] ------------------ 2618| 0| ogs_error("ogs_nas_eps_decode_security_algorithms() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2619| 0| return size; 2620| 0| } 2621| | 2622| 121| decoded += size; 2623| | 2624| 121| size = ogs_nas_eps_decode_key_set_identifier(&security_mode_command->nas_key_set_identifier, pkbuf); 2625| 121| if (size < 0) { ------------------ | Branch (2625:9): [True: 0, False: 121] ------------------ 2626| 0| ogs_error("ogs_nas_eps_decode_key_set_identifier() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2627| 0| return size; 2628| 0| } 2629| | 2630| 121| decoded += size; 2631| | 2632| 121| size = ogs_nas_eps_decode_ue_security_capability(&security_mode_command->replayed_ue_security_capabilities, pkbuf); 2633| 121| if (size < 0) { ------------------ | Branch (2633:9): [True: 4, False: 117] ------------------ 2634| 4| ogs_error("ogs_nas_eps_decode_ue_security_capability() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2635| 4| return size; 2636| 4| } 2637| | 2638| 117| decoded += size; 2639| | 2640| 5.92k| while (pkbuf->len > 0) { ------------------ | Branch (2640:12): [True: 5.82k, False: 94] ------------------ 2641| 5.82k| uint8_t *buffer = pkbuf->data; 2642| 5.82k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2642:24): [True: 1.83k, False: 3.99k] ------------------ 2643| | 2644| 5.82k| size = sizeof(uint8_t); 2645| 5.82k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2645:13): [True: 0, False: 5.82k] ------------------ 2646| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2647| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2648| 0| } 2649| 5.82k| decoded += size; 2650| | 2651| 5.82k| switch (type) { 2652| 519| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_TYPE: ------------------ | | 909| 519|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_TYPE 0xC0 ------------------ | Branch (2652:9): [True: 519, False: 5.30k] ------------------ 2653| 519| decoded--; 2654| 519| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 519| do { \ | | 114| 519| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 519|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 519, False: 0] | | | | ------------------ | | ------------------ | | 115| 519| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 519| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 519] | | ------------------ ------------------ 2655| 519| size = ogs_nas_eps_decode_imeisv_request(&security_mode_command->imeisv_request, pkbuf); 2656| 519| if (size < 0) { ------------------ | Branch (2656:17): [True: 0, False: 519] ------------------ 2657| 0| ogs_error("ogs_nas_eps_decode_imeisv_request() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2658| 0| return size; 2659| 0| } 2660| | 2661| 519| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_PRESENT; ------------------ | | 902| 519|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_IMEISV_REQUEST_PRESENT ((uint64_t)1<<0) ------------------ 2662| 519| decoded += size; 2663| 519| break; 2664| 327| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_TYPE: ------------------ | | 910| 327|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_TYPE 0x55 ------------------ | Branch (2664:9): [True: 327, False: 5.50k] ------------------ 2665| 327| size = ogs_nas_eps_decode_nonce(&security_mode_command->replayed_nonceue, pkbuf); 2666| 327| if (size < 0) { ------------------ | Branch (2666:17): [True: 2, False: 325] ------------------ 2667| 2| ogs_error("ogs_nas_eps_decode_nonce() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2668| 2| return size; 2669| 2| } 2670| | 2671| 325| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_PRESENT; ------------------ | | 903| 325|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_NONCEUE_PRESENT ((uint64_t)1<<1) ------------------ 2672| 325| decoded += size; 2673| 325| break; 2674| 197| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_TYPE: ------------------ | | 911| 197|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_TYPE 0x56 ------------------ | Branch (2674:9): [True: 197, False: 5.63k] ------------------ 2675| 197| size = ogs_nas_eps_decode_nonce(&security_mode_command->noncemme, pkbuf); 2676| 197| if (size < 0) { ------------------ | Branch (2676:17): [True: 2, False: 195] ------------------ 2677| 2| ogs_error("ogs_nas_eps_decode_nonce() failed"); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2678| 2| return size; 2679| 2| } 2680| | 2681| 195| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_PRESENT; ------------------ | | 904| 195|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_NONCEMME_PRESENT ((uint64_t)1<<2) ------------------ 2682| 195| decoded += size; 2683| 195| break; 2684| 362| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_TYPE: ------------------ | | 912| 362|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_TYPE 0x4F ------------------ | Branch (2684:9): [True: 362, False: 5.46k] ------------------ 2685| 362| size = ogs_nas_eps_decode_hashmme(&security_mode_command->hashmme, pkbuf); 2686| 362| if (size < 0) { ------------------ | Branch (2686:17): [True: 10, False: 352] ------------------ 2687| 10| ogs_error("ogs_nas_eps_decode_hashmme() failed"); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 2688| 10| return size; 2689| 10| } 2690| | 2691| 352| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_PRESENT; ------------------ | | 905| 352|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_HASHMME_PRESENT ((uint64_t)1<<3) ------------------ 2692| 352| decoded += size; 2693| 352| break; 2694| 199| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE: ------------------ | | 913| 199|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_TYPE 0x6F ------------------ | Branch (2694:9): [True: 199, False: 5.62k] ------------------ 2695| 199| size = ogs_nas_eps_decode_ue_additional_security_capability(&security_mode_command->replayed_ue_additional_security_capability, pkbuf); 2696| 199| if (size < 0) { ------------------ | Branch (2696:17): [True: 1, False: 198] ------------------ 2697| 1| ogs_error("ogs_nas_eps_decode_ue_additional_security_capability() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2698| 1| return size; 2699| 1| } 2700| | 2701| 198| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT; ------------------ | | 906| 198|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_REPLAYED_UE_ADDITIONAL_SECURITY_CAPABILITY_PRESENT ((uint64_t)1<<4) ------------------ 2702| 198| decoded += size; 2703| 198| break; 2704| 350| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_TYPE: ------------------ | | 914| 350|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_TYPE 0x37 ------------------ | Branch (2704:9): [True: 350, False: 5.47k] ------------------ 2705| 350| size = ogs_nas_eps_decode_ue_radio_capability_id_request(&security_mode_command->ue_radio_capability_id_request, pkbuf); 2706| 350| if (size < 0) { ------------------ | Branch (2706:17): [True: 8, False: 342] ------------------ 2707| 8| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id_request() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2708| 8| return size; 2709| 8| } 2710| | 2711| 342| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_PRESENT; ------------------ | | 907| 342|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_RADIO_CAPABILITY_ID_REQUEST_PRESENT ((uint64_t)1<<5) ------------------ 2712| 342| decoded += size; 2713| 342| break; 2714| 422| case OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_TYPE: ------------------ | | 915| 422|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_TYPE 0xD0 ------------------ | Branch (2714:9): [True: 422, False: 5.40k] ------------------ 2715| 422| decoded--; 2716| 422| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 422| do { \ | | 114| 422| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 422|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 422, False: 0] | | | | ------------------ | | ------------------ | | 115| 422| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 422| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 422] | | ------------------ ------------------ 2717| 422| size = ogs_nas_eps_decode_ue_information_request(&security_mode_command->ue_coarse_location_information_request, pkbuf); 2718| 422| if (size < 0) { ------------------ | Branch (2718:17): [True: 0, False: 422] ------------------ 2719| 0| ogs_error("ogs_nas_eps_decode_ue_information_request() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2720| 0| return size; 2721| 0| } 2722| | 2723| 422| security_mode_command->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_PRESENT; ------------------ | | 908| 422|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND_UE_COARSE_LOCATION_INFORMATION_REQUEST_PRESENT ((uint64_t)1<<6) ------------------ 2724| 422| decoded += size; 2725| 422| break; 2726| 3.45k| default: ------------------ | Branch (2726:9): [True: 3.45k, False: 2.37k] ------------------ 2727| 3.45k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.45k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.45k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.45k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.45k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.45k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.45k| 0, __VA_ARGS__) | | ------------------ ------------------ 2728| 3.45k| break; 2729| 5.82k| } 2730| 5.82k| } 2731| | 2732| 94| return decoded; 2733| 117|} ogs_nas_eps_decode_security_mode_complete: 2736| 153|{ 2737| 153| ogs_nas_eps_security_mode_complete_t *security_mode_complete = &message->emm.security_mode_complete; 2738| 153| int decoded = 0; 2739| 153| int size = 0; 2740| | 2741| 153| ogs_trace("[NAS] Decode SECURITY_MODE_COMPLETE\n"); ------------------ | | 40| 153|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 153| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 153|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 153| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 153|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 153| 0, __VA_ARGS__) | | ------------------ ------------------ 2742| | 2743| 7.04k| while (pkbuf->len > 0) { ------------------ | Branch (2743:12): [True: 6.94k, False: 93] ------------------ 2744| 6.94k| uint8_t *buffer = pkbuf->data; 2745| 6.94k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2745:24): [True: 1.44k, False: 5.49k] ------------------ 2746| | 2747| 6.94k| size = sizeof(uint8_t); 2748| 6.94k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2748:13): [True: 0, False: 6.94k] ------------------ 2749| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2750| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2751| 0| } 2752| 6.94k| decoded += size; 2753| | 2754| 6.94k| switch (type) { 2755| 655| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_TYPE: ------------------ | | 942| 655|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_TYPE 0x23 ------------------ | Branch (2755:9): [True: 655, False: 6.29k] ------------------ 2756| 655| size = ogs_nas_eps_decode_mobile_identity(&security_mode_complete->imeisv, pkbuf); 2757| 655| if (size < 0) { ------------------ | Branch (2757:17): [True: 10, False: 645] ------------------ 2758| 10| ogs_error("ogs_nas_eps_decode_mobile_identity() failed"); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 2759| 10| return size; 2760| 10| } 2761| | 2762| 645| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_PRESENT; ------------------ | | 938| 645|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_IMEISV_PRESENT ((uint64_t)1<<0) ------------------ 2763| 645| decoded += size; 2764| 645| break; 2765| 411| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_TYPE: ------------------ | | 943| 411|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_TYPE 0x79 ------------------ | Branch (2765:9): [True: 411, False: 6.53k] ------------------ 2766| 411| size = ogs_nas_eps_decode_replayed_nas_message_container(&security_mode_complete->replayed_nas_message_container, pkbuf); 2767| 411| if (size < 0) { ------------------ | Branch (2767:17): [True: 36, False: 375] ------------------ 2768| 36| ogs_error("ogs_nas_eps_decode_replayed_nas_message_container() failed"); ------------------ | | 36| 36|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 36| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 36|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 36| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 36|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 36| 0, __VA_ARGS__) | | ------------------ ------------------ 2769| 36| return size; 2770| 36| } 2771| | 2772| 375| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_PRESENT; ------------------ | | 939| 375|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_REPLAYED_NAS_MESSAGE_CONTAINER_PRESENT ((uint64_t)1<<1) ------------------ 2773| 375| decoded += size; 2774| 375| break; 2775| 437| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_TYPE: ------------------ | | 944| 437|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_TYPE 0x66 ------------------ | Branch (2775:9): [True: 437, False: 6.51k] ------------------ 2776| 437| size = ogs_nas_eps_decode_ue_radio_capability_id(&security_mode_complete->ue_radio_capability_id, pkbuf); 2777| 437| if (size < 0) { ------------------ | Branch (2777:17): [True: 6, False: 431] ------------------ 2778| 6| ogs_error("ogs_nas_eps_decode_ue_radio_capability_id() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2779| 6| return size; 2780| 6| } 2781| | 2782| 431| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_PRESENT; ------------------ | | 940| 431|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_RADIO_CAPABILITY_ID_PRESENT ((uint64_t)1<<2) ------------------ 2783| 431| decoded += size; 2784| 431| break; 2785| 259| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_TYPE: ------------------ | | 945| 259|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_TYPE 0x67 ------------------ | Branch (2785:9): [True: 259, False: 6.68k] ------------------ 2786| 259| size = ogs_nas_eps_decode_ue_coarse_location_information(&security_mode_complete->ue_coarse_location_information, pkbuf); 2787| 259| if (size < 0) { ------------------ | Branch (2787:17): [True: 8, False: 251] ------------------ 2788| 8| ogs_error("ogs_nas_eps_decode_ue_coarse_location_information() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2789| 8| return size; 2790| 8| } 2791| | 2792| 251| security_mode_complete->presencemask |= OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_PRESENT; ------------------ | | 941| 251|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE_UE_COARSE_LOCATION_INFORMATION_PRESENT ((uint64_t)1<<3) ------------------ 2793| 251| decoded += size; 2794| 251| break; 2795| 5.18k| default: ------------------ | Branch (2795:9): [True: 5.18k, False: 1.76k] ------------------ 2796| 5.18k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 5.18k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5.18k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5.18k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5.18k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5.18k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5.18k| 0, __VA_ARGS__) | | ------------------ ------------------ 2797| 5.18k| break; 2798| 6.94k| } 2799| 6.94k| } 2800| | 2801| 93| return decoded; 2802| 153|} ogs_nas_eps_decode_security_mode_reject: 2805| 1|{ 2806| 1| ogs_nas_eps_security_mode_reject_t *security_mode_reject = &message->emm.security_mode_reject; 2807| 1| int decoded = 0; 2808| 1| int size = 0; 2809| | 2810| 1| ogs_trace("[NAS] Decode SECURITY_MODE_REJECT\n"); ------------------ | | 40| 1|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2811| | 2812| 1| size = ogs_nas_eps_decode_emm_cause(&security_mode_reject->emm_cause, pkbuf); 2813| 1| if (size < 0) { ------------------ | Branch (2813:9): [True: 0, False: 1] ------------------ 2814| 0| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2815| 0| return size; 2816| 0| } 2817| | 2818| 1| decoded += size; 2819| | 2820| 1| return decoded; 2821| 1|} ogs_nas_eps_decode_emm_status: 2824| 1|{ 2825| 1| ogs_nas_eps_emm_status_t *emm_status = &message->emm.emm_status; 2826| 1| int decoded = 0; 2827| 1| int size = 0; 2828| | 2829| 1| ogs_trace("[NAS] Decode EMM_STATUS\n"); ------------------ | | 40| 1|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2830| | 2831| 1| size = ogs_nas_eps_decode_emm_cause(&emm_status->emm_cause, pkbuf); 2832| 1| if (size < 0) { ------------------ | Branch (2832:9): [True: 0, False: 1] ------------------ 2833| 0| ogs_error("ogs_nas_eps_decode_emm_cause() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2834| 0| return size; 2835| 0| } 2836| | 2837| 1| decoded += size; 2838| | 2839| 1| return decoded; 2840| 1|} ogs_nas_eps_decode_emm_information: 2843| 130|{ 2844| 130| ogs_nas_eps_emm_information_t *emm_information = &message->emm.emm_information; 2845| 130| int decoded = 0; 2846| 130| int size = 0; 2847| | 2848| 130| ogs_trace("[NAS] Decode EMM_INFORMATION\n"); ------------------ | | 40| 130|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 130| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 130|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 130| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 130|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 130| 0, __VA_ARGS__) | | ------------------ ------------------ 2849| | 2850| 6.23k| while (pkbuf->len > 0) { ------------------ | Branch (2850:12): [True: 6.14k, False: 92] ------------------ 2851| 6.14k| uint8_t *buffer = pkbuf->data; 2852| 6.14k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2852:24): [True: 2.58k, False: 3.56k] ------------------ 2853| | 2854| 6.14k| size = sizeof(uint8_t); 2855| 6.14k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2855:13): [True: 0, False: 6.14k] ------------------ 2856| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2857| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2858| 0| } 2859| 6.14k| decoded += size; 2860| | 2861| 6.14k| switch (type) { 2862| 257| case OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_TYPE: ------------------ | | 986| 257|#define OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_TYPE 0x43 ------------------ | Branch (2862:9): [True: 257, False: 5.88k] ------------------ 2863| 257| size = ogs_nas_eps_decode_network_name(&emm_information->full_name_for_network, pkbuf); 2864| 257| if (size < 0) { ------------------ | Branch (2864:17): [True: 8, False: 249] ------------------ 2865| 8| ogs_error("ogs_nas_eps_decode_network_name() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2866| 8| return size; 2867| 8| } 2868| | 2869| 249| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_PRESENT; ------------------ | | 981| 249|#define OGS_NAS_EPS_EMM_INFORMATION_FULL_NAME_FOR_NETWORK_PRESENT ((uint64_t)1<<0) ------------------ 2870| 249| decoded += size; 2871| 249| break; 2872| 244| case OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_TYPE: ------------------ | | 987| 244|#define OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_TYPE 0x45 ------------------ | Branch (2872:9): [True: 244, False: 5.90k] ------------------ 2873| 244| size = ogs_nas_eps_decode_network_name(&emm_information->short_name_for_network, pkbuf); 2874| 244| if (size < 0) { ------------------ | Branch (2874:17): [True: 5, False: 239] ------------------ 2875| 5| ogs_error("ogs_nas_eps_decode_network_name() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2876| 5| return size; 2877| 5| } 2878| | 2879| 239| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_PRESENT; ------------------ | | 982| 239|#define OGS_NAS_EPS_EMM_INFORMATION_SHORT_NAME_FOR_NETWORK_PRESENT ((uint64_t)1<<1) ------------------ 2880| 239| decoded += size; 2881| 239| break; 2882| 349| case OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_TYPE: ------------------ | | 988| 349|#define OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_TYPE 0x46 ------------------ | Branch (2882:9): [True: 349, False: 5.79k] ------------------ 2883| 349| size = ogs_nas_eps_decode_time_zone(&emm_information->local_time_zone, pkbuf); 2884| 349| if (size < 0) { ------------------ | Branch (2884:17): [True: 5, False: 344] ------------------ 2885| 5| ogs_error("ogs_nas_eps_decode_time_zone() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2886| 5| return size; 2887| 5| } 2888| | 2889| 344| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_PRESENT; ------------------ | | 983| 344|#define OGS_NAS_EPS_EMM_INFORMATION_LOCAL_TIME_ZONE_PRESENT ((uint64_t)1<<2) ------------------ 2890| 344| decoded += size; 2891| 344| break; 2892| 164| case OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_TYPE: ------------------ | | 989| 164|#define OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_TYPE 0x47 ------------------ | Branch (2892:9): [True: 164, False: 5.98k] ------------------ 2893| 164| size = ogs_nas_eps_decode_time_zone_and_time(&emm_information->universal_time_and_local_time_zone, pkbuf); 2894| 164| if (size < 0) { ------------------ | Branch (2894:17): [True: 9, False: 155] ------------------ 2895| 9| ogs_error("ogs_nas_eps_decode_time_zone_and_time() failed"); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 2896| 9| return size; 2897| 9| } 2898| | 2899| 155| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_PRESENT; ------------------ | | 984| 155|#define OGS_NAS_EPS_EMM_INFORMATION_UNIVERSAL_TIME_AND_LOCAL_TIME_ZONE_PRESENT ((uint64_t)1<<3) ------------------ 2900| 155| decoded += size; 2901| 155| break; 2902| 396| case OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_TYPE: ------------------ | | 990| 396|#define OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_TYPE 0x49 ------------------ | Branch (2902:9): [True: 396, False: 5.75k] ------------------ 2903| 396| size = ogs_nas_eps_decode_daylight_saving_time(&emm_information->network_daylight_saving_time, pkbuf); 2904| 396| if (size < 0) { ------------------ | Branch (2904:17): [True: 11, False: 385] ------------------ 2905| 11| ogs_error("ogs_nas_eps_decode_daylight_saving_time() failed"); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 2906| 11| return size; 2907| 11| } 2908| | 2909| 385| emm_information->presencemask |= OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_PRESENT; ------------------ | | 985| 385|#define OGS_NAS_EPS_EMM_INFORMATION_NETWORK_DAYLIGHT_SAVING_TIME_PRESENT ((uint64_t)1<<4) ------------------ 2910| 385| decoded += size; 2911| 385| break; 2912| 4.73k| default: ------------------ | Branch (2912:9): [True: 4.73k, False: 1.41k] ------------------ 2913| 4.73k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 4.73k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4.73k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4.73k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4.73k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4.73k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4.73k| 0, __VA_ARGS__) | | ------------------ ------------------ 2914| 4.73k| break; 2915| 6.14k| } 2916| 6.14k| } 2917| | 2918| 92| return decoded; 2919| 130|} ogs_nas_eps_decode_downlink_nas_transport: 2922| 32|{ 2923| 32| ogs_nas_eps_downlink_nas_transport_t *downlink_nas_transport = &message->emm.downlink_nas_transport; 2924| 32| int decoded = 0; 2925| 32| int size = 0; 2926| | 2927| 32| ogs_trace("[NAS] Decode DOWNLINK_NAS_TRANSPORT\n"); ------------------ | | 40| 32|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 32| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 32|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 32| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 32|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 32| 0, __VA_ARGS__) | | ------------------ ------------------ 2928| | 2929| 32| size = ogs_nas_eps_decode_eps_message_container(&downlink_nas_transport->nas_message_container, pkbuf); 2930| 32| if (size < 0) { ------------------ | Branch (2930:9): [True: 6, False: 26] ------------------ 2931| 6| ogs_error("ogs_nas_eps_decode_eps_message_container() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2932| 6| return size; 2933| 6| } 2934| | 2935| 26| decoded += size; 2936| | 2937| 26| return decoded; 2938| 32|} ogs_nas_eps_decode_uplink_nas_transport: 2941| 31|{ 2942| 31| ogs_nas_eps_uplink_nas_transport_t *uplink_nas_transport = &message->emm.uplink_nas_transport; 2943| 31| int decoded = 0; 2944| 31| int size = 0; 2945| | 2946| 31| ogs_trace("[NAS] Decode UPLINK_NAS_TRANSPORT\n"); ------------------ | | 40| 31|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 31| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 31|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 31| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 31|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 31| 0, __VA_ARGS__) | | ------------------ ------------------ 2947| | 2948| 31| size = ogs_nas_eps_decode_eps_message_container(&uplink_nas_transport->nas_message_container, pkbuf); 2949| 31| if (size < 0) { ------------------ | Branch (2949:9): [True: 4, False: 27] ------------------ 2950| 4| ogs_error("ogs_nas_eps_decode_eps_message_container() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 2951| 4| return size; 2952| 4| } 2953| | 2954| 27| decoded += size; 2955| | 2956| 27| return decoded; 2957| 31|} ogs_nas_eps_decode_cs_service_notification: 2960| 111|{ 2961| 111| ogs_nas_eps_cs_service_notification_t *cs_service_notification = &message->emm.cs_service_notification; 2962| 111| int decoded = 0; 2963| 111| int size = 0; 2964| | 2965| 111| ogs_trace("[NAS] Decode CS_SERVICE_NOTIFICATION\n"); ------------------ | | 40| 111|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 111| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 111|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 111| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 111|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 111| 0, __VA_ARGS__) | | ------------------ ------------------ 2966| | 2967| 111| size = ogs_nas_eps_decode_paging_identity(&cs_service_notification->paging_identity, pkbuf); 2968| 111| if (size < 0) { ------------------ | Branch (2968:9): [True: 0, False: 111] ------------------ 2969| 0| ogs_error("ogs_nas_eps_decode_paging_identity() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2970| 0| return size; 2971| 0| } 2972| | 2973| 111| decoded += size; 2974| | 2975| 4.91k| while (pkbuf->len > 0) { ------------------ | Branch (2975:12): [True: 4.84k, False: 74] ------------------ 2976| 4.84k| uint8_t *buffer = pkbuf->data; 2977| 4.84k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (2977:24): [True: 1.31k, False: 3.52k] ------------------ 2978| | 2979| 4.84k| size = sizeof(uint8_t); 2980| 4.84k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2980:13): [True: 0, False: 4.84k] ------------------ 2981| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2982| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 2983| 0| } 2984| 4.84k| decoded += size; 2985| | 2986| 4.84k| switch (type) { 2987| 402| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_TYPE: ------------------ | | 1031| 402|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_TYPE 0x60 ------------------ | Branch (2987:9): [True: 402, False: 4.44k] ------------------ 2988| 402| size = ogs_nas_eps_decode_cli(&cs_service_notification->cli, pkbuf); 2989| 402| if (size < 0) { ------------------ | Branch (2989:17): [True: 13, False: 389] ------------------ 2990| 13| ogs_error("ogs_nas_eps_decode_cli() failed"); ------------------ | | 36| 13|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 13| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 13|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 13| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 13|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 13| 0, __VA_ARGS__) | | ------------------ ------------------ 2991| 13| return size; 2992| 13| } 2993| | 2994| 389| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_PRESENT; ------------------ | | 1027| 389|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_CLI_PRESENT ((uint64_t)1<<0) ------------------ 2995| 389| decoded += size; 2996| 389| break; 2997| 220| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_TYPE: ------------------ | | 1032| 220|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_TYPE 0x61 ------------------ | Branch (2997:9): [True: 220, False: 4.62k] ------------------ 2998| 220| size = ogs_nas_eps_decode_ss_code(&cs_service_notification->ss_code, pkbuf); 2999| 220| if (size < 0) { ------------------ | Branch (2999:17): [True: 5, False: 215] ------------------ 3000| 5| ogs_error("ogs_nas_eps_decode_ss_code() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 3001| 5| return size; 3002| 5| } 3003| | 3004| 215| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_PRESENT; ------------------ | | 1028| 215|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_SS_CODE_PRESENT ((uint64_t)1<<1) ------------------ 3005| 215| decoded += size; 3006| 215| break; 3007| 511| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_TYPE: ------------------ | | 1033| 511|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_TYPE 0x62 ------------------ | Branch (3007:9): [True: 511, False: 4.33k] ------------------ 3008| 511| size = ogs_nas_eps_decode_lcs_indicator(&cs_service_notification->lcs_indicator, pkbuf); 3009| 511| if (size < 0) { ------------------ | Branch (3009:17): [True: 8, False: 503] ------------------ 3010| 8| ogs_error("ogs_nas_eps_decode_lcs_indicator() failed"); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 3011| 8| return size; 3012| 8| } 3013| | 3014| 503| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_PRESENT; ------------------ | | 1029| 503|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_INDICATOR_PRESENT ((uint64_t)1<<2) ------------------ 3015| 503| decoded += size; 3016| 503| break; 3017| 360| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_TYPE: ------------------ | | 1034| 360|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_TYPE 0x63 ------------------ | Branch (3017:9): [True: 360, False: 4.48k] ------------------ 3018| 360| size = ogs_nas_eps_decode_lcs_client_identity(&cs_service_notification->lcs_client_identity, pkbuf); 3019| 360| if (size < 0) { ------------------ | Branch (3019:17): [True: 11, False: 349] ------------------ 3020| 11| ogs_error("ogs_nas_eps_decode_lcs_client_identity() failed"); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 3021| 11| return size; 3022| 11| } 3023| | 3024| 349| cs_service_notification->presencemask |= OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_PRESENT; ------------------ | | 1030| 349|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION_LCS_CLIENT_IDENTITY_PRESENT ((uint64_t)1<<3) ------------------ 3025| 349| decoded += size; 3026| 349| break; 3027| 3.35k| default: ------------------ | Branch (3027:9): [True: 3.35k, False: 1.49k] ------------------ 3028| 3.35k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.35k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.35k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.35k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.35k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.35k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.35k| 0, __VA_ARGS__) | | ------------------ ------------------ 3029| 3.35k| break; 3030| 4.84k| } 3031| 4.84k| } 3032| | 3033| 74| return decoded; 3034| 111|} ogs_nas_eps_decode_uplink_generic_nas_transport: 3037| 86|{ 3038| 86| ogs_nas_eps_uplink_generic_nas_transport_t *uplink_generic_nas_transport = &message->emm.uplink_generic_nas_transport; 3039| 86| int decoded = 0; 3040| 86| int size = 0; 3041| | 3042| 86| ogs_trace("[NAS] Decode UPLINK_GENERIC_NAS_TRANSPORT\n"); ------------------ | | 40| 86|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 86| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 86|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 86| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 86|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 86| 0, __VA_ARGS__) | | ------------------ ------------------ 3043| | 3044| 86| size = ogs_nas_eps_decode_generic_message_container_type(&uplink_generic_nas_transport->generic_message_container_type, pkbuf); 3045| 86| if (size < 0) { ------------------ | Branch (3045:9): [True: 0, False: 86] ------------------ 3046| 0| ogs_error("ogs_nas_eps_decode_generic_message_container_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 3047| 0| return size; 3048| 0| } 3049| | 3050| 86| decoded += size; 3051| | 3052| 86| size = ogs_nas_eps_decode_generic_message_container(&uplink_generic_nas_transport->generic_message_container, pkbuf); 3053| 86| if (size < 0) { ------------------ | Branch (3053:9): [True: 16, False: 70] ------------------ 3054| 16| ogs_error("ogs_nas_eps_decode_generic_message_container() failed"); ------------------ | | 36| 16|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 16| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 16|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 16| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 16|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 16| 0, __VA_ARGS__) | | ------------------ ------------------ 3055| 16| return size; 3056| 16| } 3057| | 3058| 70| decoded += size; 3059| | 3060| 2.51k| while (pkbuf->len > 0) { ------------------ | Branch (3060:12): [True: 2.45k, False: 66] ------------------ 3061| 2.45k| uint8_t *buffer = pkbuf->data; 3062| 2.45k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (3062:24): [True: 806, False: 1.64k] ------------------ 3063| | 3064| 2.45k| size = sizeof(uint8_t); 3065| 2.45k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3065:13): [True: 0, False: 2.45k] ------------------ 3066| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 3067| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 3068| 0| } 3069| 2.45k| decoded += size; 3070| | 3071| 2.45k| switch (type) { 3072| 246| case OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE: ------------------ | | 1053| 246|#define OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE 0x65 ------------------ | Branch (3072:9): [True: 246, False: 2.20k] ------------------ 3073| 246| size = ogs_nas_eps_decode_additional_information(&uplink_generic_nas_transport->additional_information, pkbuf); 3074| 246| if (size < 0) { ------------------ | Branch (3074:17): [True: 4, False: 242] ------------------ 3075| 4| ogs_error("ogs_nas_eps_decode_additional_information() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 3076| 4| return size; 3077| 4| } 3078| | 3079| 242| uplink_generic_nas_transport->presencemask |= OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT; ------------------ | | 1052| 242|#define OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT ((uint64_t)1<<0) ------------------ 3080| 242| decoded += size; 3081| 242| break; 3082| 2.20k| default: ------------------ | Branch (3082:9): [True: 2.20k, False: 246] ------------------ 3083| 2.20k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 2.20k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.20k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.20k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.20k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.20k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.20k| 0, __VA_ARGS__) | | ------------------ ------------------ 3084| 2.20k| break; 3085| 2.45k| } 3086| 2.45k| } 3087| | 3088| 66| return decoded; 3089| 70|} ogs_nas_eps_decode_downlink_generic_nas_transport: 3092| 87|{ 3093| 87| ogs_nas_eps_downlink_generic_nas_transport_t *downlink_generic_nas_transport = &message->emm.downlink_generic_nas_transport; 3094| 87| int decoded = 0; 3095| 87| int size = 0; 3096| | 3097| 87| ogs_trace("[NAS] Decode DOWNLINK_GENERIC_NAS_TRANSPORT\n"); ------------------ | | 40| 87|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 87| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 87|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 87| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 87|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 87| 0, __VA_ARGS__) | | ------------------ ------------------ 3098| | 3099| 87| size = ogs_nas_eps_decode_generic_message_container_type(&downlink_generic_nas_transport->generic_message_container_type, pkbuf); 3100| 87| if (size < 0) { ------------------ | Branch (3100:9): [True: 0, False: 87] ------------------ 3101| 0| ogs_error("ogs_nas_eps_decode_generic_message_container_type() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 3102| 0| return size; 3103| 0| } 3104| | 3105| 87| decoded += size; 3106| | 3107| 87| size = ogs_nas_eps_decode_generic_message_container(&downlink_generic_nas_transport->generic_message_container, pkbuf); 3108| 87| if (size < 0) { ------------------ | Branch (3108:9): [True: 14, False: 73] ------------------ 3109| 14| ogs_error("ogs_nas_eps_decode_generic_message_container() failed"); ------------------ | | 36| 14|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 14| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 14|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 14| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 14|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 14| 0, __VA_ARGS__) | | ------------------ ------------------ 3110| 14| return size; 3111| 14| } 3112| | 3113| 73| decoded += size; 3114| | 3115| 3.96k| while (pkbuf->len > 0) { ------------------ | Branch (3115:12): [True: 3.90k, False: 67] ------------------ 3116| 3.90k| uint8_t *buffer = pkbuf->data; 3117| 3.90k| uint8_t type = (*buffer) >= 0x80 ? ((*buffer) & 0xf0) : (*buffer); ------------------ | Branch (3117:24): [True: 1.17k, False: 2.72k] ------------------ 3118| | 3119| 3.90k| size = sizeof(uint8_t); 3120| 3.90k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3120:13): [True: 0, False: 3.90k] ------------------ 3121| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 3122| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 3123| 0| } 3124| 3.90k| decoded += size; 3125| | 3126| 3.90k| switch (type) { 3127| 247| case OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE: ------------------ | | 1070| 247|#define OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_TYPE 0x65 ------------------ | Branch (3127:9): [True: 247, False: 3.65k] ------------------ 3128| 247| size = ogs_nas_eps_decode_additional_information(&downlink_generic_nas_transport->additional_information, pkbuf); 3129| 247| if (size < 0) { ------------------ | Branch (3129:17): [True: 6, False: 241] ------------------ 3130| 6| ogs_error("ogs_nas_eps_decode_additional_information() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 3131| 6| return size; 3132| 6| } 3133| | 3134| 241| downlink_generic_nas_transport->presencemask |= OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT; ------------------ | | 1069| 241|#define OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT_ADDITIONAL_INFORMATION_PRESENT ((uint64_t)1<<0) ------------------ 3135| 241| decoded += size; 3136| 241| break; 3137| 3.65k| default: ------------------ | Branch (3137:9): [True: 3.65k, False: 247] ------------------ 3138| 3.65k| ogs_warn("Unknown type(0x%x) or not implemented\n", type); ------------------ | | 37| 3.65k|#define ogs_warn(...) ogs_log_message(OGS_LOG_WARN, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.65k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.65k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.65k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.65k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.65k| 0, __VA_ARGS__) | | ------------------ ------------------ 3139| 3.65k| break; 3140| 3.90k| } 3141| 3.90k| } 3142| | 3143| 67| return decoded; 3144| 73|} ogs_nas_emm_decode: 4990| 3.88k|{ 4991| 3.88k| int size = 0; 4992| 3.88k| int decoded = 0; 4993| | 4994| 3.88k| ogs_assert(pkbuf); ------------------ | | 113| 3.88k| do { \ | | 114| 3.88k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.88k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.88k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.88k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 3.88k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.88k] | | ------------------ ------------------ 4995| 3.88k| ogs_assert(pkbuf->data); ------------------ | | 113| 3.88k| do { \ | | 114| 3.88k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 3.88k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 3.88k, False: 0] | | | | ------------------ | | ------------------ | | 115| 3.88k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 3.88k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 3.88k] | | ------------------ ------------------ 4996| | 4997| 3.88k| size = sizeof(ogs_nas_emm_header_t); 4998| 3.88k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (4998:9): [True: 0, False: 3.88k] ------------------ 4999| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 5000| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 5001| 0| } 5002| | 5003| 3.88k| memset(message, 0, sizeof(ogs_nas_eps_message_t)); 5004| 3.88k| memcpy(&message->emm.h, pkbuf->data - size, size); 5005| 3.88k| decoded += size; 5006| | 5007| 3.88k| if (message->emm.h.security_header_type >= ------------------ | Branch (5007:9): [True: 12, False: 3.87k] ------------------ 5008| 3.88k| OGS_NAS_SECURITY_HEADER_FOR_SERVICE_REQUEST_MESSAGE) { ------------------ | | 43| 3.88k|#define OGS_NAS_SECURITY_HEADER_FOR_SERVICE_REQUEST_MESSAGE 12 ------------------ 5009| 12| ogs_assert(ogs_pkbuf_push(pkbuf, 1)); ------------------ | | 113| 12| do { \ | | 114| 12| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 12|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 12, False: 0] | | | | ------------------ | | ------------------ | | 115| 12| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_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| 12| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 12] | | ------------------ ------------------ 5010| 12| decoded -= 1; 5011| 12| size = ogs_nas_eps_decode_service_request(message, pkbuf); 5012| 12| if (size < 0) { ------------------ | Branch (5012:13): [True: 0, False: 12] ------------------ 5013| 0| ogs_error("ogs_nas_eps_decode_service_request() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 5014| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 5015| 0| } 5016| 12| decoded += size; 5017| | 5018| 12| goto out; 5019| 12| } 5020| | 5021| 3.87k| switch (message->emm.h.message_type) { 5022| 347| case OGS_NAS_EPS_ATTACH_REQUEST: ------------------ | | 71| 347|#define OGS_NAS_EPS_ATTACH_REQUEST 65 ------------------ | Branch (5022:5): [True: 347, False: 3.53k] ------------------ 5023| 347| size = ogs_nas_eps_decode_attach_request(message, pkbuf); 5024| 347| if (size < 0) { ------------------ | Branch (5024:13): [True: 49, False: 298] ------------------ 5025| 49| ogs_error("ogs_nas_eps_decode_attach_request() failed"); ------------------ | | 36| 49|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 49| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 49|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 49| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 49|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 49| 0, __VA_ARGS__) | | ------------------ ------------------ 5026| 49| return OGS_ERROR; ------------------ | | 78| 49|#define OGS_ERROR -1 ------------------ 5027| 49| } 5028| | 5029| 298| decoded += size; 5030| 298| break; 5031| 436| case OGS_NAS_EPS_ATTACH_ACCEPT: ------------------ | | 72| 436|#define OGS_NAS_EPS_ATTACH_ACCEPT 66 ------------------ | Branch (5031:5): [True: 436, False: 3.44k] ------------------ 5032| 436| size = ogs_nas_eps_decode_attach_accept(message, pkbuf); 5033| 436| if (size < 0) { ------------------ | Branch (5033:13): [True: 46, False: 390] ------------------ 5034| 46| ogs_error("ogs_nas_eps_decode_attach_accept() failed"); ------------------ | | 36| 46|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 46| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 46|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 46| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 46|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 46| 0, __VA_ARGS__) | | ------------------ ------------------ 5035| 46| return OGS_ERROR; ------------------ | | 78| 46|#define OGS_ERROR -1 ------------------ 5036| 46| } 5037| | 5038| 390| decoded += size; 5039| 390| break; 5040| 40| case OGS_NAS_EPS_ATTACH_COMPLETE: ------------------ | | 73| 40|#define OGS_NAS_EPS_ATTACH_COMPLETE 67 ------------------ | Branch (5040:5): [True: 40, False: 3.83k] ------------------ 5041| 40| size = ogs_nas_eps_decode_attach_complete(message, pkbuf); 5042| 40| if (size < 0) { ------------------ | Branch (5042:13): [True: 20, False: 20] ------------------ 5043| 20| ogs_error("ogs_nas_eps_decode_attach_complete() failed"); ------------------ | | 36| 20|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 5044| 20| return OGS_ERROR; ------------------ | | 78| 20|#define OGS_ERROR -1 ------------------ 5045| 20| } 5046| | 5047| 20| decoded += size; 5048| 20| break; 5049| 157| case OGS_NAS_EPS_ATTACH_REJECT: ------------------ | | 74| 157|#define OGS_NAS_EPS_ATTACH_REJECT 68 ------------------ | Branch (5049:5): [True: 157, False: 3.72k] ------------------ 5050| 157| size = ogs_nas_eps_decode_attach_reject(message, pkbuf); 5051| 157| if (size < 0) { ------------------ | Branch (5051:13): [True: 33, False: 124] ------------------ 5052| 33| ogs_error("ogs_nas_eps_decode_attach_reject() failed"); ------------------ | | 36| 33|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 33| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 33|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 33| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 33|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 33| 0, __VA_ARGS__) | | ------------------ ------------------ 5053| 33| return OGS_ERROR; ------------------ | | 78| 33|#define OGS_ERROR -1 ------------------ 5054| 33| } 5055| | 5056| 124| decoded += size; 5057| 124| break; 5058| 9| case OGS_NAS_EPS_DETACH_REQUEST: ------------------ | | 75| 9|#define OGS_NAS_EPS_DETACH_REQUEST 69 ------------------ | Branch (5058:5): [True: 9, False: 3.86k] ------------------ 5059| 9| size = ogs_nas_eps_decode_detach_request_from_ue(message, pkbuf); 5060| 9| if (size < 0) { ------------------ | Branch (5060:13): [True: 1, False: 8] ------------------ 5061| 1| ogs_error("ogs_nas_eps_decode_detach_request_from_ue() failed"); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 5062| 1| return OGS_ERROR; ------------------ | | 78| 1|#define OGS_ERROR -1 ------------------ 5063| 1| } 5064| | 5065| 8| decoded += size; 5066| 8| break; 5067| 1| case OGS_NAS_EPS_DETACH_ACCEPT: ------------------ | | 76| 1|#define OGS_NAS_EPS_DETACH_ACCEPT 70 ------------------ | Branch (5067:5): [True: 1, False: 3.87k] ------------------ 5068| 1| break; 5069| 679| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST: ------------------ | | 77| 679|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REQUEST 72 ------------------ | Branch (5069:5): [True: 679, False: 3.19k] ------------------ 5070| 679| size = ogs_nas_eps_decode_tracking_area_update_request(message, pkbuf); 5071| 679| if (size < 0) { ------------------ | Branch (5071:13): [True: 212, False: 467] ------------------ 5072| 212| ogs_error("ogs_nas_eps_decode_tracking_area_update_request() failed"); ------------------ | | 36| 212|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 212| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 212|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 212| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 212|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 212| 0, __VA_ARGS__) | | ------------------ ------------------ 5073| 212| return OGS_ERROR; ------------------ | | 78| 212|#define OGS_ERROR -1 ------------------ 5074| 212| } 5075| | 5076| 467| decoded += size; 5077| 467| break; 5078| 794| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT: ------------------ | | 78| 794|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_ACCEPT 73 ------------------ | Branch (5078:5): [True: 794, False: 3.08k] ------------------ 5079| 794| size = ogs_nas_eps_decode_tracking_area_update_accept(message, pkbuf); 5080| 794| if (size < 0) { ------------------ | Branch (5080:13): [True: 274, False: 520] ------------------ 5081| 274| ogs_error("ogs_nas_eps_decode_tracking_area_update_accept() failed"); ------------------ | | 36| 274|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 274| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 274|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 274| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 274|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 274| 0, __VA_ARGS__) | | ------------------ ------------------ 5082| 274| return OGS_ERROR; ------------------ | | 78| 274|#define OGS_ERROR -1 ------------------ 5083| 274| } 5084| | 5085| 520| decoded += size; 5086| 520| break; 5087| 1| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_COMPLETE: ------------------ | | 79| 1|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_COMPLETE 74 ------------------ | Branch (5087:5): [True: 1, False: 3.87k] ------------------ 5088| 1| break; 5089| 135| case OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT: ------------------ | | 80| 135|#define OGS_NAS_EPS_TRACKING_AREA_UPDATE_REJECT 75 ------------------ | Branch (5089:5): [True: 135, False: 3.74k] ------------------ 5090| 135| size = ogs_nas_eps_decode_tracking_area_update_reject(message, pkbuf); 5091| 135| if (size < 0) { ------------------ | Branch (5091:13): [True: 20, False: 115] ------------------ 5092| 20| ogs_error("ogs_nas_eps_decode_tracking_area_update_reject() failed"); ------------------ | | 36| 20|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 5093| 20| return OGS_ERROR; ------------------ | | 78| 20|#define OGS_ERROR -1 ------------------ 5094| 20| } 5095| | 5096| 115| decoded += size; 5097| 115| break; 5098| 120| case OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST: ------------------ | | 81| 120|#define OGS_NAS_EPS_EXTENDED_SERVICE_REQUEST 76 ------------------ | Branch (5098:5): [True: 120, False: 3.75k] ------------------ 5099| 120| size = ogs_nas_eps_decode_extended_service_request(message, pkbuf); 5100| 120| if (size < 0) { ------------------ | Branch (5100:13): [True: 23, False: 97] ------------------ 5101| 23| ogs_error("ogs_nas_eps_decode_extended_service_request() failed"); ------------------ | | 36| 23|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 23| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 23|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 23| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 23|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 23| 0, __VA_ARGS__) | | ------------------ ------------------ 5102| 23| return OGS_ERROR; ------------------ | | 78| 23|#define OGS_ERROR -1 ------------------ 5103| 23| } 5104| | 5105| 97| decoded += size; 5106| 97| break; 5107| 130| case OGS_NAS_EPS_SERVICE_REJECT: ------------------ | | 82| 130|#define OGS_NAS_EPS_SERVICE_REJECT 78 ------------------ | Branch (5107:5): [True: 130, False: 3.74k] ------------------ 5108| 130| size = ogs_nas_eps_decode_service_reject(message, pkbuf); 5109| 130| if (size < 0) { ------------------ | Branch (5109:13): [True: 23, False: 107] ------------------ 5110| 23| ogs_error("ogs_nas_eps_decode_service_reject() failed"); ------------------ | | 36| 23|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 23| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 23|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 23| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 23|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 23| 0, __VA_ARGS__) | | ------------------ ------------------ 5111| 23| return OGS_ERROR; ------------------ | | 78| 23|#define OGS_ERROR -1 ------------------ 5112| 23| } 5113| | 5114| 107| decoded += size; 5115| 107| break; 5116| 114| case OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND: ------------------ | | 83| 114|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMMAND 80 ------------------ | Branch (5116:5): [True: 114, False: 3.76k] ------------------ 5117| 114| size = ogs_nas_eps_decode_guti_reallocation_command(message, pkbuf); 5118| 114| if (size < 0) { ------------------ | Branch (5118:13): [True: 14, False: 100] ------------------ 5119| 14| ogs_error("ogs_nas_eps_decode_guti_reallocation_command() failed"); ------------------ | | 36| 14|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 14| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 14|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 14| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 14|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 14| 0, __VA_ARGS__) | | ------------------ ------------------ 5120| 14| return OGS_ERROR; ------------------ | | 78| 14|#define OGS_ERROR -1 ------------------ 5121| 14| } 5122| | 5123| 100| decoded += size; 5124| 100| break; 5125| 1| case OGS_NAS_EPS_GUTI_REALLOCATION_COMPLETE: ------------------ | | 84| 1|#define OGS_NAS_EPS_GUTI_REALLOCATION_COMPLETE 81 ------------------ | Branch (5125:5): [True: 1, False: 3.87k] ------------------ 5126| 1| break; 5127| 28| case OGS_NAS_EPS_AUTHENTICATION_REQUEST: ------------------ | | 85| 28|#define OGS_NAS_EPS_AUTHENTICATION_REQUEST 82 ------------------ | Branch (5127:5): [True: 28, False: 3.84k] ------------------ 5128| 28| size = ogs_nas_eps_decode_authentication_request(message, pkbuf); 5129| 28| if (size < 0) { ------------------ | Branch (5129:13): [True: 13, False: 15] ------------------ 5130| 13| ogs_error("ogs_nas_eps_decode_authentication_request() failed"); ------------------ | | 36| 13|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 13| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 13|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 13| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 13|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 13| 0, __VA_ARGS__) | | ------------------ ------------------ 5131| 13| return OGS_ERROR; ------------------ | | 78| 13|#define OGS_ERROR -1 ------------------ 5132| 13| } 5133| | 5134| 15| decoded += size; 5135| 15| break; 5136| 28| case OGS_NAS_EPS_AUTHENTICATION_RESPONSE: ------------------ | | 86| 28|#define OGS_NAS_EPS_AUTHENTICATION_RESPONSE 83 ------------------ | Branch (5136:5): [True: 28, False: 3.84k] ------------------ 5137| 28| size = ogs_nas_eps_decode_authentication_response(message, pkbuf); 5138| 28| if (size < 0) { ------------------ | Branch (5138:13): [True: 5, False: 23] ------------------ 5139| 5| ogs_error("ogs_nas_eps_decode_authentication_response() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 5140| 5| return OGS_ERROR; ------------------ | | 78| 5|#define OGS_ERROR -1 ------------------ 5141| 5| } 5142| | 5143| 23| decoded += size; 5144| 23| break; 5145| 1| case OGS_NAS_EPS_AUTHENTICATION_REJECT: ------------------ | | 87| 1|#define OGS_NAS_EPS_AUTHENTICATION_REJECT 84 ------------------ | Branch (5145:5): [True: 1, False: 3.87k] ------------------ 5146| 1| break; 5147| 9| case OGS_NAS_EPS_IDENTITY_REQUEST: ------------------ | | 88| 9|#define OGS_NAS_EPS_IDENTITY_REQUEST 85 ------------------ | Branch (5147:5): [True: 9, False: 3.86k] ------------------ 5148| 9| size = ogs_nas_eps_decode_identity_request(message, pkbuf); 5149| 9| if (size < 0) { ------------------ | Branch (5149:13): [True: 0, False: 9] ------------------ 5150| 0| ogs_error("ogs_nas_eps_decode_identity_request() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 5151| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 5152| 0| } 5153| | 5154| 9| decoded += size; 5155| 9| break; 5156| 20| case OGS_NAS_EPS_IDENTITY_RESPONSE: ------------------ | | 89| 20|#define OGS_NAS_EPS_IDENTITY_RESPONSE 86 ------------------ | Branch (5156:5): [True: 20, False: 3.85k] ------------------ 5157| 20| size = ogs_nas_eps_decode_identity_response(message, pkbuf); 5158| 20| if (size < 0) { ------------------ | Branch (5158:13): [True: 5, False: 15] ------------------ 5159| 5| ogs_error("ogs_nas_eps_decode_identity_response() failed"); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 5160| 5| return OGS_ERROR; ------------------ | | 78| 5|#define OGS_ERROR -1 ------------------ 5161| 5| } 5162| | 5163| 15| decoded += size; 5164| 15| break; 5165| 73| case OGS_NAS_EPS_AUTHENTICATION_FAILURE: ------------------ | | 90| 73|#define OGS_NAS_EPS_AUTHENTICATION_FAILURE 92 ------------------ | Branch (5165:5): [True: 73, False: 3.80k] ------------------ 5166| 73| size = ogs_nas_eps_decode_authentication_failure(message, pkbuf); 5167| 73| if (size < 0) { ------------------ | Branch (5167:13): [True: 17, False: 56] ------------------ 5168| 17| ogs_error("ogs_nas_eps_decode_authentication_failure() failed"); ------------------ | | 36| 17|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 17| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 17|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 17| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 17|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 17| 0, __VA_ARGS__) | | ------------------ ------------------ 5169| 17| return OGS_ERROR; ------------------ | | 78| 17|#define OGS_ERROR -1 ------------------ 5170| 17| } 5171| | 5172| 56| decoded += size; 5173| 56| break; 5174| 121| case OGS_NAS_EPS_SECURITY_MODE_COMMAND: ------------------ | | 91| 121|#define OGS_NAS_EPS_SECURITY_MODE_COMMAND 93 ------------------ | Branch (5174:5): [True: 121, False: 3.75k] ------------------ 5175| 121| size = ogs_nas_eps_decode_security_mode_command(message, pkbuf); 5176| 121| if (size < 0) { ------------------ | Branch (5176:13): [True: 27, False: 94] ------------------ 5177| 27| ogs_error("ogs_nas_eps_decode_security_mode_command() failed"); ------------------ | | 36| 27|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 27| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 27|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 27| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 27|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 27| 0, __VA_ARGS__) | | ------------------ ------------------ 5178| 27| return OGS_ERROR; ------------------ | | 78| 27|#define OGS_ERROR -1 ------------------ 5179| 27| } 5180| | 5181| 94| decoded += size; 5182| 94| break; 5183| 153| case OGS_NAS_EPS_SECURITY_MODE_COMPLETE: ------------------ | | 92| 153|#define OGS_NAS_EPS_SECURITY_MODE_COMPLETE 94 ------------------ | Branch (5183:5): [True: 153, False: 3.72k] ------------------ 5184| 153| size = ogs_nas_eps_decode_security_mode_complete(message, pkbuf); 5185| 153| if (size < 0) { ------------------ | Branch (5185:13): [True: 60, False: 93] ------------------ 5186| 60| ogs_error("ogs_nas_eps_decode_security_mode_complete() failed"); ------------------ | | 36| 60|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 60| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 60|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 60| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 60|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 60| 0, __VA_ARGS__) | | ------------------ ------------------ 5187| 60| return OGS_ERROR; ------------------ | | 78| 60|#define OGS_ERROR -1 ------------------ 5188| 60| } 5189| | 5190| 93| decoded += size; 5191| 93| break; 5192| 1| case OGS_NAS_EPS_SECURITY_MODE_REJECT: ------------------ | | 93| 1|#define OGS_NAS_EPS_SECURITY_MODE_REJECT 95 ------------------ | Branch (5192:5): [True: 1, False: 3.87k] ------------------ 5193| 1| size = ogs_nas_eps_decode_security_mode_reject(message, pkbuf); 5194| 1| if (size < 0) { ------------------ | Branch (5194:13): [True: 0, False: 1] ------------------ 5195| 0| ogs_error("ogs_nas_eps_decode_security_mode_reject() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 5196| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 5197| 0| } 5198| | 5199| 1| decoded += size; 5200| 1| break; 5201| 1| case OGS_NAS_EPS_EMM_STATUS: ------------------ | | 94| 1|#define OGS_NAS_EPS_EMM_STATUS 96 ------------------ | Branch (5201:5): [True: 1, False: 3.87k] ------------------ 5202| 1| size = ogs_nas_eps_decode_emm_status(message, pkbuf); 5203| 1| if (size < 0) { ------------------ | Branch (5203:13): [True: 0, False: 1] ------------------ 5204| 0| ogs_error("ogs_nas_eps_decode_emm_status() failed"); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 5205| 0| return OGS_ERROR; ------------------ | | 78| 0|#define OGS_ERROR -1 ------------------ 5206| 0| } 5207| | 5208| 1| decoded += size; 5209| 1| break; 5210| 130| case OGS_NAS_EPS_EMM_INFORMATION: ------------------ | | 95| 130|#define OGS_NAS_EPS_EMM_INFORMATION 97 ------------------ | Branch (5210:5): [True: 130, False: 3.74k] ------------------ 5211| 130| size = ogs_nas_eps_decode_emm_information(message, pkbuf); 5212| 130| if (size < 0) { ------------------ | Branch (5212:13): [True: 38, False: 92] ------------------ 5213| 38| ogs_error("ogs_nas_eps_decode_emm_information() failed"); ------------------ | | 36| 38|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 38| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 38|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 38| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 38|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 38| 0, __VA_ARGS__) | | ------------------ ------------------ 5214| 38| return OGS_ERROR; ------------------ | | 78| 38|#define OGS_ERROR -1 ------------------ 5215| 38| } 5216| | 5217| 92| decoded += size; 5218| 92| break; 5219| 32| case OGS_NAS_EPS_DOWNLINK_NAS_TRANSPORT: ------------------ | | 96| 32|#define OGS_NAS_EPS_DOWNLINK_NAS_TRANSPORT 98 ------------------ | Branch (5219:5): [True: 32, False: 3.84k] ------------------ 5220| 32| size = ogs_nas_eps_decode_downlink_nas_transport(message, pkbuf); 5221| 32| if (size < 0) { ------------------ | Branch (5221:13): [True: 6, False: 26] ------------------ 5222| 6| ogs_error("ogs_nas_eps_decode_downlink_nas_transport() failed"); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 5223| 6| return OGS_ERROR; ------------------ | | 78| 6|#define OGS_ERROR -1 ------------------ 5224| 6| } 5225| | 5226| 26| decoded += size; 5227| 26| break; 5228| 31| case OGS_NAS_EPS_UPLINK_NAS_TRANSPORT: ------------------ | | 97| 31|#define OGS_NAS_EPS_UPLINK_NAS_TRANSPORT 99 ------------------ | Branch (5228:5): [True: 31, False: 3.84k] ------------------ 5229| 31| size = ogs_nas_eps_decode_uplink_nas_transport(message, pkbuf); 5230| 31| if (size < 0) { ------------------ | Branch (5230:13): [True: 4, False: 27] ------------------ 5231| 4| ogs_error("ogs_nas_eps_decode_uplink_nas_transport() failed"); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 5232| 4| return OGS_ERROR; ------------------ | | 78| 4|#define OGS_ERROR -1 ------------------ 5233| 4| } 5234| | 5235| 27| decoded += size; 5236| 27| break; 5237| 111| case OGS_NAS_EPS_CS_SERVICE_NOTIFICATION: ------------------ | | 98| 111|#define OGS_NAS_EPS_CS_SERVICE_NOTIFICATION 100 ------------------ | Branch (5237:5): [True: 111, False: 3.76k] ------------------ 5238| 111| size = ogs_nas_eps_decode_cs_service_notification(message, pkbuf); 5239| 111| if (size < 0) { ------------------ | Branch (5239:13): [True: 37, False: 74] ------------------ 5240| 37| ogs_error("ogs_nas_eps_decode_cs_service_notification() failed"); ------------------ | | 36| 37|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 37| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 37|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 37| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 37|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 37| 0, __VA_ARGS__) | | ------------------ ------------------ 5241| 37| return OGS_ERROR; ------------------ | | 78| 37|#define OGS_ERROR -1 ------------------ 5242| 37| } 5243| | 5244| 74| decoded += size; 5245| 74| break; 5246| 86| case OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT: ------------------ | | 99| 86|#define OGS_NAS_EPS_UPLINK_GENERIC_NAS_TRANSPORT 101 ------------------ | Branch (5246:5): [True: 86, False: 3.79k] ------------------ 5247| 86| size = ogs_nas_eps_decode_uplink_generic_nas_transport(message, pkbuf); 5248| 86| if (size < 0) { ------------------ | Branch (5248:13): [True: 20, False: 66] ------------------ 5249| 20| ogs_error("ogs_nas_eps_decode_uplink_generic_nas_transport() failed"); ------------------ | | 36| 20|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 5250| 20| return OGS_ERROR; ------------------ | | 78| 20|#define OGS_ERROR -1 ------------------ 5251| 20| } 5252| | 5253| 66| decoded += size; 5254| 66| break; 5255| 87| case OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT: ------------------ | | 100| 87|#define OGS_NAS_EPS_DOWNLINK_GENERIC_NAS_TRANSPORT 104 ------------------ | Branch (5255:5): [True: 87, False: 3.79k] ------------------ 5256| 87| size = ogs_nas_eps_decode_downlink_generic_nas_transport(message, pkbuf); 5257| 87| if (size < 0) { ------------------ | Branch (5257:13): [True: 20, False: 67] ------------------ 5258| 20| ogs_error("ogs_nas_eps_decode_downlink_generic_nas_transport() failed"); ------------------ | | 36| 20|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 5259| 20| return OGS_ERROR; ------------------ | | 78| 20|#define OGS_ERROR -1 ------------------ 5260| 20| } 5261| | 5262| 67| decoded += size; 5263| 67| break; 5264| 1| default: ------------------ | Branch (5264:5): [True: 1, False: 3.87k] ------------------ 5265| 1| ogs_error("Unknown message type (0x%x) or not implemented", ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 5266| 1| message->emm.h.message_type); 5267| 1| break; 5268| 3.87k| } 5269| | 5270| 2.92k|out: 5271| 2.92k| ogs_assert(ogs_pkbuf_push(pkbuf, decoded)); ------------------ | | 113| 2.92k| do { \ | | 114| 2.92k| if (ogs_likely(expr)) ; \ | | ------------------ | | | | 54| 2.92k|#define ogs_likely(x) __builtin_expect (!!(x), 1) | | | | ------------------ | | | | | Branch (54:23): [True: 2.92k, False: 0] | | | | ------------------ | | ------------------ | | 115| 2.92k| else { \ | | 116| 0| ogs_fatal("%s: Assertion `%s' failed.", OGS_FUNC, #expr); \ | | ------------------ | | | | 35| 0|#define ogs_fatal(...) ogs_log_message(OGS_LOG_FATAL, 0, __VA_ARGS__) | | | | ------------------ | | | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | | | ------------------ | | | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | | | ------------------ | | | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | | | ------------------ | | | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | | | ------------------ | | | | | | 45| 0| 0, __VA_ARGS__) | | | | ------------------ | | ------------------ | | 117| 0| ogs_abort(); \ | | 118| 0| } \ | | 119| 2.92k| } while(0) | | ------------------ | | | Branch (119:13): [Folded, False: 2.92k] | | ------------------ ------------------ 5272| | 5273| 2.92k| return OGS_OK; ------------------ | | 77| 2.92k|#define OGS_OK 0 ------------------ 5274| 2.92k|} ogs_nas_eps_decode_list_of_plmns_to_be_used_in_disaster_condition: 49| 471|{ 50| 471| int size = 0; 51| 471| ogs_nas_list_of_plmns_to_be_used_in_disaster_condition_t *source = NULL; 52| | 53| 471| if (pkbuf->len < 1) { ------------------ | Branch (53:9): [True: 5, False: 466] ------------------ 54| 5| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 55| 5| return -1; 56| 5| } 57| | 58| 466| source = (ogs_nas_list_of_plmns_to_be_used_in_disaster_condition_t *)pkbuf->data; 59| | 60| 466| list_of_plmns_to_be_used_in_disaster_condition->length = source->length; 61| 466| size = list_of_plmns_to_be_used_in_disaster_condition->length + sizeof(list_of_plmns_to_be_used_in_disaster_condition->length); 62| | 63| 466| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (63:9): [True: 3, False: 463] ------------------ 64| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 65| 3| return -1; 66| 3| } 67| | 68| 463| if (sizeof(*list_of_plmns_to_be_used_in_disaster_condition) < size) return -1; ------------------ | Branch (68:9): [True: 4, False: 459] ------------------ 69| 459| memcpy(list_of_plmns_to_be_used_in_disaster_condition, pkbuf->data - size, size); 70| | 71| 459| ogs_trace(" LIST_OF_PLMNS_TO_BE_USED_IN_DISASTER_CONDITION - "); ------------------ | | 40| 459|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 459| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 459|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 459| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 459|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 459| 0, __VA_ARGS__) | | ------------------ ------------------ 72| 459| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 459| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 459|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 73| | 74| 459| return size; 75| 463|} ogs_nas_eps_decode_additional_information: 95| 493|{ 96| 493| int size = 0; 97| 493| ogs_nas_additional_information_t *source = NULL; 98| | 99| 493| if (pkbuf->len < 1) { ------------------ | Branch (99:9): [True: 7, False: 486] ------------------ 100| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 101| 7| return -1; 102| 7| } 103| | 104| 486| source = (ogs_nas_additional_information_t *)pkbuf->data; 105| | 106| 486| additional_information->length = source->length; 107| 486| size = additional_information->length + sizeof(additional_information->length); 108| | 109| 486| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (109:9): [True: 3, False: 483] ------------------ 110| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 111| 3| return -1; 112| 3| } 113| | 114| 483| if (sizeof(*additional_information) < size) return -1; ------------------ | Branch (114:9): [True: 0, False: 483] ------------------ 115| 483| memcpy(additional_information, pkbuf->data - size, size); 116| | 117| 483| ogs_trace(" ADDITIONAL_INFORMATION - "); ------------------ | | 40| 483|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 483| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 483|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 483| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 483|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 483| 0, __VA_ARGS__) | | ------------------ ------------------ 118| 483| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 483| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 483|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 119| | 120| 483| return size; 121| 483|} ogs_nas_eps_decode_device_properties: 141| 2.55k|{ 142| 2.55k| int size = sizeof(ogs_nas_device_properties_t); 143| | 144| 2.55k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (144:9): [True: 0, False: 2.55k] ------------------ 145| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 146| 0| return -1; 147| 0| } 148| | 149| 2.55k| memcpy(device_properties, pkbuf->data - size, size); 150| | 151| 2.55k| ogs_trace(" DEVICE_PROPERTIES - "); ------------------ | | 40| 2.55k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.55k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.55k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.55k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.55k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.55k| 0, __VA_ARGS__) | | ------------------ ------------------ 152| 2.55k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.55k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.55k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 153| | 154| 2.55k| return size; 155| 2.55k|} ogs_nas_eps_decode_eps_bearer_context_status: 173| 932|{ 174| 932| int size = 0; 175| 932| ogs_nas_eps_bearer_context_status_t *source = NULL; 176| | 177| 932| if (pkbuf->len < 1) { ------------------ | Branch (177:9): [True: 10, False: 922] ------------------ 178| 10| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 179| 10| return -1; 180| 10| } 181| | 182| 922| source = (ogs_nas_eps_bearer_context_status_t *)pkbuf->data; 183| | 184| 922| eps_bearer_context_status->length = source->length; 185| 922| size = eps_bearer_context_status->length + sizeof(eps_bearer_context_status->length); 186| | 187| 922| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (187:9): [True: 9, False: 913] ------------------ 188| 9| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 189| 9| return -1; 190| 9| } 191| | 192| 913| if (sizeof(*eps_bearer_context_status) < size) return -1; ------------------ | Branch (192:9): [True: 4, False: 909] ------------------ 193| 909| memcpy(eps_bearer_context_status, pkbuf->data - size, size); 194| | 195| 909| ogs_trace(" EPS_BEARER_CONTEXT_STATUS - "); ------------------ | | 40| 909|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 909| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 909|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 909| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 909|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 909| 0, __VA_ARGS__) | | ------------------ ------------------ 196| 909| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 909| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 909|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 197| | 198| 909| return size; 199| 913|} ogs_nas_eps_decode_supported_codec_list: 219| 482|{ 220| 482| int size = 0; 221| 482| ogs_nas_supported_codec_list_t *source = NULL; 222| | 223| 482| if (pkbuf->len < 1) { ------------------ | Branch (223:9): [True: 3, False: 479] ------------------ 224| 3| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 225| 3| return -1; 226| 3| } 227| | 228| 479| source = (ogs_nas_supported_codec_list_t *)pkbuf->data; 229| | 230| 479| supported_codec_list->length = source->length; 231| 479| size = supported_codec_list->length + sizeof(supported_codec_list->length); 232| | 233| 479| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (233:9): [True: 1, False: 478] ------------------ 234| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 235| 1| return -1; 236| 1| } 237| | 238| 478| if (sizeof(*supported_codec_list) < size) return -1; ------------------ | Branch (238:9): [True: 2, False: 476] ------------------ 239| 476| memcpy(supported_codec_list, pkbuf->data - size, size); 240| | 241| 476| ogs_trace(" SUPPORTED_CODEC_LIST - "); ------------------ | | 40| 476|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 476| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 476|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 476| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 476|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 476| 0, __VA_ARGS__) | | ------------------ ------------------ 242| 476| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 476| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 476|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 243| | 244| 476| return size; 245| 478|} ogs_nas_eps_decode_location_area_identification: 265| 1.11k|{ 266| 1.11k| int size = sizeof(ogs_nas_location_area_identification_t); 267| | 268| 1.11k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (268:9): [True: 13, False: 1.09k] ------------------ 269| 13| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 13|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 13| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 13|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 13| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 13|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 13| 0, __VA_ARGS__) | | ------------------ ------------------ 270| 13| return -1; 271| 13| } 272| | 273| 1.09k| memcpy(location_area_identification, pkbuf->data - size, size); 274| | 275| 1.09k| location_area_identification->lac = be16toh(location_area_identification->lac); 276| | 277| 1.09k| ogs_trace(" LOCATION_AREA_IDENTIFICATION - "); ------------------ | | 40| 1.09k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.09k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.09k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.09k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.09k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.09k| 0, __VA_ARGS__) | | ------------------ ------------------ 278| 1.09k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.09k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.09k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 279| | 280| 1.09k| return size; 281| 1.11k|} ogs_nas_eps_decode_mobile_identity: 303| 1.22k|{ 304| 1.22k| int size = 0; 305| 1.22k| ogs_nas_mobile_identity_t *source = NULL; 306| | 307| 1.22k| if (pkbuf->len < 1) { ------------------ | Branch (307:9): [True: 10, False: 1.21k] ------------------ 308| 10| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 309| 10| return -1; 310| 10| } 311| | 312| 1.21k| source = (ogs_nas_mobile_identity_t *)pkbuf->data; 313| | 314| 1.21k| mobile_identity->length = source->length; 315| 1.21k| size = mobile_identity->length + sizeof(mobile_identity->length); 316| | 317| 1.21k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (317:9): [True: 11, False: 1.20k] ------------------ 318| 11| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 319| 11| return -1; 320| 11| } 321| | 322| 1.20k| if (sizeof(*mobile_identity) < size) return -1; ------------------ | Branch (322:9): [True: 2, False: 1.19k] ------------------ 323| 1.19k| memcpy(mobile_identity, pkbuf->data - size, size); 324| | 325| 1.19k| if (mobile_identity->tmsi.type == OGS_NAS_MOBILE_IDENTITY_TMSI) { ------------------ | | 74| 1.19k|#define OGS_NAS_MOBILE_IDENTITY_TMSI 4 ------------------ | Branch (325:9): [True: 195, False: 1.00k] ------------------ 326| 195| mobile_identity->tmsi.tmsi = be32toh(mobile_identity->tmsi.tmsi); 327| 195| } 328| | 329| 1.19k| ogs_trace(" MOBILE_IDENTITY - "); ------------------ | | 40| 1.19k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.19k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.19k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.19k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.19k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.19k| 0, __VA_ARGS__) | | ------------------ ------------------ 330| 1.19k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.19k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.19k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 331| | 332| 1.19k| return size; 333| 1.20k|} ogs_nas_eps_decode_mobile_station_classmark_2: 358| 547|{ 359| 547| int size = 0; 360| 547| ogs_nas_mobile_station_classmark_2_t *source = NULL; 361| | 362| 547| if (pkbuf->len < 1) { ------------------ | Branch (362:9): [True: 4, False: 543] ------------------ 363| 4| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 364| 4| return -1; 365| 4| } 366| | 367| 543| source = (ogs_nas_mobile_station_classmark_2_t *)pkbuf->data; 368| | 369| 543| mobile_station_classmark_2->length = source->length; 370| 543| size = mobile_station_classmark_2->length + sizeof(mobile_station_classmark_2->length); 371| | 372| 543| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (372:9): [True: 2, False: 541] ------------------ 373| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 374| 2| return -1; 375| 2| } 376| | 377| 541| if (sizeof(*mobile_station_classmark_2) < size) return -1; ------------------ | Branch (377:9): [True: 1, False: 540] ------------------ 378| 540| memcpy(mobile_station_classmark_2, pkbuf->data - size, size); 379| | 380| 540| ogs_trace(" MOBILE_STATION_CLASSMARK_2 - "); ------------------ | | 40| 540|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 540| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 540|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 540| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 540|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 540| 0, __VA_ARGS__) | | ------------------ ------------------ 381| 540| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 540| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 540|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 382| | 383| 540| return size; 384| 541|} ogs_nas_eps_decode_mobile_station_classmark_3: 404| 539|{ 405| 539| int size = 0; 406| 539| ogs_nas_mobile_station_classmark_3_t *source = NULL; 407| | 408| 539| if (pkbuf->len < 1) { ------------------ | Branch (408:9): [True: 7, False: 532] ------------------ 409| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 410| 7| return -1; 411| 7| } 412| | 413| 532| source = (ogs_nas_mobile_station_classmark_3_t *)pkbuf->data; 414| | 415| 532| mobile_station_classmark_3->length = source->length; 416| 532| size = mobile_station_classmark_3->length + sizeof(mobile_station_classmark_3->length); 417| | 418| 532| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (418:9): [True: 1, False: 531] ------------------ 419| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 420| 1| return -1; 421| 1| } 422| | 423| 531| if (sizeof(*mobile_station_classmark_3) < size) return -1; ------------------ | Branch (423:9): [True: 1, False: 530] ------------------ 424| 530| memcpy(mobile_station_classmark_3, pkbuf->data - size, size); 425| | 426| 530| ogs_trace(" MOBILE_STATION_CLASSMARK_3 - "); ------------------ | | 40| 530|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 530| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 530|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 530| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 530|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 530| 0, __VA_ARGS__) | | ------------------ ------------------ 427| 530| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 530| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 530|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 428| | 429| 530| return size; 430| 531|} ogs_nas_eps_decode_plmn_list: 450| 701|{ 451| 701| int size = 0; 452| 701| ogs_nas_plmn_list_t *source = NULL; 453| | 454| 701| if (pkbuf->len < 1) { ------------------ | Branch (454:9): [True: 8, False: 693] ------------------ 455| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 456| 8| return -1; 457| 8| } 458| | 459| 693| source = (ogs_nas_plmn_list_t *)pkbuf->data; 460| | 461| 693| plmn_list->length = source->length; 462| 693| size = plmn_list->length + sizeof(plmn_list->length); 463| | 464| 693| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (464:9): [True: 8, False: 685] ------------------ 465| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 466| 8| return -1; 467| 8| } 468| | 469| 685| if (sizeof(*plmn_list) < size) return -1; ------------------ | Branch (469:9): [True: 3, False: 682] ------------------ 470| 682| memcpy(plmn_list, pkbuf->data - size, size); 471| | 472| 682| ogs_trace(" PLMN_LIST - "); ------------------ | | 40| 682|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 682| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 682|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 682| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 682|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 682| 0, __VA_ARGS__) | | ------------------ ------------------ 473| 682| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 682| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 682|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 474| | 475| 682| return size; 476| 685|} ogs_nas_eps_decode_additional_update_result: 496| 6.00k|{ 497| 6.00k| int size = sizeof(ogs_nas_additional_update_result_t); 498| | 499| 6.00k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (499:9): [True: 0, False: 6.00k] ------------------ 500| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 501| 0| return -1; 502| 0| } 503| | 504| 6.00k| memcpy(additional_update_result, pkbuf->data - size, size); 505| | 506| 6.00k| ogs_trace(" ADDITIONAL_UPDATE_RESULT - "); ------------------ | | 40| 6.00k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6.00k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6.00k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6.00k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6.00k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6.00k| 0, __VA_ARGS__) | | ------------------ ------------------ 507| 6.00k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 6.00k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 6.00k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 508| | 509| 6.00k| return size; 510| 6.00k|} ogs_nas_eps_decode_additional_update_type: 528| 7.00k|{ 529| 7.00k| int size = sizeof(ogs_nas_additional_update_type_t); 530| | 531| 7.00k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (531:9): [True: 0, False: 7.00k] ------------------ 532| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 533| 0| return -1; 534| 0| } 535| | 536| 7.00k| memcpy(additional_update_type, pkbuf->data - size, size); 537| | 538| 7.00k| ogs_trace(" ADDITIONAL_UPDATE_TYPE - "); ------------------ | | 40| 7.00k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7.00k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7.00k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7.00k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7.00k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7.00k| 0, __VA_ARGS__) | | ------------------ ------------------ 539| 7.00k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 7.00k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 7.00k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 540| | 541| 7.00k| return size; 542| 7.00k|} ogs_nas_eps_decode_authentication_failure_parameter: 560| 484|{ 561| 484| int size = 0; 562| 484| ogs_nas_authentication_failure_parameter_t *source = NULL; 563| | 564| 484| if (pkbuf->len < 1) { ------------------ | Branch (564:9): [True: 6, False: 478] ------------------ 565| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 566| 6| return -1; 567| 6| } 568| | 569| 478| source = (ogs_nas_authentication_failure_parameter_t *)pkbuf->data; 570| | 571| 478| authentication_failure_parameter->length = source->length; 572| 478| size = authentication_failure_parameter->length + sizeof(authentication_failure_parameter->length); 573| | 574| 478| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (574:9): [True: 8, False: 470] ------------------ 575| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 576| 8| return -1; 577| 8| } 578| | 579| 470| if (sizeof(*authentication_failure_parameter) < size) return -1; ------------------ | Branch (579:9): [True: 3, False: 467] ------------------ 580| 467| memcpy(authentication_failure_parameter, pkbuf->data - size, size); 581| | 582| 467| ogs_trace(" AUTHENTICATION_FAILURE_PARAMETER - "); ------------------ | | 40| 467|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 467| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 467|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 467| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 467|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 467| 0, __VA_ARGS__) | | ------------------ ------------------ 583| 467| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 467| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 467|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 584| | 585| 467| return size; 586| 470|} ogs_nas_eps_decode_eps_attach_result: 606| 436|{ 607| 436| int size = sizeof(ogs_nas_eps_attach_result_t); 608| | 609| 436| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (609:9): [True: 0, False: 436] ------------------ 610| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 611| 0| return -1; 612| 0| } 613| | 614| 436| memcpy(eps_attach_result, pkbuf->data - size, size); 615| | 616| 436| ogs_trace(" EPS_ATTACH_RESULT - "); ------------------ | | 40| 436|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 436| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 436|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 436| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 436|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 436| 0, __VA_ARGS__) | | ------------------ ------------------ 617| 436| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 436| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 436|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 618| | 619| 436| return size; 620| 436|} ogs_nas_eps_decode_eps_attach_type: 640| 347|{ 641| 347| int size = sizeof(ogs_nas_eps_attach_type_t); 642| | 643| 347| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (643:9): [True: 0, False: 347] ------------------ 644| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 645| 0| return -1; 646| 0| } 647| | 648| 347| memcpy(eps_attach_type, pkbuf->data - size, size); 649| | 650| 347| ogs_trace(" EPS_ATTACH_TYPE - "); ------------------ | | 40| 347|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 347| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 347|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 347| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 347|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 347| 0, __VA_ARGS__) | | ------------------ ------------------ 651| 347| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 347| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 347|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 652| | 653| 347| return size; 654| 347|} ogs_nas_eps_decode_eps_mobile_identity: 674| 2.61k|{ 675| 2.61k| int size = 0; 676| 2.61k| ogs_nas_eps_mobile_identity_t *source = NULL; 677| | 678| 2.61k| if (pkbuf->len < 1) { ------------------ | Branch (678:9): [True: 9, False: 2.60k] ------------------ 679| 9| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 680| 9| return -1; 681| 9| } 682| | 683| 2.60k| source = (ogs_nas_eps_mobile_identity_t *)pkbuf->data; 684| | 685| 2.60k| eps_mobile_identity->length = source->length; 686| 2.60k| size = eps_mobile_identity->length + sizeof(eps_mobile_identity->length); 687| | 688| 2.60k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (688:9): [True: 9, False: 2.59k] ------------------ 689| 9| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 690| 9| return -1; 691| 9| } 692| | 693| 2.59k| if (sizeof(*eps_mobile_identity) < size) return -1; ------------------ | Branch (693:9): [True: 7, False: 2.58k] ------------------ 694| 2.58k| memcpy(eps_mobile_identity, pkbuf->data - size, size); 695| | 696| 2.58k| if (eps_mobile_identity->guti.type == OGS_NAS_EPS_MOBILE_IDENTITY_GUTI) { ------------------ | | 317| 2.58k|#define OGS_NAS_EPS_MOBILE_IDENTITY_GUTI 6 ------------------ | Branch (696:9): [True: 210, False: 2.37k] ------------------ 697| 210| eps_mobile_identity->guti.mme_gid = be16toh(eps_mobile_identity->guti.mme_gid); 698| 210| eps_mobile_identity->guti.m_tmsi = be32toh(eps_mobile_identity->guti.m_tmsi); 699| 210| } 700| | 701| 2.58k| ogs_trace(" EPS_MOBILE_IDENTITY - "); ------------------ | | 40| 2.58k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.58k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.58k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.58k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.58k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.58k| 0, __VA_ARGS__) | | ------------------ ------------------ 702| 2.58k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.58k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.58k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 703| | 704| 2.58k| return size; 705| 2.59k|} ogs_nas_eps_decode_eps_network_feature_support: 731| 622|{ 732| 622| int size = 0; 733| 622| ogs_nas_eps_network_feature_support_t *source = NULL; 734| | 735| 622| if (pkbuf->len < 1) { ------------------ | Branch (735:9): [True: 7, False: 615] ------------------ 736| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 737| 7| return -1; 738| 7| } 739| | 740| 615| source = (ogs_nas_eps_network_feature_support_t *)pkbuf->data; 741| | 742| 615| eps_network_feature_support->length = source->length; 743| 615| size = eps_network_feature_support->length + sizeof(eps_network_feature_support->length); 744| | 745| 615| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (745:9): [True: 5, False: 610] ------------------ 746| 5| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 747| 5| return -1; 748| 5| } 749| | 750| 610| if (sizeof(*eps_network_feature_support) < size) return -1; ------------------ | Branch (750:9): [True: 1, False: 609] ------------------ 751| 609| memcpy(eps_network_feature_support, pkbuf->data - size, size); 752| | 753| 609| ogs_trace(" EPS_NETWORK_FEATURE_SUPPORT - "); ------------------ | | 40| 609|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 609| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 609|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 609| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 609|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 609| 0, __VA_ARGS__) | | ------------------ ------------------ 754| 609| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 609| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 609|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 755| | 756| 609| return size; 757| 610|} ogs_nas_eps_decode_eps_update_result: 777| 794|{ 778| 794| int size = sizeof(ogs_nas_eps_update_result_t); 779| | 780| 794| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (780:9): [True: 0, False: 794] ------------------ 781| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 782| 0| return -1; 783| 0| } 784| | 785| 794| memcpy(eps_update_result, pkbuf->data - size, size); 786| | 787| 794| ogs_trace(" EPS_UPDATE_RESULT - "); ------------------ | | 40| 794|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 794| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 794|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 794| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 794|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 794| 0, __VA_ARGS__) | | ------------------ ------------------ 788| 794| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 794| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 794|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 789| | 790| 794| return size; 791| 794|} ogs_nas_eps_decode_eps_update_type: 811| 679|{ 812| 679| int size = sizeof(ogs_nas_eps_update_type_t); 813| | 814| 679| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (814:9): [True: 0, False: 679] ------------------ 815| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 816| 0| return -1; 817| 0| } 818| | 819| 679| memcpy(eps_update_type, pkbuf->data - size, size); 820| | 821| 679| ogs_trace(" EPS_UPDATE_TYPE - "); ------------------ | | 40| 679|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 679| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 679|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 679| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 679|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 679| 0, __VA_ARGS__) | | ------------------ ------------------ 822| 679| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 679| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 679|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 823| | 824| 679| return size; 825| 679|} ogs_nas_eps_decode_esm_message_container: 845| 1.07k|{ 846| 1.07k| int size = 0; 847| 1.07k| ogs_nas_esm_message_container_t *source = NULL; 848| | 849| 1.07k| if (pkbuf->len < 2) { ------------------ | Branch (849:9): [True: 17, False: 1.05k] ------------------ 850| 17| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 17|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 17| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 17|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 17| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 17|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 17| 0, __VA_ARGS__) | | ------------------ ------------------ 851| 17| return -1; 852| 17| } 853| | 854| 1.05k| source = (ogs_nas_esm_message_container_t *)pkbuf->data; 855| | 856| 1.05k| esm_message_container->length = be16toh(source->length); 857| 1.05k| size = esm_message_container->length + sizeof(esm_message_container->length); 858| | 859| 1.05k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (859:9): [True: 26, False: 1.03k] ------------------ 860| 26| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 26|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 26| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 26|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 26| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 26|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 26| 0, __VA_ARGS__) | | ------------------ ------------------ 861| 26| return -1; 862| 26| } 863| | 864| 1.03k| esm_message_container->buffer = pkbuf->data - size + sizeof(esm_message_container->length); 865| | 866| 1.03k| ogs_trace(" ESM_MESSAGE_CONTAINER - "); ------------------ | | 40| 1.03k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.03k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.03k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.03k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.03k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.03k| 0, __VA_ARGS__) | | ------------------ ------------------ 867| 1.03k| ogs_log_hexdump(OGS_LOG_TRACE, (void*)esm_message_container->buffer, esm_message_container->length); ------------------ | | 53| 1.03k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.03k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 868| | 869| 1.03k| return size; 870| 1.05k|} ogs_nas_eps_decode_gprs_timer: 898| 2.29k|{ 899| 2.29k| int size = sizeof(ogs_nas_gprs_timer_t); 900| | 901| 2.29k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (901:9): [True: 12, False: 2.27k] ------------------ 902| 12| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 12|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 903| 12| return -1; 904| 12| } 905| | 906| 2.27k| memcpy(gprs_timer, pkbuf->data - size, size); 907| | 908| 2.27k| ogs_trace(" GPRS_TIMER - "); ------------------ | | 40| 2.27k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.27k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.27k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.27k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.27k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.27k| 0, __VA_ARGS__) | | ------------------ ------------------ 909| 2.27k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.27k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.27k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 910| | 911| 2.27k| return size; 912| 2.29k|} ogs_nas_eps_decode_gprs_timer_2: 932| 2.37k|{ 933| 2.37k| int size = 0; 934| 2.37k| ogs_nas_gprs_timer_2_t *source = NULL; 935| | 936| 2.37k| if (pkbuf->len < 1) { ------------------ | Branch (936:9): [True: 11, False: 2.36k] ------------------ 937| 11| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 938| 11| return -1; 939| 11| } 940| | 941| 2.36k| source = (ogs_nas_gprs_timer_2_t *)pkbuf->data; 942| | 943| 2.36k| gprs_timer_2->length = source->length; 944| 2.36k| size = gprs_timer_2->length + sizeof(gprs_timer_2->length); 945| | 946| 2.36k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (946:9): [True: 12, False: 2.35k] ------------------ 947| 12| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 12|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 948| 12| return -1; 949| 12| } 950| | 951| 2.35k| if (sizeof(*gprs_timer_2) < size) return -1; ------------------ | Branch (951:9): [True: 10, False: 2.34k] ------------------ 952| 2.34k| memcpy(gprs_timer_2, pkbuf->data - size, size); 953| | 954| 2.34k| ogs_trace(" GPRS_TIMER_2 - "); ------------------ | | 40| 2.34k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.34k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.34k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.34k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.34k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.34k| 0, __VA_ARGS__) | | ------------------ ------------------ 955| 2.34k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.34k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.34k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 956| | 957| 2.34k| return size; 958| 2.35k|} ogs_nas_eps_decode_gprs_timer_3: 978| 2.53k|{ 979| 2.53k| int size = 0; 980| 2.53k| ogs_nas_gprs_timer_3_t *source = NULL; 981| | 982| 2.53k| if (pkbuf->len < 1) { ------------------ | Branch (982:9): [True: 11, False: 2.51k] ------------------ 983| 11| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 984| 11| return -1; 985| 11| } 986| | 987| 2.51k| source = (ogs_nas_gprs_timer_3_t *)pkbuf->data; 988| | 989| 2.51k| gprs_timer_3->length = source->length; 990| 2.51k| size = gprs_timer_3->length + sizeof(gprs_timer_3->length); 991| | 992| 2.51k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (992:9): [True: 12, False: 2.50k] ------------------ 993| 12| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 12|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 994| 12| return -1; 995| 12| } 996| | 997| 2.50k| if (sizeof(*gprs_timer_3) < size) return -1; ------------------ | Branch (997:9): [True: 6, False: 2.50k] ------------------ 998| 2.50k| memcpy(gprs_timer_3, pkbuf->data - size, size); 999| | 1000| 2.50k| ogs_trace(" GPRS_TIMER_3 - "); ------------------ | | 40| 2.50k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.50k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.50k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.50k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.50k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.50k| 0, __VA_ARGS__) | | ------------------ ------------------ 1001| 2.50k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.50k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.50k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1002| | 1003| 2.50k| return size; 1004| 2.50k|} ogs_nas_eps_decode_identity_type_2: 1024| 9|{ 1025| 9| int size = sizeof(ogs_nas_identity_type_2_t); 1026| | 1027| 9| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1027:9): [True: 0, False: 9] ------------------ 1028| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1029| 0| return -1; 1030| 0| } 1031| | 1032| 9| memcpy(identity_type_2, pkbuf->data - size, size); 1033| | 1034| 9| ogs_trace(" IDENTITY_TYPE_2 - "); ------------------ | | 40| 9|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1035| 9| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 9| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1036| | 1037| 9| return size; 1038| 9|} ogs_nas_eps_decode_imeisv_request: 1058| 519|{ 1059| 519| int size = sizeof(ogs_nas_imeisv_request_t); 1060| | 1061| 519| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1061:9): [True: 0, False: 519] ------------------ 1062| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1063| 0| return -1; 1064| 0| } 1065| | 1066| 519| memcpy(imeisv_request, pkbuf->data - size, size); 1067| | 1068| 519| ogs_trace(" IMEISV_REQUEST - "); ------------------ | | 40| 519|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 519| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 519|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 519| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 519|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 519| 0, __VA_ARGS__) | | ------------------ ------------------ 1069| 519| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 519| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 519|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1070| | 1071| 519| return size; 1072| 519|} ogs_nas_eps_decode_ksi_and_sequence_number: 1090| 12|{ 1091| 12| int size = sizeof(ogs_nas_ksi_and_sequence_number_t); 1092| | 1093| 12| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1093:9): [True: 0, False: 12] ------------------ 1094| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1095| 0| return -1; 1096| 0| } 1097| | 1098| 12| memcpy(ksi_and_sequence_number, pkbuf->data - size, size); 1099| | 1100| 12| ogs_trace(" KSI_AND_SEQUENCE_NUMBER - "); ------------------ | | 40| 12|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 1101| 12| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 12| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1102| | 1103| 12| return size; 1104| 12|} ogs_nas_eps_decode_authentication_parameter_autn: 1124| 20|{ 1125| 20| int size = 0; 1126| 20| ogs_nas_authentication_parameter_autn_t *source = NULL; 1127| | 1128| 20| if (pkbuf->len < 1) { ------------------ | Branch (1128:9): [True: 2, False: 18] ------------------ 1129| 2| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 1130| 2| return -1; 1131| 2| } 1132| | 1133| 18| source = (ogs_nas_authentication_parameter_autn_t *)pkbuf->data; 1134| | 1135| 18| authentication_parameter_autn->length = source->length; 1136| 18| size = authentication_parameter_autn->length + sizeof(authentication_parameter_autn->length); 1137| | 1138| 18| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1138:9): [True: 1, False: 17] ------------------ 1139| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1140| 1| return -1; 1141| 1| } 1142| | 1143| 17| if (sizeof(*authentication_parameter_autn) < size) return -1; ------------------ | Branch (1143:9): [True: 2, False: 15] ------------------ 1144| 15| memcpy(authentication_parameter_autn, pkbuf->data - size, size); 1145| | 1146| 15| ogs_trace(" AUTHENTICATION_PARAMETER_AUTN - "); ------------------ | | 40| 15|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 15| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 15|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 15| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 15|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 15| 0, __VA_ARGS__) | | ------------------ ------------------ 1147| 15| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 15| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 15|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1148| | 1149| 15| return size; 1150| 17|} ogs_nas_eps_decode_ms_network_capability: 1170| 471|{ 1171| 471| int size = 0; 1172| 471| ogs_nas_ms_network_capability_t *source = NULL; 1173| | 1174| 471| if (pkbuf->len < 1) { ------------------ | Branch (1174:9): [True: 6, False: 465] ------------------ 1175| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1176| 6| return -1; 1177| 6| } 1178| | 1179| 465| source = (ogs_nas_ms_network_capability_t *)pkbuf->data; 1180| | 1181| 465| ms_network_capability->length = source->length; 1182| 465| size = ms_network_capability->length + sizeof(ms_network_capability->length); 1183| | 1184| 465| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1184:9): [True: 1, False: 464] ------------------ 1185| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 1186| 1| return -1; 1187| 1| } 1188| | 1189| 464| if (sizeof(*ms_network_capability) < size) return -1; ------------------ | Branch (1189:9): [True: 3, False: 461] ------------------ 1190| 461| memcpy(ms_network_capability, pkbuf->data - size, size); 1191| | 1192| 461| ogs_trace(" MS_NETWORK_CAPABILITY - "); ------------------ | | 40| 461|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 461| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 461|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 461| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 461|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 461| 0, __VA_ARGS__) | | ------------------ ------------------ 1193| 461| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 461| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 461|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1194| | 1195| 461| return size; 1196| 464|} ogs_nas_eps_decode_ms_network_feature_support: 1216| 1.29k|{ 1217| 1.29k| int size = sizeof(ogs_nas_ms_network_feature_support_t); 1218| | 1219| 1.29k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1219:9): [True: 0, False: 1.29k] ------------------ 1220| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1221| 0| return -1; 1222| 0| } 1223| | 1224| 1.29k| memcpy(ms_network_feature_support, pkbuf->data - size, size); 1225| | 1226| 1.29k| ogs_trace(" MS_NETWORK_FEATURE_SUPPORT - "); ------------------ | | 40| 1.29k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.29k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.29k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.29k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.29k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.29k| 0, __VA_ARGS__) | | ------------------ ------------------ 1227| 1.29k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.29k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.29k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1228| | 1229| 1.29k| return size; 1230| 1.29k|} ogs_nas_eps_decode_key_set_identifier: 1248| 1.29k|{ 1249| 1.29k| int size = sizeof(ogs_nas_key_set_identifier_t); 1250| | 1251| 1.29k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1251:9): [True: 0, False: 1.29k] ------------------ 1252| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1253| 0| return -1; 1254| 0| } 1255| | 1256| 1.29k| memcpy(key_set_identifier, pkbuf->data - size, size); 1257| | 1258| 1.29k| ogs_trace(" KEY_SET_IDENTIFIER - "); ------------------ | | 40| 1.29k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.29k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.29k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.29k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.29k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.29k| 0, __VA_ARGS__) | | ------------------ ------------------ 1259| 1.29k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.29k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.29k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1260| | 1261| 1.29k| return size; 1262| 1.29k|} ogs_nas_eps_decode_eps_message_container: 1280| 63|{ 1281| 63| int size = 0; 1282| 63| ogs_nas_eps_message_container_t *source = NULL; 1283| | 1284| 63| if (pkbuf->len < 1) { ------------------ | Branch (1284:9): [True: 0, False: 63] ------------------ 1285| 0| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1286| 0| return -1; 1287| 0| } 1288| | 1289| 63| source = (ogs_nas_eps_message_container_t *)pkbuf->data; 1290| | 1291| 63| eps_message_container->length = source->length; 1292| 63| size = eps_message_container->length + sizeof(eps_message_container->length); 1293| | 1294| 63| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1294:9): [True: 8, False: 55] ------------------ 1295| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1296| 8| return -1; 1297| 8| } 1298| | 1299| 55| if (sizeof(*eps_message_container) < size) return -1; ------------------ | Branch (1299:9): [True: 2, False: 53] ------------------ 1300| 53| memcpy(eps_message_container, pkbuf->data - size, size); 1301| | 1302| 53| ogs_trace(" EPS_MESSAGE_CONTAINER - "); ------------------ | | 40| 53|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 53| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 53|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 53| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 53|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 53| 0, __VA_ARGS__) | | ------------------ ------------------ 1303| 53| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 53| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 53|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1304| | 1305| 53| return size; 1306| 55|} ogs_nas_eps_decode_security_algorithms: 1326| 121|{ 1327| 121| int size = sizeof(ogs_nas_security_algorithms_t); 1328| | 1329| 121| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1329:9): [True: 0, False: 121] ------------------ 1330| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1331| 0| return -1; 1332| 0| } 1333| | 1334| 121| memcpy(security_algorithms, pkbuf->data - size, size); 1335| | 1336| 121| ogs_trace(" SECURITY_ALGORITHMS - "); ------------------ | | 40| 121|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 121| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 121|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 121| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 121|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 121| 0, __VA_ARGS__) | | ------------------ ------------------ 1337| 121| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 121| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 121|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1338| | 1339| 121| return size; 1340| 121|} ogs_nas_eps_decode_network_name: 1360| 501|{ 1361| 501| int size = 0; 1362| 501| ogs_nas_network_name_t *source = NULL; 1363| | 1364| 501| if (pkbuf->len < 1) { ------------------ | Branch (1364:9): [True: 6, False: 495] ------------------ 1365| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1366| 6| return -1; 1367| 6| } 1368| | 1369| 495| source = (ogs_nas_network_name_t *)pkbuf->data; 1370| | 1371| 495| network_name->length = source->length; 1372| 495| size = network_name->length + sizeof(network_name->length); 1373| | 1374| 495| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1374:9): [True: 7, False: 488] ------------------ 1375| 7| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1376| 7| return -1; 1377| 7| } 1378| | 1379| 488| if (sizeof(*network_name) < size) return -1; ------------------ | Branch (1379:9): [True: 0, False: 488] ------------------ 1380| 488| memcpy(network_name, pkbuf->data - size, size); 1381| | 1382| 488| ogs_trace(" NETWORK_NAME - "); ------------------ | | 40| 488|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 488| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 488|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 488| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 488|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 488| 0, __VA_ARGS__) | | ------------------ ------------------ 1383| 488| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 488| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 488|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1384| | 1385| 488| return size; 1386| 488|} ogs_nas_eps_decode_network_resource_identifier_container: 1406| 503|{ 1407| 503| int size = 0; 1408| 503| ogs_nas_network_resource_identifier_container_t *source = NULL; 1409| | 1410| 503| if (pkbuf->len < 1) { ------------------ | Branch (1410:9): [True: 7, False: 496] ------------------ 1411| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 1412| 7| return -1; 1413| 7| } 1414| | 1415| 496| source = (ogs_nas_network_resource_identifier_container_t *)pkbuf->data; 1416| | 1417| 496| network_resource_identifier_container->length = source->length; 1418| 496| size = network_resource_identifier_container->length + sizeof(network_resource_identifier_container->length); 1419| | 1420| 496| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1420:9): [True: 8, False: 488] ------------------ 1421| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1422| 8| return -1; 1423| 8| } 1424| | 1425| 488| if (sizeof(*network_resource_identifier_container) < size) return -1; ------------------ | Branch (1425:9): [True: 1, False: 487] ------------------ 1426| 487| memcpy(network_resource_identifier_container, pkbuf->data - size, size); 1427| | 1428| 487| ogs_trace(" NETWORK_RESOURCE_IDENTIFIER_CONTAINER - "); ------------------ | | 40| 487|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 487| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 487|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 487| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 487|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 487| 0, __VA_ARGS__) | | ------------------ ------------------ 1429| 487| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 487| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 487|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1430| | 1431| 487| return size; 1432| 488|} ogs_nas_eps_decode_nonce: 1452| 775|{ 1453| 775| int size = sizeof(ogs_nas_nonce_t); 1454| | 1455| 775| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1455:9): [True: 11, False: 764] ------------------ 1456| 11| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 1457| 11| return -1; 1458| 11| } 1459| | 1460| 764| memcpy(nonce, pkbuf->data - size, size); 1461| | 1462| 764| *nonce = be32toh(*nonce); 1463| | 1464| 764| ogs_trace(" NONCE - "); ------------------ | | 40| 764|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 764| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 764|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 764| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 764|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 764| 0, __VA_ARGS__) | | ------------------ ------------------ 1465| 764| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 764| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 764|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1466| | 1467| 764| return size; 1468| 775|} ogs_nas_eps_decode_paging_identity: 1490| 111|{ 1491| 111| int size = sizeof(ogs_nas_paging_identity_t); 1492| | 1493| 111| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1493:9): [True: 0, False: 111] ------------------ 1494| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1495| 0| return -1; 1496| 0| } 1497| | 1498| 111| memcpy(paging_identity, pkbuf->data - size, size); 1499| | 1500| 111| ogs_trace(" PAGING_IDENTITY - "); ------------------ | | 40| 111|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 111| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 111|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 111| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 111|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 111| 0, __VA_ARGS__) | | ------------------ ------------------ 1501| 111| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 111| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 111|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1502| | 1503| 111| return size; 1504| 111|} ogs_nas_eps_decode_p_tmsi_signature: 1524| 647|{ 1525| 647| int size = 3; 1526| | 1527| 647| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1527:9): [True: 9, False: 638] ------------------ 1528| 9| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1529| 9| return -1; 1530| 9| } 1531| | 1532| 638| memcpy(p_tmsi_signature, pkbuf->data - size, size); 1533| | 1534| 638| *p_tmsi_signature = htobe32(*p_tmsi_signature); 1535| | 1536| 638| ogs_trace(" P_TMSI_SIGNATURE - "); ------------------ | | 40| 638|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 638| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 638|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 638| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 638|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 638| 0, __VA_ARGS__) | | ------------------ ------------------ 1537| 638| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 638| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 638|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1538| | 1539| 638| return size; 1540| 647|} ogs_nas_eps_decode_extended_emm_cause: 1562| 1.33k|{ 1563| 1.33k| int size = sizeof(ogs_nas_extended_emm_cause_t); 1564| | 1565| 1.33k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1565:9): [True: 0, False: 1.33k] ------------------ 1566| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1567| 0| return -1; 1568| 0| } 1569| | 1570| 1.33k| memcpy(extended_emm_cause, pkbuf->data - size, size); 1571| | 1572| 1.33k| ogs_trace(" EXTENDED_EMM_CAUSE - "); ------------------ | | 40| 1.33k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.33k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.33k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.33k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.33k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.33k| 0, __VA_ARGS__) | | ------------------ ------------------ 1573| 1.33k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.33k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.33k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1574| | 1575| 1.33k| return size; 1576| 1.33k|} ogs_nas_eps_decode_service_type: 1594| 120|{ 1595| 120| int size = sizeof(ogs_nas_service_type_t); 1596| | 1597| 120| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1597:9): [True: 0, False: 120] ------------------ 1598| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1599| 0| return -1; 1600| 0| } 1601| | 1602| 120| memcpy(service_type, pkbuf->data - size, size); 1603| | 1604| 120| ogs_trace(" SERVICE_TYPE - "); ------------------ | | 40| 120|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 120| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 120|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 120| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 120|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 120| 0, __VA_ARGS__) | | ------------------ ------------------ 1605| 120| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 120| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 120|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1606| | 1607| 120| return size; 1608| 120|} ogs_nas_eps_decode_short_mac: 1628| 12|{ 1629| 12| int size = sizeof(ogs_nas_short_mac_t); 1630| | 1631| 12| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1631:9): [True: 0, False: 12] ------------------ 1632| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1633| 0| return -1; 1634| 0| } 1635| | 1636| 12| memcpy(short_mac, pkbuf->data - size, size); 1637| | 1638| 12| *short_mac = be16toh(*short_mac); 1639| | 1640| 12| ogs_trace(" SHORT_MAC - "); ------------------ | | 40| 12|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 12| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 12| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 12|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 12| 0, __VA_ARGS__) | | ------------------ ------------------ 1641| 12| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 12| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 12|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1642| | 1643| 12| return size; 1644| 12|} ogs_nas_eps_decode_time_zone: 1666| 349|{ 1667| 349| int size = sizeof(ogs_nas_time_zone_t); 1668| | 1669| 349| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1669:9): [True: 5, False: 344] ------------------ 1670| 5| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 1671| 5| return -1; 1672| 5| } 1673| | 1674| 344| memcpy(time_zone, pkbuf->data - size, size); 1675| | 1676| 344| ogs_trace(" TIME_ZONE - "); ------------------ | | 40| 344|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 344| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 344|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 344| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 344|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 344| 0, __VA_ARGS__) | | ------------------ ------------------ 1677| 344| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 344| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 344|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1678| | 1679| 344| return size; 1680| 349|} ogs_nas_eps_decode_authentication_parameter_rand: 1700| 28|{ 1701| 28| int size = sizeof(ogs_nas_authentication_parameter_rand_t); 1702| | 1703| 28| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1703:9): [True: 8, False: 20] ------------------ 1704| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1705| 8| return -1; 1706| 8| } 1707| | 1708| 20| memcpy(authentication_parameter_rand, pkbuf->data - size, size); 1709| | 1710| 20| ogs_trace(" AUTHENTICATION_PARAMETER_RAND - "); ------------------ | | 40| 20|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 20| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 20| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 20|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 20| 0, __VA_ARGS__) | | ------------------ ------------------ 1711| 20| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 20| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 20|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1712| | 1713| 20| return size; 1714| 28|} ogs_nas_eps_decode_time_zone_and_time: 1734| 164|{ 1735| 164| int size = sizeof(ogs_nas_time_zone_and_time_t); 1736| | 1737| 164| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1737:9): [True: 9, False: 155] ------------------ 1738| 9| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 1739| 9| return -1; 1740| 9| } 1741| | 1742| 155| memcpy(time_zone_and_time, pkbuf->data - size, size); 1743| | 1744| 155| ogs_trace(" TIME_ZONE_AND_TIME - "); ------------------ | | 40| 155|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 155| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 155|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 155| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 155|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 155| 0, __VA_ARGS__) | | ------------------ ------------------ 1745| 155| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 155| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 155|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1746| | 1747| 155| return size; 1748| 164|} ogs_nas_eps_decode_tmsi_status: 1768| 2.15k|{ 1769| 2.15k| int size = sizeof(ogs_nas_tmsi_status_t); 1770| | 1771| 2.15k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1771:9): [True: 0, False: 2.15k] ------------------ 1772| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1773| 0| return -1; 1774| 0| } 1775| | 1776| 2.15k| memcpy(tmsi_status, pkbuf->data - size, size); 1777| | 1778| 2.15k| ogs_trace(" TMSI_STATUS - "); ------------------ | | 40| 2.15k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.15k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.15k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.15k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.15k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.15k| 0, __VA_ARGS__) | | ------------------ ------------------ 1779| 2.15k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.15k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.15k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1780| | 1781| 2.15k| return size; 1782| 2.15k|} ogs_nas_eps_decode_tracking_area_identity: 1800| 615|{ 1801| 615| int size = sizeof(ogs_nas_tracking_area_identity_t); 1802| | 1803| 615| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1803:9): [True: 10, False: 605] ------------------ 1804| 10| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 1805| 10| return -1; 1806| 10| } 1807| | 1808| 605| memcpy(tracking_area_identity, pkbuf->data - size, size); 1809| | 1810| 605| tracking_area_identity->tac = be16toh(tracking_area_identity->tac); 1811| | 1812| 605| ogs_trace(" TRACKING_AREA_IDENTITY - "); ------------------ | | 40| 605|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 605| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 605|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 605| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 605|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 605| 0, __VA_ARGS__) | | ------------------ ------------------ 1813| 605| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 605| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 605|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1814| | 1815| 605| return size; 1816| 615|} ogs_nas_eps_decode_tracking_area_identity_list: 1838| 3.15k|{ 1839| 3.15k| int size = 0; 1840| 3.15k| ogs_nas_tracking_area_identity_list_t *source = NULL; 1841| | 1842| 3.15k| if (pkbuf->len < 1) { ------------------ | Branch (1842:9): [True: 11, False: 3.14k] ------------------ 1843| 11| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 1844| 11| return -1; 1845| 11| } 1846| | 1847| 3.14k| source = (ogs_nas_tracking_area_identity_list_t *)pkbuf->data; 1848| | 1849| 3.14k| tracking_area_identity_list->length = source->length; 1850| 3.14k| size = tracking_area_identity_list->length + sizeof(tracking_area_identity_list->length); 1851| | 1852| 3.14k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1852:9): [True: 8, False: 3.13k] ------------------ 1853| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 1854| 8| return -1; 1855| 8| } 1856| | 1857| 3.13k| if (sizeof(*tracking_area_identity_list) < size) return -1; ------------------ | Branch (1857:9): [True: 3, False: 3.13k] ------------------ 1858| 3.13k| memcpy(tracking_area_identity_list, pkbuf->data - size, size); 1859| | 1860| 3.13k| ogs_trace(" TRACKING_AREA_IDENTITY_LIST - "); ------------------ | | 40| 3.13k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3.13k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3.13k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3.13k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3.13k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3.13k| 0, __VA_ARGS__) | | ------------------ ------------------ 1861| 3.13k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 3.13k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 3.13k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1862| | 1863| 3.13k| return size; 1864| 3.13k|} ogs_nas_eps_decode_ue_network_capability: 1884| 736|{ 1885| 736| int size = 0; 1886| 736| ogs_nas_ue_network_capability_t *source = NULL; 1887| | 1888| 736| if (pkbuf->len < 1) { ------------------ | Branch (1888:9): [True: 11, False: 725] ------------------ 1889| 11| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 11|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 11| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 11|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 11| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 11|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 11| 0, __VA_ARGS__) | | ------------------ ------------------ 1890| 11| return -1; 1891| 11| } 1892| | 1893| 725| source = (ogs_nas_ue_network_capability_t *)pkbuf->data; 1894| | 1895| 725| ue_network_capability->length = source->length; 1896| 725| size = ue_network_capability->length + sizeof(ue_network_capability->length); 1897| | 1898| 725| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1898:9): [True: 6, False: 719] ------------------ 1899| 6| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 1900| 6| return -1; 1901| 6| } 1902| | 1903| 719| if (sizeof(*ue_network_capability) < size) return -1; ------------------ | Branch (1903:9): [True: 2, False: 717] ------------------ 1904| 717| memcpy(ue_network_capability, pkbuf->data - size, size); 1905| | 1906| 717| ogs_trace(" UE_NETWORK_CAPABILITY - "); ------------------ | | 40| 717|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 717| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 717|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 717| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 717|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 717| 0, __VA_ARGS__) | | ------------------ ------------------ 1907| 717| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 717| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 717|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1908| | 1909| 717| return size; 1910| 719|} ogs_nas_eps_decode_ue_radio_capability_information_update_needed: 1930| 806|{ 1931| 806| int size = sizeof(ogs_nas_ue_radio_capability_information_update_needed_t); 1932| | 1933| 806| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1933:9): [True: 0, False: 806] ------------------ 1934| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1935| 0| return -1; 1936| 0| } 1937| | 1938| 806| memcpy(ue_radio_capability_information_update_needed, pkbuf->data - size, size); 1939| | 1940| 806| ogs_trace(" UE_RADIO_CAPABILITY_INFORMATION_UPDATE_NEEDED - "); ------------------ | | 40| 806|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 806| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 806|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 806| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 806|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 806| 0, __VA_ARGS__) | | ------------------ ------------------ 1941| 806| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 806| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 806|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1942| | 1943| 806| return size; 1944| 806|} ogs_nas_eps_decode_ue_security_capability: 1962| 121|{ 1963| 121| int size = 0; 1964| 121| ogs_nas_ue_security_capability_t *source = NULL; 1965| | 1966| 121| if (pkbuf->len < 1) { ------------------ | Branch (1966:9): [True: 0, False: 121] ------------------ 1967| 0| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 1968| 0| return -1; 1969| 0| } 1970| | 1971| 121| source = (ogs_nas_ue_security_capability_t *)pkbuf->data; 1972| | 1973| 121| ue_security_capability->length = source->length; 1974| 121| size = ue_security_capability->length + sizeof(ue_security_capability->length); 1975| | 1976| 121| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (1976:9): [True: 3, False: 118] ------------------ 1977| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 1978| 3| return -1; 1979| 3| } 1980| | 1981| 118| if (sizeof(*ue_security_capability) < size) return -1; ------------------ | Branch (1981:9): [True: 1, False: 117] ------------------ 1982| 117| memcpy(ue_security_capability, pkbuf->data - size, size); 1983| | 1984| 117| ogs_trace(" UE_SECURITY_CAPABILITY - "); ------------------ | | 40| 117|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 117| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 117|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 117| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 117|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 117| 0, __VA_ARGS__) | | ------------------ ------------------ 1985| 117| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 117| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 117|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 1986| | 1987| 117| return size; 1988| 118|} ogs_nas_eps_decode_emergency_number_list: 2008| 683|{ 2009| 683| int size = 0; 2010| 683| ogs_nas_emergency_number_list_t *source = NULL; 2011| | 2012| 683| if (pkbuf->len < 1) { ------------------ | Branch (2012:9): [True: 6, False: 677] ------------------ 2013| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2014| 6| return -1; 2015| 6| } 2016| | 2017| 677| source = (ogs_nas_emergency_number_list_t *)pkbuf->data; 2018| | 2019| 677| emergency_number_list->length = source->length; 2020| 677| size = emergency_number_list->length + sizeof(emergency_number_list->length); 2021| | 2022| 677| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2022:9): [True: 8, False: 669] ------------------ 2023| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2024| 8| return -1; 2025| 8| } 2026| | 2027| 669| if (sizeof(*emergency_number_list) < size) return -1; ------------------ | Branch (2027:9): [True: 4, False: 665] ------------------ 2028| 665| memcpy(emergency_number_list, pkbuf->data - size, size); 2029| | 2030| 665| ogs_trace(" EMERGENCY_NUMBER_LIST - "); ------------------ | | 40| 665|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 665| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 665|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 665| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 665|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 665| 0, __VA_ARGS__) | | ------------------ ------------------ 2031| 665| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 665| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 665|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2032| | 2033| 665| return size; 2034| 669|} ogs_nas_eps_decode_extended_emergency_number_list: 2054| 520|{ 2055| 520| int size = 0; 2056| 520| ogs_nas_extended_emergency_number_list_t *source = NULL; 2057| | 2058| 520| if (pkbuf->len < 2) { ------------------ | Branch (2058:9): [True: 8, False: 512] ------------------ 2059| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2060| 8| return -1; 2061| 8| } 2062| | 2063| 512| source = (ogs_nas_extended_emergency_number_list_t *)pkbuf->data; 2064| | 2065| 512| extended_emergency_number_list->length = be16toh(source->length); 2066| 512| size = extended_emergency_number_list->length + sizeof(extended_emergency_number_list->length); 2067| | 2068| 512| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2068:9): [True: 22, False: 490] ------------------ 2069| 22| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 22|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 22| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 22|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 22| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 22|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 22| 0, __VA_ARGS__) | | ------------------ ------------------ 2070| 22| return -1; 2071| 22| } 2072| | 2073| 490| extended_emergency_number_list->buffer = pkbuf->data - size + sizeof(extended_emergency_number_list->length); 2074| | 2075| 490| ogs_trace(" EXTENDED_EMERGENCY_NUMBER_LIST - "); ------------------ | | 40| 490|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 490| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 490|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 490| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 490|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 490| 0, __VA_ARGS__) | | ------------------ ------------------ 2076| 490| ogs_log_hexdump(OGS_LOG_TRACE, (void*)extended_emergency_number_list->buffer, extended_emergency_number_list->length); ------------------ | | 53| 490| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 490|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2077| | 2078| 490| return size; 2079| 512|} ogs_nas_eps_decode_cli: 2107| 402|{ 2108| 402| int size = 0; 2109| 402| ogs_nas_cli_t *source = NULL; 2110| | 2111| 402| if (pkbuf->len < 1) { ------------------ | Branch (2111:9): [True: 8, False: 394] ------------------ 2112| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2113| 8| return -1; 2114| 8| } 2115| | 2116| 394| source = (ogs_nas_cli_t *)pkbuf->data; 2117| | 2118| 394| cli->length = source->length; 2119| 394| size = cli->length + sizeof(cli->length); 2120| | 2121| 394| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2121:9): [True: 2, False: 392] ------------------ 2122| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2123| 2| return -1; 2124| 2| } 2125| | 2126| 392| if (sizeof(*cli) < size) return -1; ------------------ | Branch (2126:9): [True: 3, False: 389] ------------------ 2127| 389| memcpy(cli, pkbuf->data - size, size); 2128| | 2129| 389| ogs_trace(" CLI - "); ------------------ | | 40| 389|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 389| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 389|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 389| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 389|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 389| 0, __VA_ARGS__) | | ------------------ ------------------ 2130| 389| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 389| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 389|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2131| | 2132| 389| return size; 2133| 392|} ogs_nas_eps_decode_ss_code: 2153| 220|{ 2154| 220| int size = sizeof(ogs_nas_ss_code_t); 2155| | 2156| 220| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2156:9): [True: 5, False: 215] ------------------ 2157| 5| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2158| 5| return -1; 2159| 5| } 2160| | 2161| 215| memcpy(ss_code, pkbuf->data - size, size); 2162| | 2163| 215| ogs_trace(" SS_CODE - "); ------------------ | | 40| 215|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 215| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 215|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 215| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 215|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 215| 0, __VA_ARGS__) | | ------------------ ------------------ 2164| 215| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 215| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 215|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2165| | 2166| 215| return size; 2167| 220|} ogs_nas_eps_decode_access_technology_utilization_control: 2187| 1.53k|{ 2188| 1.53k| int size = 0; 2189| 1.53k| ogs_nas_access_technology_utilization_control_t *source = NULL; 2190| | 2191| 1.53k| if (pkbuf->len < 1) { ------------------ | Branch (2191:9): [True: 8, False: 1.52k] ------------------ 2192| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2193| 8| return -1; 2194| 8| } 2195| | 2196| 1.52k| source = (ogs_nas_access_technology_utilization_control_t *)pkbuf->data; 2197| | 2198| 1.52k| access_technology_utilization_control->length = source->length; 2199| 1.52k| size = access_technology_utilization_control->length + sizeof(access_technology_utilization_control->length); 2200| | 2201| 1.52k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2201:9): [True: 3, False: 1.52k] ------------------ 2202| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 2203| 3| return -1; 2204| 3| } 2205| | 2206| 1.52k| if (sizeof(*access_technology_utilization_control) < size) return -1; ------------------ | Branch (2206:9): [True: 1, False: 1.52k] ------------------ 2207| 1.52k| memcpy(access_technology_utilization_control, pkbuf->data - size, size); 2208| | 2209| 1.52k| ogs_trace(" ACCESS_TECHNOLOGY_UTILIZATION_CONTROL - "); ------------------ | | 40| 1.52k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.52k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.52k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.52k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.52k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.52k| 0, __VA_ARGS__) | | ------------------ ------------------ 2210| 1.52k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.52k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.52k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2211| | 2212| 1.52k| return size; 2213| 1.52k|} ogs_nas_eps_decode_authentication_response_parameter: 2233| 28|{ 2234| 28| int size = 0; 2235| 28| ogs_nas_authentication_response_parameter_t *source = NULL; 2236| | 2237| 28| if (pkbuf->len < 1) { ------------------ | Branch (2237:9): [True: 0, False: 28] ------------------ 2238| 0| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2239| 0| return -1; 2240| 0| } 2241| | 2242| 28| source = (ogs_nas_authentication_response_parameter_t *)pkbuf->data; 2243| | 2244| 28| authentication_response_parameter->length = source->length; 2245| 28| size = authentication_response_parameter->length + sizeof(authentication_response_parameter->length); 2246| | 2247| 28| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2247:9): [True: 2, False: 26] ------------------ 2248| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2249| 2| return -1; 2250| 2| } 2251| | 2252| 26| if (sizeof(*authentication_response_parameter) < size) return -1; ------------------ | Branch (2252:9): [True: 3, False: 23] ------------------ 2253| 23| memcpy(authentication_response_parameter, pkbuf->data - size, size); 2254| | 2255| 23| ogs_trace(" AUTHENTICATION_RESPONSE_PARAMETER - "); ------------------ | | 40| 23|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 23| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 23|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 23| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 23|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 23| 0, __VA_ARGS__) | | ------------------ ------------------ 2256| 23| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 23| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 23|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2257| | 2258| 23| return size; 2259| 26|} ogs_nas_eps_decode_lcs_indicator: 2279| 511|{ 2280| 511| int size = sizeof(ogs_nas_lcs_indicator_t); 2281| | 2282| 511| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2282:9): [True: 8, False: 503] ------------------ 2283| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2284| 8| return -1; 2285| 8| } 2286| | 2287| 503| memcpy(lcs_indicator, pkbuf->data - size, size); 2288| | 2289| 503| ogs_trace(" LCS_INDICATOR - "); ------------------ | | 40| 503|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 503| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 503|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 503| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 503|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 503| 0, __VA_ARGS__) | | ------------------ ------------------ 2290| 503| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 503| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 503|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2291| | 2292| 503| return size; 2293| 511|} ogs_nas_eps_decode_lcs_client_identity: 2313| 360|{ 2314| 360| int size = 0; 2315| 360| ogs_nas_lcs_client_identity_t *source = NULL; 2316| | 2317| 360| if (pkbuf->len < 1) { ------------------ | Branch (2317:9): [True: 5, False: 355] ------------------ 2318| 5| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2319| 5| return -1; 2320| 5| } 2321| | 2322| 355| source = (ogs_nas_lcs_client_identity_t *)pkbuf->data; 2323| | 2324| 355| lcs_client_identity->length = source->length; 2325| 355| size = lcs_client_identity->length + sizeof(lcs_client_identity->length); 2326| | 2327| 355| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2327:9): [True: 6, False: 349] ------------------ 2328| 6| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2329| 6| return -1; 2330| 6| } 2331| | 2332| 349| if (sizeof(*lcs_client_identity) < size) return -1; ------------------ | Branch (2332:9): [True: 0, False: 349] ------------------ 2333| 349| memcpy(lcs_client_identity, pkbuf->data - size, size); 2334| | 2335| 349| ogs_trace(" LCS_CLIENT_IDENTITY - "); ------------------ | | 40| 349|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 349| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 349|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 349| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 349|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 349| 0, __VA_ARGS__) | | ------------------ ------------------ 2336| 349| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 349| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 349|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2337| | 2338| 349| return size; 2339| 349|} ogs_nas_eps_decode_generic_message_container_type: 2359| 173|{ 2360| 173| int size = sizeof(ogs_nas_generic_message_container_type_t); 2361| | 2362| 173| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2362:9): [True: 0, False: 173] ------------------ 2363| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2364| 0| return -1; 2365| 0| } 2366| | 2367| 173| memcpy(generic_message_container_type, pkbuf->data - size, size); 2368| | 2369| 173| ogs_trace(" GENERIC_MESSAGE_CONTAINER_TYPE - "); ------------------ | | 40| 173|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 173| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 173|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 173| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 173|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 173| 0, __VA_ARGS__) | | ------------------ ------------------ 2370| 173| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 173| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 173|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2371| | 2372| 173| return size; 2373| 173|} ogs_nas_eps_decode_generic_message_container: 2393| 173|{ 2394| 173| int size = 0; 2395| 173| ogs_nas_generic_message_container_t *source = NULL; 2396| | 2397| 173| if (pkbuf->len < 2) { ------------------ | Branch (2397:9): [True: 0, False: 173] ------------------ 2398| 0| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2399| 0| return -1; 2400| 0| } 2401| | 2402| 173| source = (ogs_nas_generic_message_container_t *)pkbuf->data; 2403| | 2404| 173| generic_message_container->length = be16toh(source->length); 2405| 173| size = generic_message_container->length + sizeof(generic_message_container->length); 2406| | 2407| 173| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2407:9): [True: 30, False: 143] ------------------ 2408| 30| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 30|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 30| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 30|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 30| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 30|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 30| 0, __VA_ARGS__) | | ------------------ ------------------ 2409| 30| return -1; 2410| 30| } 2411| | 2412| 143| generic_message_container->buffer = pkbuf->data - size + sizeof(generic_message_container->length); 2413| | 2414| 143| ogs_trace(" GENERIC_MESSAGE_CONTAINER - "); ------------------ | | 40| 143|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 143| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 143|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 143| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 143|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 143| 0, __VA_ARGS__) | | ------------------ ------------------ 2415| 143| ogs_log_hexdump(OGS_LOG_TRACE, (void*)generic_message_container->buffer, generic_message_container->length); ------------------ | | 53| 143| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 143|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2416| | 2417| 143| return size; 2418| 173|} ogs_nas_eps_decode_voice_domain_preference_and_ue_usage_setting: 2446| 449|{ 2447| 449| int size = 0; 2448| 449| ogs_nas_voice_domain_preference_and_ue_usage_setting_t *source = NULL; 2449| | 2450| 449| if (pkbuf->len < 1) { ------------------ | Branch (2450:9): [True: 6, False: 443] ------------------ 2451| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2452| 6| return -1; 2453| 6| } 2454| | 2455| 443| source = (ogs_nas_voice_domain_preference_and_ue_usage_setting_t *)pkbuf->data; 2456| | 2457| 443| voice_domain_preference_and_ue_usage_setting->length = source->length; 2458| 443| size = voice_domain_preference_and_ue_usage_setting->length + sizeof(voice_domain_preference_and_ue_usage_setting->length); 2459| | 2460| 443| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2460:9): [True: 1, False: 442] ------------------ 2461| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2462| 1| return -1; 2463| 1| } 2464| | 2465| 442| if (sizeof(*voice_domain_preference_and_ue_usage_setting) < size) return -1; ------------------ | Branch (2465:9): [True: 2, False: 440] ------------------ 2466| 440| memcpy(voice_domain_preference_and_ue_usage_setting, pkbuf->data - size, size); 2467| | 2468| 440| ogs_trace(" VOICE_DOMAIN_PREFERENCE_AND_UE_USAGE_SETTING - "); ------------------ | | 40| 440|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 440| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 440|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 440| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 440|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 440| 0, __VA_ARGS__) | | ------------------ ------------------ 2469| 440| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 440| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 440|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2470| | 2471| 440| return size; 2472| 442|} ogs_nas_eps_decode_guti_type: 2492| 2.11k|{ 2493| 2.11k| int size = sizeof(ogs_nas_guti_type_t); 2494| | 2495| 2.11k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2495:9): [True: 0, False: 2.11k] ------------------ 2496| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2497| 0| return -1; 2498| 0| } 2499| | 2500| 2.11k| memcpy(guti_type, pkbuf->data - size, size); 2501| | 2502| 2.11k| ogs_trace(" GUTI_TYPE - "); ------------------ | | 40| 2.11k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.11k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.11k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.11k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.11k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.11k| 0, __VA_ARGS__) | | ------------------ ------------------ 2503| 2.11k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.11k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.11k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2504| | 2505| 2.11k| return size; 2506| 2.11k|} ogs_nas_eps_decode_extended_drx_parameters: 2524| 1.07k|{ 2525| 1.07k| int size = 0; 2526| 1.07k| ogs_nas_extended_drx_parameters_t *source = NULL; 2527| | 2528| 1.07k| if (pkbuf->len < 1) { ------------------ | Branch (2528:9): [True: 8, False: 1.07k] ------------------ 2529| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2530| 8| return -1; 2531| 8| } 2532| | 2533| 1.07k| source = (ogs_nas_extended_drx_parameters_t *)pkbuf->data; 2534| | 2535| 1.07k| extended_drx_parameters->length = source->length; 2536| 1.07k| size = extended_drx_parameters->length + sizeof(extended_drx_parameters->length); 2537| | 2538| 1.07k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2538:9): [True: 5, False: 1.06k] ------------------ 2539| 5| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 2540| 5| return -1; 2541| 5| } 2542| | 2543| 1.06k| if (sizeof(*extended_drx_parameters) < size) return -1; ------------------ | Branch (2543:9): [True: 1, False: 1.06k] ------------------ 2544| 1.06k| memcpy(extended_drx_parameters, pkbuf->data - size, size); 2545| | 2546| 1.06k| ogs_trace(" EXTENDED_DRX_PARAMETERS - "); ------------------ | | 40| 1.06k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.06k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.06k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.06k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.06k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.06k| 0, __VA_ARGS__) | | ------------------ ------------------ 2547| 1.06k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.06k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.06k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2548| | 2549| 1.06k| return size; 2550| 1.06k|} ogs_nas_eps_decode_dcn_id: 2570| 756|{ 2571| 756| int size = 0; 2572| 756| ogs_nas_dcn_id_t *source = NULL; 2573| | 2574| 756| if (pkbuf->len < 1) { ------------------ | Branch (2574:9): [True: 8, False: 748] ------------------ 2575| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2576| 8| return -1; 2577| 8| } 2578| | 2579| 748| source = (ogs_nas_dcn_id_t *)pkbuf->data; 2580| | 2581| 748| dcn_id->length = source->length; 2582| 748| size = dcn_id->length + sizeof(dcn_id->length); 2583| | 2584| 748| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2584:9): [True: 6, False: 742] ------------------ 2585| 6| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 2586| 6| return -1; 2587| 6| } 2588| | 2589| 742| if (sizeof(*dcn_id) < size) return -1; ------------------ | Branch (2589:9): [True: 2, False: 740] ------------------ 2590| 740| memcpy(dcn_id, pkbuf->data - size, size); 2591| | 2592| 740| ogs_trace(" DCN_ID - "); ------------------ | | 40| 740|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 740| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 740|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 740| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 740|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 740| 0, __VA_ARGS__) | | ------------------ ------------------ 2593| 740| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 740| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 740|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2594| | 2595| 740| return size; 2596| 742|} ogs_nas_eps_decode_non_nw_provided_policies: 2616| 1.72k|{ 2617| 1.72k| int size = sizeof(ogs_nas_non_nw_provided_policies_t); 2618| | 2619| 1.72k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2619:9): [True: 0, False: 1.72k] ------------------ 2620| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2621| 0| return -1; 2622| 0| } 2623| | 2624| 1.72k| memcpy(non_nw_provided_policies, pkbuf->data - size, size); 2625| | 2626| 1.72k| ogs_trace(" NON__NW_PROVIDED_POLICIES - "); ------------------ | | 40| 1.72k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.72k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.72k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.72k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.72k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.72k| 0, __VA_ARGS__) | | ------------------ ------------------ 2627| 1.72k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.72k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.72k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2628| | 2629| 1.72k| return size; 2630| 1.72k|} ogs_nas_eps_decode_sms_services_status: 2648| 2.03k|{ 2649| 2.03k| int size = sizeof(ogs_nas_sms_services_status_t); 2650| | 2651| 2.03k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2651:9): [True: 0, False: 2.03k] ------------------ 2652| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2653| 0| return -1; 2654| 0| } 2655| | 2656| 2.03k| memcpy(sms_services_status, pkbuf->data - size, size); 2657| | 2658| 2.03k| ogs_trace(" SMS_SERVICES_STATUS - "); ------------------ | | 40| 2.03k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.03k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.03k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.03k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.03k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.03k| 0, __VA_ARGS__) | | ------------------ ------------------ 2659| 2.03k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.03k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.03k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2660| | 2661| 2.03k| return size; 2662| 2.03k|} ogs_nas_eps_decode_ciphering_key_sequence_number: 2680| 1.12k|{ 2681| 1.12k| int size = sizeof(ogs_nas_ciphering_key_sequence_number_t); 2682| | 2683| 1.12k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2683:9): [True: 0, False: 1.12k] ------------------ 2684| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2685| 0| return -1; 2686| 0| } 2687| | 2688| 1.12k| memcpy(ciphering_key_sequence_number, pkbuf->data - size, size); 2689| | 2690| 1.12k| ogs_trace(" CIPHERING_KEY_SEQUENCE_NUMBER - "); ------------------ | | 40| 1.12k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.12k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.12k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.12k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.12k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.12k| 0, __VA_ARGS__) | | ------------------ ------------------ 2691| 1.12k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.12k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.12k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2692| | 2693| 1.12k| return size; 2694| 1.12k|} ogs_nas_eps_decode_csfb_response: 2712| 739|{ 2713| 739| int size = sizeof(ogs_nas_csfb_response_t); 2714| | 2715| 739| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2715:9): [True: 0, False: 739] ------------------ 2716| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2717| 0| return -1; 2718| 0| } 2719| | 2720| 739| memcpy(csfb_response, pkbuf->data - size, size); 2721| | 2722| 739| ogs_trace(" CSFB_RESPONSE - "); ------------------ | | 40| 739|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 739| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 739|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 739| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 739|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 739| 0, __VA_ARGS__) | | ------------------ ------------------ 2723| 739| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 739| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 739|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2724| | 2725| 739| return size; 2726| 739|} ogs_nas_eps_decode_hashmme: 2744| 362|{ 2745| 362| int size = 0; 2746| 362| ogs_nas_hashmme_t *source = NULL; 2747| | 2748| 362| if (pkbuf->len < 1) { ------------------ | Branch (2748:9): [True: 7, False: 355] ------------------ 2749| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 2750| 7| return -1; 2751| 7| } 2752| | 2753| 355| source = (ogs_nas_hashmme_t *)pkbuf->data; 2754| | 2755| 355| hashmme->length = source->length; 2756| 355| size = hashmme->length + sizeof(hashmme->length); 2757| | 2758| 355| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2758:9): [True: 1, False: 354] ------------------ 2759| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 2760| 1| return -1; 2761| 1| } 2762| | 2763| 354| if (sizeof(*hashmme) < size) return -1; ------------------ | Branch (2763:9): [True: 2, False: 352] ------------------ 2764| 352| memcpy(hashmme, pkbuf->data - size, size); 2765| | 2766| 352| ogs_trace(" HASHMME - "); ------------------ | | 40| 352|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 352| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 352|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 352| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 352|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 352| 0, __VA_ARGS__) | | ------------------ ------------------ 2767| 352| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 352| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 352|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2768| | 2769| 352| return size; 2770| 354|} ogs_nas_eps_decode_replayed_nas_message_container: 2790| 411|{ 2791| 411| int size = 0; 2792| 411| ogs_nas_replayed_nas_message_container_t *source = NULL; 2793| | 2794| 411| if (pkbuf->len < 2) { ------------------ | Branch (2794:9): [True: 9, False: 402] ------------------ 2795| 9| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 2796| 9| return -1; 2797| 9| } 2798| | 2799| 402| source = (ogs_nas_replayed_nas_message_container_t *)pkbuf->data; 2800| | 2801| 402| replayed_nas_message_container->length = be16toh(source->length); 2802| 402| size = replayed_nas_message_container->length + sizeof(replayed_nas_message_container->length); 2803| | 2804| 402| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2804:9): [True: 27, False: 375] ------------------ 2805| 27| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 27|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 27| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 27|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 27| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 27|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 27| 0, __VA_ARGS__) | | ------------------ ------------------ 2806| 27| return -1; 2807| 27| } 2808| | 2809| 375| replayed_nas_message_container->buffer = pkbuf->data - size + sizeof(replayed_nas_message_container->length); 2810| | 2811| 375| ogs_trace(" REPLAYED_NAS_MESSAGE_CONTAINER - "); ------------------ | | 40| 375|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 375| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 375|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 375| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 375|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 375| 0, __VA_ARGS__) | | ------------------ ------------------ 2812| 375| ogs_log_hexdump(OGS_LOG_TRACE, (void*)replayed_nas_message_container->buffer, replayed_nas_message_container->length); ------------------ | | 53| 375| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 375|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2813| | 2814| 375| return size; 2815| 402|} ogs_nas_eps_decode_network_policy: 2843| 1.25k|{ 2844| 1.25k| int size = sizeof(ogs_nas_network_policy_t); 2845| | 2846| 1.25k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2846:9): [True: 0, False: 1.25k] ------------------ 2847| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 2848| 0| return -1; 2849| 0| } 2850| | 2851| 1.25k| memcpy(network_policy, pkbuf->data - size, size); 2852| | 2853| 1.25k| ogs_trace(" NETWORK_POLICY - "); ------------------ | | 40| 1.25k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.25k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.25k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.25k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.25k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.25k| 0, __VA_ARGS__) | | ------------------ ------------------ 2854| 1.25k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.25k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.25k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2855| | 2856| 1.25k| return size; 2857| 1.25k|} ogs_nas_eps_decode_ue_additional_security_capability: 2875| 686|{ 2876| 686| int size = 0; 2877| 686| ogs_nas_ue_additional_security_capability_t *source = NULL; 2878| | 2879| 686| if (pkbuf->len < 1) { ------------------ | Branch (2879:9): [True: 8, False: 678] ------------------ 2880| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 2881| 8| return -1; 2882| 8| } 2883| | 2884| 678| source = (ogs_nas_ue_additional_security_capability_t *)pkbuf->data; 2885| | 2886| 678| ue_additional_security_capability->length = source->length; 2887| 678| size = ue_additional_security_capability->length + sizeof(ue_additional_security_capability->length); 2888| | 2889| 678| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2889:9): [True: 2, False: 676] ------------------ 2890| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2891| 2| return -1; 2892| 2| } 2893| | 2894| 676| if (sizeof(*ue_additional_security_capability) < size) return -1; ------------------ | Branch (2894:9): [True: 2, False: 674] ------------------ 2895| 674| memcpy(ue_additional_security_capability, pkbuf->data - size, size); 2896| | 2897| 674| ogs_trace(" UE_ADDITIONAL_SECURITY_CAPABILITY - "); ------------------ | | 40| 674|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 674| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 674|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 674| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 674|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 674| 0, __VA_ARGS__) | | ------------------ ------------------ 2898| 674| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 674| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 674|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2899| | 2900| 674| return size; 2901| 676|} ogs_nas_eps_decode_ue_status: 2921| 502|{ 2922| 502| int size = 0; 2923| 502| ogs_nas_ue_status_t *source = NULL; 2924| | 2925| 502| if (pkbuf->len < 1) { ------------------ | Branch (2925:9): [True: 7, False: 495] ------------------ 2926| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 2927| 7| return -1; 2928| 7| } 2929| | 2930| 495| source = (ogs_nas_ue_status_t *)pkbuf->data; 2931| | 2932| 495| ue_status->length = source->length; 2933| 495| size = ue_status->length + sizeof(ue_status->length); 2934| | 2935| 495| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2935:9): [True: 2, False: 493] ------------------ 2936| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 2937| 2| return -1; 2938| 2| } 2939| | 2940| 493| if (sizeof(*ue_status) < size) return -1; ------------------ | Branch (2940:9): [True: 3, False: 490] ------------------ 2941| 490| memcpy(ue_status, pkbuf->data - size, size); 2942| | 2943| 490| ogs_trace(" UE_STATUS - "); ------------------ | | 40| 490|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 490| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 490|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 490| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 490|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 490| 0, __VA_ARGS__) | | ------------------ ------------------ 2944| 490| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 490| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 490|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2945| | 2946| 490| return size; 2947| 493|} ogs_nas_eps_decode_additional_information_requested: 2967| 768|{ 2968| 768| int size = sizeof(ogs_nas_additional_information_requested_t); 2969| | 2970| 768| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (2970:9): [True: 10, False: 758] ------------------ 2971| 10| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 2972| 10| return -1; 2973| 10| } 2974| | 2975| 758| memcpy(additional_information_requested, pkbuf->data - size, size); 2976| | 2977| 758| ogs_trace(" ADDITIONAL_INFORMATION_REQUESTED - "); ------------------ | | 40| 758|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 758| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 758|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 758| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 758|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 758| 0, __VA_ARGS__) | | ------------------ ------------------ 2978| 758| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 758| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 758|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 2979| | 2980| 758| return size; 2981| 768|} ogs_nas_eps_decode_ciphering_key_data: 3001| 674|{ 3002| 674| int size = 0; 3003| 674| ogs_nas_ciphering_key_data_t *source = NULL; 3004| | 3005| 674| if (pkbuf->len < 2) { ------------------ | Branch (3005:9): [True: 9, False: 665] ------------------ 3006| 9| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 3007| 9| return -1; 3008| 9| } 3009| | 3010| 665| source = (ogs_nas_ciphering_key_data_t *)pkbuf->data; 3011| | 3012| 665| ciphering_key_data->length = be16toh(source->length); 3013| 665| size = ciphering_key_data->length + sizeof(ciphering_key_data->length); 3014| | 3015| 665| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3015:9): [True: 27, False: 638] ------------------ 3016| 27| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 27|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 27| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 27|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 27| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 27|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 27| 0, __VA_ARGS__) | | ------------------ ------------------ 3017| 27| return -1; 3018| 27| } 3019| | 3020| 638| ciphering_key_data->buffer = pkbuf->data - size + sizeof(ciphering_key_data->length); 3021| | 3022| 638| ogs_trace(" CIPHERING_KEY_DATA - "); ------------------ | | 40| 638|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 638| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 638|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 638| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 638|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 638| 0, __VA_ARGS__) | | ------------------ ------------------ 3023| 638| ogs_log_hexdump(OGS_LOG_TRACE, (void*)ciphering_key_data->buffer, ciphering_key_data->length); ------------------ | | 53| 638| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 638|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3024| | 3025| 638| return size; 3026| 665|} ogs_nas_eps_decode_n1_ue_network_capability: 3054| 637|{ 3055| 637| int size = 0; 3056| 637| ogs_nas_n1_ue_network_capability_t *source = NULL; 3057| | 3058| 637| if (pkbuf->len < 1) { ------------------ | Branch (3058:9): [True: 7, False: 630] ------------------ 3059| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 3060| 7| return -1; 3061| 7| } 3062| | 3063| 630| source = (ogs_nas_n1_ue_network_capability_t *)pkbuf->data; 3064| | 3065| 630| n1_ue_network_capability->length = source->length; 3066| 630| size = n1_ue_network_capability->length + sizeof(n1_ue_network_capability->length); 3067| | 3068| 630| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3068:9): [True: 7, False: 623] ------------------ 3069| 7| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 3070| 7| return -1; 3071| 7| } 3072| | 3073| 623| if (sizeof(*n1_ue_network_capability) < size) return -1; ------------------ | Branch (3073:9): [True: 2, False: 621] ------------------ 3074| 621| memcpy(n1_ue_network_capability, pkbuf->data - size, size); 3075| | 3076| 621| ogs_trace(" N1_UE_NETWORK_CAPABILITY - "); ------------------ | | 40| 621|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 621| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 621|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 621| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 621|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 621| 0, __VA_ARGS__) | | ------------------ ------------------ 3077| 621| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 621| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 621|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3078| | 3079| 621| return size; 3080| 623|} ogs_nas_eps_decode_ue_radio_capability_id_availability: 3100| 751|{ 3101| 751| int size = 0; 3102| 751| ogs_nas_ue_radio_capability_id_availability_t *source = NULL; 3103| | 3104| 751| if (pkbuf->len < 1) { ------------------ | Branch (3104:9): [True: 8, False: 743] ------------------ 3105| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 3106| 8| return -1; 3107| 8| } 3108| | 3109| 743| source = (ogs_nas_ue_radio_capability_id_availability_t *)pkbuf->data; 3110| | 3111| 743| ue_radio_capability_id_availability->length = source->length; 3112| 743| size = ue_radio_capability_id_availability->length + sizeof(ue_radio_capability_id_availability->length); 3113| | 3114| 743| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3114:9): [True: 6, False: 737] ------------------ 3115| 6| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 3116| 6| return -1; 3117| 6| } 3118| | 3119| 737| if (sizeof(*ue_radio_capability_id_availability) < size) return -1; ------------------ | Branch (3119:9): [True: 2, False: 735] ------------------ 3120| 735| memcpy(ue_radio_capability_id_availability, pkbuf->data - size, size); 3121| | 3122| 735| ogs_trace(" UE_RADIO_CAPABILITY_ID_AVAILABILITY - "); ------------------ | | 40| 735|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 735| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 735|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 735| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 735|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 735| 0, __VA_ARGS__) | | ------------------ ------------------ 3123| 735| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 735| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 735|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3124| | 3125| 735| return size; 3126| 737|} ogs_nas_eps_decode_ue_radio_capability_id_request: 3146| 350|{ 3147| 350| int size = 0; 3148| 350| ogs_nas_ue_radio_capability_id_request_t *source = NULL; 3149| | 3150| 350| if (pkbuf->len < 1) { ------------------ | Branch (3150:9): [True: 5, False: 345] ------------------ 3151| 5| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 3152| 5| return -1; 3153| 5| } 3154| | 3155| 345| source = (ogs_nas_ue_radio_capability_id_request_t *)pkbuf->data; 3156| | 3157| 345| ue_radio_capability_id_request->length = source->length; 3158| 345| size = ue_radio_capability_id_request->length + sizeof(ue_radio_capability_id_request->length); 3159| | 3160| 345| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3160:9): [True: 2, False: 343] ------------------ 3161| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 3162| 2| return -1; 3163| 2| } 3164| | 3165| 343| if (sizeof(*ue_radio_capability_id_request) < size) return -1; ------------------ | Branch (3165:9): [True: 1, False: 342] ------------------ 3166| 342| memcpy(ue_radio_capability_id_request, pkbuf->data - size, size); 3167| | 3168| 342| ogs_trace(" UE_RADIO_CAPABILITY_ID_REQUEST - "); ------------------ | | 40| 342|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 342| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 342|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 342| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 342|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 342| 0, __VA_ARGS__) | | ------------------ ------------------ 3169| 342| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 342| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 342|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3170| | 3171| 342| return size; 3172| 343|} ogs_nas_eps_decode_daylight_saving_time: 3192| 396|{ 3193| 396| int size = 0; 3194| 396| ogs_nas_daylight_saving_time_t *source = NULL; 3195| | 3196| 396| if (pkbuf->len < 1) { ------------------ | Branch (3196:9): [True: 8, False: 388] ------------------ 3197| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 3198| 8| return -1; 3199| 8| } 3200| | 3201| 388| source = (ogs_nas_daylight_saving_time_t *)pkbuf->data; 3202| | 3203| 388| daylight_saving_time->length = source->length; 3204| 388| size = daylight_saving_time->length + sizeof(daylight_saving_time->length); 3205| | 3206| 388| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3206:9): [True: 2, False: 386] ------------------ 3207| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 3208| 2| return -1; 3209| 2| } 3210| | 3211| 386| if (sizeof(*daylight_saving_time) < size) return -1; ------------------ | Branch (3211:9): [True: 1, False: 385] ------------------ 3212| 385| memcpy(daylight_saving_time, pkbuf->data - size, size); 3213| | 3214| 385| ogs_trace(" DAYLIGHT_SAVING_TIME - "); ------------------ | | 40| 385|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 385| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 385|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 385| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 385|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 385| 0, __VA_ARGS__) | | ------------------ ------------------ 3215| 385| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 385| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 385|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3216| | 3217| 385| return size; 3218| 386|} ogs_nas_eps_decode_ue_radio_capability_id: 3238| 1.09k|{ 3239| 1.09k| int size = 0; 3240| 1.09k| ogs_nas_ue_radio_capability_id_t *source = NULL; 3241| | 3242| 1.09k| if (pkbuf->len < 1) { ------------------ | Branch (3242:9): [True: 6, False: 1.08k] ------------------ 3243| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 3244| 6| return -1; 3245| 6| } 3246| | 3247| 1.08k| source = (ogs_nas_ue_radio_capability_id_t *)pkbuf->data; 3248| | 3249| 1.08k| ue_radio_capability_id->length = source->length; 3250| 1.08k| size = ue_radio_capability_id->length + sizeof(ue_radio_capability_id->length); 3251| | 3252| 1.08k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3252:9): [True: 5, False: 1.08k] ------------------ 3253| 5| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 3254| 5| return -1; 3255| 5| } 3256| | 3257| 1.08k| if (sizeof(*ue_radio_capability_id) < size) return -1; ------------------ | Branch (3257:9): [True: 0, False: 1.08k] ------------------ 3258| 1.08k| memcpy(ue_radio_capability_id, pkbuf->data - size, size); 3259| | 3260| 1.08k| ogs_trace(" UE_RADIO_CAPABILITY_ID - "); ------------------ | | 40| 1.08k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.08k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.08k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.08k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.08k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.08k| 0, __VA_ARGS__) | | ------------------ ------------------ 3261| 1.08k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.08k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.08k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3262| | 3263| 1.08k| return size; 3264| 1.08k|} ogs_nas_eps_decode_ue_radio_capability_id_deletion_indication: 3284| 2.45k|{ 3285| 2.45k| int size = sizeof(ogs_nas_ue_radio_capability_id_deletion_indication_t); 3286| | 3287| 2.45k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3287:9): [True: 0, False: 2.45k] ------------------ 3288| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 3289| 0| return -1; 3290| 0| } 3291| | 3292| 2.45k| memcpy(ue_radio_capability_id_deletion_indication, pkbuf->data - size, size); 3293| | 3294| 2.45k| ogs_trace(" UE_RADIO_CAPABILITY_ID_DELETION_INDICATION - "); ------------------ | | 40| 2.45k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2.45k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2.45k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2.45k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2.45k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2.45k| 0, __VA_ARGS__) | | ------------------ ------------------ 3295| 2.45k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 2.45k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 2.45k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3296| | 3297| 2.45k| return size; 3298| 2.45k|} ogs_nas_eps_decode_wus_assistance_information: 3316| 1.06k|{ 3317| 1.06k| int size = 0; 3318| 1.06k| ogs_nas_wus_assistance_information_t *source = NULL; 3319| | 3320| 1.06k| if (pkbuf->len < 1) { ------------------ | Branch (3320:9): [True: 6, False: 1.05k] ------------------ 3321| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 3322| 6| return -1; 3323| 6| } 3324| | 3325| 1.05k| source = (ogs_nas_wus_assistance_information_t *)pkbuf->data; 3326| | 3327| 1.05k| wus_assistance_information->length = source->length; 3328| 1.05k| size = wus_assistance_information->length + sizeof(wus_assistance_information->length); 3329| | 3330| 1.05k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3330:9): [True: 3, False: 1.05k] ------------------ 3331| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 3332| 3| return -1; 3333| 3| } 3334| | 3335| 1.05k| if (sizeof(*wus_assistance_information) < size) return -1; ------------------ | Branch (3335:9): [True: 0, False: 1.05k] ------------------ 3336| 1.05k| memcpy(wus_assistance_information, pkbuf->data - size, size); 3337| | 3338| 1.05k| ogs_trace(" WUS_ASSISTANCE_INFORMATION - "); ------------------ | | 40| 1.05k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.05k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.05k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.05k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.05k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.05k| 0, __VA_ARGS__) | | ------------------ ------------------ 3339| 1.05k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.05k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.05k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3340| | 3341| 1.05k| return size; 3342| 1.05k|} ogs_nas_eps_decode_nb_s1_drx_parameter: 3362| 979|{ 3363| 979| int size = 0; 3364| 979| ogs_nas_nb_s1_drx_parameter_t *source = NULL; 3365| | 3366| 979| if (pkbuf->len < 1) { ------------------ | Branch (3366:9): [True: 7, False: 972] ------------------ 3367| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 3368| 7| return -1; 3369| 7| } 3370| | 3371| 972| source = (ogs_nas_nb_s1_drx_parameter_t *)pkbuf->data; 3372| | 3373| 972| nb_s1_drx_parameter->length = source->length; 3374| 972| size = nb_s1_drx_parameter->length + sizeof(nb_s1_drx_parameter->length); 3375| | 3376| 972| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3376:9): [True: 4, False: 968] ------------------ 3377| 4| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 3378| 4| return -1; 3379| 4| } 3380| | 3381| 968| if (sizeof(*nb_s1_drx_parameter) < size) return -1; ------------------ | Branch (3381:9): [True: 2, False: 966] ------------------ 3382| 966| memcpy(nb_s1_drx_parameter, pkbuf->data - size, size); 3383| | 3384| 966| ogs_trace(" NB_S1_DRX_PARAMETER - "); ------------------ | | 40| 966|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 966| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 966|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 966| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 966|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 966| 0, __VA_ARGS__) | | ------------------ ------------------ 3385| 966| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 966| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 966|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3386| | 3387| 966| return size; 3388| 968|} ogs_nas_eps_decode_imsi_offset: 3408| 969|{ 3409| 969| int size = 0; 3410| 969| ogs_nas_imsi_offset_t *source = NULL; 3411| | 3412| 969| if (pkbuf->len < 1) { ------------------ | Branch (3412:9): [True: 9, False: 960] ------------------ 3413| 9| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 9|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 3414| 9| return -1; 3415| 9| } 3416| | 3417| 960| source = (ogs_nas_imsi_offset_t *)pkbuf->data; 3418| | 3419| 960| imsi_offset->length = source->length; 3420| 960| size = imsi_offset->length + sizeof(imsi_offset->length); 3421| | 3422| 960| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3422:9): [True: 1, False: 959] ------------------ 3423| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 3424| 1| return -1; 3425| 1| } 3426| | 3427| 959| if (sizeof(*imsi_offset) < size) return -1; ------------------ | Branch (3427:9): [True: 2, False: 957] ------------------ 3428| 957| memcpy(imsi_offset, pkbuf->data - size, size); 3429| | 3430| 957| ogs_trace(" IMSI_OFFSET - "); ------------------ | | 40| 957|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 957| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 957|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 957| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 957|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 957| 0, __VA_ARGS__) | | ------------------ ------------------ 3431| 957| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 957| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 957|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3432| | 3433| 957| return size; 3434| 959|} ogs_nas_eps_decode_ue_request_type: 3454| 904|{ 3455| 904| int size = 0; 3456| 904| ogs_nas_ue_request_type_t *source = NULL; 3457| | 3458| 904| if (pkbuf->len < 1) { ------------------ | Branch (3458:9): [True: 10, False: 894] ------------------ 3459| 10| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 3460| 10| return -1; 3461| 10| } 3462| | 3463| 894| source = (ogs_nas_ue_request_type_t *)pkbuf->data; 3464| | 3465| 894| ue_request_type->length = source->length; 3466| 894| size = ue_request_type->length + sizeof(ue_request_type->length); 3467| | 3468| 894| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3468:9): [True: 3, False: 891] ------------------ 3469| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 3470| 3| return -1; 3471| 3| } 3472| | 3473| 891| if (sizeof(*ue_request_type) < size) return -1; ------------------ | Branch (3473:9): [True: 6, False: 885] ------------------ 3474| 885| memcpy(ue_request_type, pkbuf->data - size, size); 3475| | 3476| 885| ogs_trace(" UE_REQUEST_TYPE - "); ------------------ | | 40| 885|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 885| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 885|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 885| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 885|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 885| 0, __VA_ARGS__) | | ------------------ ------------------ 3477| 885| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 885| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 885|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3478| | 3479| 885| return size; 3480| 891|} ogs_nas_eps_decode_paging_restriction: 3500| 773|{ 3501| 773| int size = 0; 3502| 773| ogs_nas_paging_restriction_t *source = NULL; 3503| | 3504| 773| if (pkbuf->len < 1) { ------------------ | Branch (3504:9): [True: 8, False: 765] ------------------ 3505| 8| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 3506| 8| return -1; 3507| 8| } 3508| | 3509| 765| source = (ogs_nas_paging_restriction_t *)pkbuf->data; 3510| | 3511| 765| paging_restriction->length = source->length; 3512| 765| size = paging_restriction->length + sizeof(paging_restriction->length); 3513| | 3514| 765| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3514:9): [True: 6, False: 759] ------------------ 3515| 6| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 3516| 6| return -1; 3517| 6| } 3518| | 3519| 759| if (sizeof(*paging_restriction) < size) return -1; ------------------ | Branch (3519:9): [True: 2, False: 757] ------------------ 3520| 757| memcpy(paging_restriction, pkbuf->data - size, size); 3521| | 3522| 757| ogs_trace(" PAGING_RESTRICTION - "); ------------------ | | 40| 757|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 757| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 757|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 757| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 757|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 757| 0, __VA_ARGS__) | | ------------------ ------------------ 3523| 757| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 757| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 757|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3524| | 3525| 757| return size; 3526| 759|} ogs_nas_eps_decode_eps_additional_request_result: 3546| 354|{ 3547| 354| int size = 0; 3548| 354| ogs_nas_eps_additional_request_result_t *source = NULL; 3549| | 3550| 354| if (pkbuf->len < 1) { ------------------ | Branch (3550:9): [True: 6, False: 348] ------------------ 3551| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 3552| 6| return -1; 3553| 6| } 3554| | 3555| 348| source = (ogs_nas_eps_additional_request_result_t *)pkbuf->data; 3556| | 3557| 348| eps_additional_request_result->length = source->length; 3558| 348| size = eps_additional_request_result->length + sizeof(eps_additional_request_result->length); 3559| | 3560| 348| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3560:9): [True: 1, False: 347] ------------------ 3561| 1| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 1|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1| 0, __VA_ARGS__) | | ------------------ ------------------ 3562| 1| return -1; 3563| 1| } 3564| | 3565| 347| if (sizeof(*eps_additional_request_result) < size) return -1; ------------------ | Branch (3565:9): [True: 1, False: 346] ------------------ 3566| 346| memcpy(eps_additional_request_result, pkbuf->data - size, size); 3567| | 3568| 346| ogs_trace(" EPS_ADDITIONAL_REQUEST_RESULT - "); ------------------ | | 40| 346|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 346| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 346|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 346| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 346|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 346| 0, __VA_ARGS__) | | ------------------ ------------------ 3569| 346| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 346| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 346|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3570| | 3571| 346| return size; 3572| 347|} ogs_nas_eps_decode_unavailability_information: 3592| 231|{ 3593| 231| int size = 0; 3594| 231| ogs_nas_unavailability_information_t *source = NULL; 3595| | 3596| 231| if (pkbuf->len < 1) { ------------------ | Branch (3596:9): [True: 2, False: 229] ------------------ 3597| 2| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 3598| 2| return -1; 3599| 2| } 3600| | 3601| 229| source = (ogs_nas_unavailability_information_t *)pkbuf->data; 3602| | 3603| 229| unavailability_information->length = source->length; 3604| 229| size = unavailability_information->length + sizeof(unavailability_information->length); 3605| | 3606| 229| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3606:9): [True: 2, False: 227] ------------------ 3607| 2| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 2|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 2| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 2|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 2| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 2|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 2| 0, __VA_ARGS__) | | ------------------ ------------------ 3608| 2| return -1; 3609| 2| } 3610| | 3611| 227| if (sizeof(*unavailability_information) < size) return -1; ------------------ | Branch (3611:9): [True: 2, False: 225] ------------------ 3612| 225| memcpy(unavailability_information, pkbuf->data - size, size); 3613| | 3614| 225| ogs_trace(" UNAVAILABILITY_INFORMATION - "); ------------------ | | 40| 225|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 225| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 225|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 225| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 225|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 225| 0, __VA_ARGS__) | | ------------------ ------------------ 3615| 225| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 225| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 225|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3616| | 3617| 225| return size; 3618| 227|} ogs_nas_eps_decode_detach_type: 3638| 9|{ 3639| 9| int size = sizeof(ogs_nas_detach_type_t); 3640| | 3641| 9| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3641:9): [True: 0, False: 9] ------------------ 3642| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 3643| 0| return -1; 3644| 0| } 3645| | 3646| 9| memcpy(detach_type, pkbuf->data - size, size); 3647| | 3648| 9| ogs_trace(" DETACH_TYPE - "); ------------------ | | 40| 9|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 9| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 9| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 9|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 9| 0, __VA_ARGS__) | | ------------------ ------------------ 3649| 9| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 9| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 9|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3650| | 3651| 9| return size; 3652| 9|} ogs_nas_eps_decode_unavailability_configuration: 3672| 456|{ 3673| 456| int size = 0; 3674| 456| ogs_nas_unavailability_configuration_t *source = NULL; 3675| | 3676| 456| if (pkbuf->len < 1) { ------------------ | Branch (3676:9): [True: 5, False: 451] ------------------ 3677| 5| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 5|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 5| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 5|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 5| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 5|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 5| 0, __VA_ARGS__) | | ------------------ ------------------ 3678| 5| return -1; 3679| 5| } 3680| | 3681| 451| source = (ogs_nas_unavailability_configuration_t *)pkbuf->data; 3682| | 3683| 451| unavailability_configuration->length = source->length; 3684| 451| size = unavailability_configuration->length + sizeof(unavailability_configuration->length); 3685| | 3686| 451| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3686:9): [True: 3, False: 448] ------------------ 3687| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 3688| 3| return -1; 3689| 3| } 3690| | 3691| 448| if (sizeof(*unavailability_configuration) < size) return -1; ------------------ | Branch (3691:9): [True: 3, False: 445] ------------------ 3692| 445| memcpy(unavailability_configuration, pkbuf->data - size, size); 3693| | 3694| 445| ogs_trace(" UNAVAILABILITY_CONFIGURATION - "); ------------------ | | 40| 445|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 445| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 445|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 445| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 445|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 445| 0, __VA_ARGS__) | | ------------------ ------------------ 3695| 445| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 445| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 445|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3696| | 3697| 445| return size; 3698| 448|} ogs_nas_eps_decode_ue_information_request: 3718| 422|{ 3719| 422| int size = sizeof(ogs_nas_ue_information_request_t); 3720| | 3721| 422| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3721:9): [True: 0, False: 422] ------------------ 3722| 0| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 0|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 0| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 0|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 0| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 0|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 0| 0, __VA_ARGS__) | | ------------------ ------------------ 3723| 0| return -1; 3724| 0| } 3725| | 3726| 422| memcpy(ue_information_request, pkbuf->data - size, size); 3727| | 3728| 422| ogs_trace(" UE_INFORMATION_REQUEST - "); ------------------ | | 40| 422|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 422| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 422|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 422| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 422|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 422| 0, __VA_ARGS__) | | ------------------ ------------------ 3729| 422| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 422| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 422|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3730| | 3731| 422| return size; 3732| 422|} ogs_nas_eps_decode_ue_coarse_location_information: 3750| 259|{ 3751| 259| int size = 0; 3752| 259| ogs_nas_ue_coarse_location_information_t *source = NULL; 3753| | 3754| 259| if (pkbuf->len < 1) { ------------------ | Branch (3754:9): [True: 3, False: 256] ------------------ 3755| 3| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 3756| 3| return -1; 3757| 3| } 3758| | 3759| 256| source = (ogs_nas_ue_coarse_location_information_t *)pkbuf->data; 3760| | 3761| 256| ue_coarse_location_information->length = source->length; 3762| 256| size = ue_coarse_location_information->length + sizeof(ue_coarse_location_information->length); 3763| | 3764| 256| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3764:9): [True: 3, False: 253] ------------------ 3765| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 3766| 3| return -1; 3767| 3| } 3768| | 3769| 253| if (sizeof(*ue_coarse_location_information) < size) return -1; ------------------ | Branch (3769:9): [True: 2, False: 251] ------------------ 3770| 251| memcpy(ue_coarse_location_information, pkbuf->data - size, size); 3771| | 3772| 251| ogs_trace(" UE_COARSE_LOCATION_INFORMATION - "); ------------------ | | 40| 251|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 251| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 251|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 251| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 251|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 251| 0, __VA_ARGS__) | | ------------------ ------------------ 3773| 251| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 251| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 251|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3774| | 3775| 251| return size; 3776| 253|} ogs_nas_eps_decode_registration_wait_range: 3796| 1.33k|{ 3797| 1.33k| int size = 0; 3798| 1.33k| ogs_nas_registration_wait_range_t *source = NULL; 3799| | 3800| 1.33k| if (pkbuf->len < 1) { ------------------ | Branch (3800:9): [True: 6, False: 1.32k] ------------------ 3801| 6| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 6|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 6| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 6|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 6| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 6|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 6| 0, __VA_ARGS__) | | ------------------ ------------------ 3802| 6| return -1; 3803| 6| } 3804| | 3805| 1.32k| source = (ogs_nas_registration_wait_range_t *)pkbuf->data; 3806| | 3807| 1.32k| registration_wait_range->length = source->length; 3808| 1.32k| size = registration_wait_range->length + sizeof(registration_wait_range->length); 3809| | 3810| 1.32k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3810:9): [True: 10, False: 1.31k] ------------------ 3811| 10| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 3812| 10| return -1; 3813| 10| } 3814| | 3815| 1.31k| if (sizeof(*registration_wait_range) < size) return -1; ------------------ | Branch (3815:9): [True: 2, False: 1.31k] ------------------ 3816| 1.31k| memcpy(registration_wait_range, pkbuf->data - size, size); 3817| | 3818| 1.31k| ogs_trace(" REGISTRATION_WAIT_RANGE - "); ------------------ | | 40| 1.31k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.31k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.31k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.31k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.31k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.31k| 0, __VA_ARGS__) | | ------------------ ------------------ 3819| 1.31k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.31k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.31k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3820| | 3821| 1.31k| return size; 3822| 1.31k|} ogs_nas_eps_decode_plmn_identity: 3842| 451|{ 3843| 451| int size = 0; 3844| 451| ogs_nas_plmn_identity_t *source = NULL; 3845| | 3846| 451| if (pkbuf->len < 1) { ------------------ | Branch (3846:9): [True: 4, False: 447] ------------------ 3847| 4| ogs_error("Not enough pkbuf [len:%d]", pkbuf->len); ------------------ | | 36| 4|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 4| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 4|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 4| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 4|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 4| 0, __VA_ARGS__) | | ------------------ ------------------ 3848| 4| return -1; 3849| 4| } 3850| | 3851| 447| source = (ogs_nas_plmn_identity_t *)pkbuf->data; 3852| | 3853| 447| plmn_identity->length = source->length; 3854| 447| size = plmn_identity->length + sizeof(plmn_identity->length); 3855| | 3856| 447| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3856:9): [True: 3, False: 444] ------------------ 3857| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 3858| 3| return -1; 3859| 3| } 3860| | 3861| 444| if (sizeof(*plmn_identity) < size) return -1; ------------------ | Branch (3861:9): [True: 1, False: 443] ------------------ 3862| 443| memcpy(plmn_identity, pkbuf->data - size, size); 3863| | 3864| 443| ogs_trace(" PLMN_IDENTITY - "); ------------------ | | 40| 443|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 443| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 443|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 443| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 443|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 443| 0, __VA_ARGS__) | | ------------------ ------------------ 3865| 443| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 443| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 443|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3866| | 3867| 443| return size; 3868| 444|} ogs_nas_eps_decode_drx_parameter: 3888| 560|{ 3889| 560| int size = sizeof(ogs_nas_drx_parameter_t); 3890| | 3891| 560| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3891:9): [True: 7, False: 553] ------------------ 3892| 7| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 7|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 7| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 3893| 7| return -1; 3894| 7| } 3895| | 3896| 553| memcpy(drx_parameter, pkbuf->data - size, size); 3897| | 3898| 553| ogs_trace(" DRX_PARAMETER - "); ------------------ | | 40| 553|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 553| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 553|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 553| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 553|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 553| 0, __VA_ARGS__) | | ------------------ ------------------ 3899| 553| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 553| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 553|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3900| | 3901| 553| return size; 3902| 560|} ogs_nas_eps_decode_emm_cause: 3922| 1.24k|{ 3923| 1.24k| int size = sizeof(ogs_nas_emm_cause_t); 3924| | 3925| 1.24k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (3925:9): [True: 8, False: 1.23k] ------------------ 3926| 8| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 8|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 8| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 8|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 8| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 8|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 8| 0, __VA_ARGS__) | | ------------------ ------------------ 3927| 8| return -1; 3928| 8| } 3929| | 3930| 1.23k| memcpy(emm_cause, pkbuf->data - size, size); 3931| | 3932| 1.23k| ogs_trace(" EMM_CAUSE - "); ------------------ | | 40| 1.23k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.23k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.23k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.23k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.23k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.23k| 0, __VA_ARGS__) | | ------------------ ------------------ 3933| 1.23k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.23k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.23k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 3934| | 3935| 1.23k| return size; 3936| 1.24k|} ogs_nas_eps_decode_header_compression_configuration_status: 4617| 367|{ 4618| 367| int size = 0; 4619| 367| ogs_nas_header_compression_configuration_status_t *source = NULL; 4620| | 4621| 367| if (pkbuf->len < 1) { ------------------ | Branch (4621:9): [True: 7, False: 360] ------------------ 4622| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 4623| 7| return -1; 4624| 7| } 4625| | 4626| 360| source = (ogs_nas_header_compression_configuration_status_t *)pkbuf->data; 4627| | 4628| 360| header_compression_configuration_status->length = source->length; 4629| 360| size = header_compression_configuration_status->length + sizeof(header_compression_configuration_status->length); 4630| | 4631| 360| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (4631:9): [True: 3, False: 357] ------------------ 4632| 3| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 3|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 3| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 3|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 3| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 3|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 3| 0, __VA_ARGS__) | | ------------------ ------------------ 4633| 3| return -1; 4634| 3| } 4635| | 4636| 357| if (sizeof(*header_compression_configuration_status) < size) return -1; ------------------ | Branch (4636:9): [True: 1, False: 356] ------------------ 4637| 356| memcpy(header_compression_configuration_status, pkbuf->data - size, size); 4638| | 4639| 356| ogs_trace(" HEADER_COMPRESSION_CONFIGURATION_STATUS - "); ------------------ | | 40| 356|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 356| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 356|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 356| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 356|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 356| 0, __VA_ARGS__) | | ------------------ ------------------ 4640| 356| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 356| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 356|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 4641| | 4642| 356| return size; 4643| 357|} ogs_nas_eps_decode_s_f_satellite_operation_parameters: 5105| 1.20k|{ 5106| 1.20k| int size = 0; 5107| 1.20k| ogs_nas_s_f_satellite_operation_parameters_t *source = NULL; 5108| | 5109| 1.20k| if (pkbuf->len < 1) { ------------------ | Branch (5109:9): [True: 7, False: 1.20k] ------------------ 5110| 7| ogs_error("Not enough pkbuf [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, \ | | | | ------------------ | | | | | | 40| 7|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 7| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 7|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 7| 0, __VA_ARGS__) | | ------------------ ------------------ 5111| 7| return -1; 5112| 7| } 5113| | 5114| 1.20k| source = (ogs_nas_s_f_satellite_operation_parameters_t *)pkbuf->data; 5115| | 5116| 1.20k| s_f_satellite_operation_parameters->length = source->length; 5117| 1.20k| size = s_f_satellite_operation_parameters->length + sizeof(s_f_satellite_operation_parameters->length); 5118| | 5119| 1.20k| if (ogs_pkbuf_pull(pkbuf, size) == NULL) { ------------------ | Branch (5119:9): [True: 10, False: 1.19k] ------------------ 5120| 10| ogs_error("ogs_pkbuf_pull() failed [size:%d]", (int)size); ------------------ | | 36| 10|#define ogs_error(...) ogs_log_message(OGS_LOG_ERROR, 0, __VA_ARGS__) | | ------------------ | | | | 43| 10| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 10|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 10| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 10|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 10| 0, __VA_ARGS__) | | ------------------ ------------------ 5121| 10| return -1; 5122| 10| } 5123| | 5124| 1.19k| if (sizeof(*s_f_satellite_operation_parameters) < size) return -1; ------------------ | Branch (5124:9): [True: 2, False: 1.18k] ------------------ 5125| 1.18k| memcpy(s_f_satellite_operation_parameters, pkbuf->data - size, size); 5126| | 5127| 1.18k| ogs_trace(" S_F_SATELLITE_OPERATION_PARAMETERS - "); ------------------ | | 40| 1.18k|#define ogs_trace(...) ogs_log_message(OGS_LOG_TRACE, 0, __VA_ARGS__) | | ------------------ | | | | 43| 1.18k| ogs_log_printf(level, OGS_LOG_DOMAIN, \ | | | | ------------------ | | | | | | 40| 1.18k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | | | ------------------ | | | | 44| 1.18k| err, __FILE__, __LINE__, OGS_FUNC, \ | | | | ------------------ | | | | | | 50| 1.18k|#define OGS_FUNC __func__ | | | | ------------------ | | | | 45| 1.18k| 0, __VA_ARGS__) | | ------------------ ------------------ 5128| 1.18k| ogs_log_hexdump(OGS_LOG_TRACE, pkbuf->data - size, size); ------------------ | | 53| 1.18k| ogs_log_hexdump_func(level, OGS_LOG_DOMAIN, _d, _l) | | ------------------ | | | | 40| 1.18k|#define OGS_LOG_DOMAIN __ogs_nas_domain | | ------------------ ------------------ 5129| | 5130| 1.18k| return size; 5131| 1.19k|} initialize: 24| 1|void initialize(void) { 25| | 26| 1| ogs_pkbuf_config_t config; 27| | 28| 1| ogs_core_initialize(); 29| | 30| 1| ogs_pkbuf_default_init(&config); 31| 1| ogs_pkbuf_default_create(&config); 32| | 33| 1| initialized = 1; 34| 1|} LLVMFuzzerTestOneInput: 30| 3.91k|{ /* open5gs/tests/unit/nas-message-test.c */ 31| | 32| 3.91k| if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 26| 7.82k|#define kMinInputLength 5 ------------------ if (Size < kMinInputLength || Size > kMaxInputLength) { ------------------ | | 27| 3.91k|#define kMaxInputLength 1024 ------------------ | Branch (32:9): [True: 4, False: 3.91k] | Branch (32:35): [True: 21, False: 3.88k] ------------------ 33| 25| return 1; 34| 25| } 35| | 36| 3.88k| if (!initialized) { ------------------ | Branch (36:9): [True: 1, False: 3.88k] ------------------ 37| 1| initialize(); 38| 1| ogs_log_install_domain(&__ogs_nas_domain, "nas", OGS_LOG_NONE); 39| 1| } 40| | 41| 3.88k| int result; 42| 3.88k| ogs_pkbuf_t *pkbuf; 43| 3.88k| ogs_nas_eps_message_t message; 44| | 45| 3.88k| pkbuf = ogs_pkbuf_alloc(NULL, OGS_MAX_SDU_LEN); ------------------ | | 87| 3.88k| ogs_pkbuf_alloc_debug(pool, size, OGS_FILE_LINE) | | ------------------ | | | | 213| 3.88k|#define OGS_FILE_LINE __FILE__ ":" OGS_STRINGIFY(__LINE__) | | | | ------------------ | | | | | | 167| 3.88k|#define OGS_STRINGIFY(n) OGS_STRINGIFY_HELPER(n) | | | | | | ------------------ | | | | | | | | 168| 3.88k|#define OGS_STRINGIFY_HELPER(n) #n | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 46| 3.88k| if (pkbuf == NULL) { ------------------ | Branch (46:9): [True: 0, False: 3.88k] ------------------ 47| 0| return 1; 48| 0| } 49| | 50| 3.88k| ogs_pkbuf_put_data(pkbuf, Data, Size); 51| | 52| 3.88k| result = ogs_nas_emm_decode(&message, pkbuf); 53| | 54| 3.88k| ogs_pkbuf_free(pkbuf); 55| | 56| 3.88k| return result; 57| 3.88k|}